@esfaenza/flow-builder 20.3.32 → 20.3.34

package/index.d.ts

@@ -1,7 +1,7 @@
 import * as _angular_core from '@angular/core';
 import { InjectionToken, Signal, AfterViewChecked } from '@angular/core';
 import * as _esfaenza_flow_builder from '@esfaenza/flow-builder';
-import { EFMarkerType, EFConnectableSide } from '@foblex/flow';
+import { EFMarkerType, EFConnectableSide, EFResizeHandleType } from '@foblex/flow';
 import { CdkDragMove, CdkDragEnd } from '@angular/cdk/drag-drop';
 
 /**
@@ -683,12 +683,46 @@ interface FlowDefinition {
     /** Non supportati: conservati nel round-trip ma non creabili dalla palette. */
     steps?: FlowUnsupportedNode[];
     experiments?: FlowUnsupportedNode[];
+    /** §3.6 — riquadri di raggruppamento: commenti sul canvas, nessun effetto sull'esecuzione. */
+    groups?: FlowGroup[];
     apiVersion?: string;
     timeZoneSidKey?: string;
     triggerOrder?: number;
     isTemplate?: boolean;
     customProperties?: FlowCustomProperty[];
 }
+/**
+ * §3.6 — un riquadro di raggruppamento: l'unica collection del radice che **non contiene node**.
+ *
+ * E' documentazione, non esecuzione: nessun connector, nessuna raggiungibilita', il runtime non
+ * lo legge mai. Da lì vengono le due cose che sorprendono chi lo tratta come un elemento:
+ *
+ *  - il `name` **non** entra nello spazio dei nomi dei riferimenti (§3.3), perche' non c'e'
+ *    nessun riferimento da rendere ambiguo: un riquadro omonimo di una variabile non e'
+ *    `NAME_DUPLICATED`, e l'unicita' si verifica **fra i riquadri** (`GROUP_NAME_DUPLICATED`);
+ *  - l'appartenenza la dichiara `members`, non la geometria: il rettangolo dice come si disegna,
+ *    `members` chi c'e' dentro. Con un auto-layout le coordinate valgono 0 e un riquadro
+ *    conterrebbe tutto o niente, e senza `members` non sarebbe implementabile «sposto il
+ *    riquadro, si spostano i node».
+ */
+interface FlowGroup {
+    /** Identificatore del riquadro, univoco **fra i riquadri** (§3.6). */
+    name?: string;
+    /** Intestazione mostrata sulla barra del riquadro. */
+    label?: string;
+    /** Il testo del commento. */
+    description?: string;
+    locationX?: number;
+    locationY?: number;
+    /** `0` (o assente) significa «calcolala sui membri» (§3.6). */
+    width?: number;
+    height?: number;
+    /** Token concordato fra editor e backend: la libreria non lo interpreta. */
+    color?: string;
+    isCollapsed?: boolean;
+    /** I `name` dei node contenuti. Un nome rimasto indietro e' normale, non un difetto (§3.6). */
+    members?: string[];
+}
 /** Le collection di node: `metadataProperty` del dizionario `elementTypes` (§3.2). */
 declare const FLOW_NODE_COLLECTIONS: readonly ["screens", "dynamicScreens", "assignments", "decisions", "loops", "collectionProcessors", "recordLookups", "recordCreates", "recordUpdates", "recordDeletes", "recordRollbacks", "actionCalls", "scriptPluginCalls", "subflows", "transforms", "waits", "customErrors", "orchestratedStages", "steps", "experiments"];
 type FlowNodeCollection = (typeof FLOW_NODE_COLLECTIONS)[number];
@@ -1219,6 +1253,24 @@ interface FlowOutlineConnection {
     label?: string | null;
     isGoTo?: boolean;
 }
+/**
+ * §3.6, §6.4 — un riquadro di raggruppamento come arriva nell'outline: gli stessi campi del
+ * documento, con i **soli membri che corrispondono a un node esistente**. Quelli rimasti
+ * indietro sono omessi qui e segnalati dalla validazione (`GROUP_MEMBER_UNKNOWN`, un avviso):
+ * chi disegna non deve filtrarli di nuovo.
+ */
+interface FlowOutlineGroup {
+    name: string;
+    label?: string | null;
+    description?: string | null;
+    locationX?: number;
+    locationY?: number;
+    width?: number;
+    height?: number;
+    color?: string | null;
+    isCollapsed?: boolean;
+    members?: string[];
+}
 interface FlowOutline {
     flowName?: string | null;
     label?: string | null;
@@ -1227,6 +1279,8 @@ interface FlowOutline {
     entryElementName?: string | null;
     nodes: FlowOutlineNode[];
     connections: FlowOutlineConnection[];
+    /** I riquadri (§3.6): si disegnano **sotto** i node e non hanno archi. */
+    groups?: FlowOutlineGroup[];
 }
 type FlowInterviewStatus = 'Completed' | 'WaitingForScreen' | 'Paused' | 'Suspended'
 /** **Non** e' un errore HTTP: la richiesta e' riuscita, il flow e' fallito (§6.5). */
@@ -2257,6 +2311,31 @@ declare function removeField(screen: FlowDynamicScreen, path: FlowScreenFieldPat
 declare function moveField(screen: FlowDynamicScreen, from: FlowScreenFieldPath, toParent: FlowScreenFieldPath, toIndex: number): FlowScreenFieldPath | undefined;
 /** Duplica un campo accanto all'originale, rinominandolo: i nomi restano unici (§3.3). */
 declare function duplicateField(screen: FlowDynamicScreen, path: FlowScreenFieldPath, newName: string): FlowScreenFieldPath | undefined;
+/**
+ * Il `path` di un rilievo di validazione tradotto nel percorso del campo che riguarda.
+ *
+ * Serve a far sì che il clic su un problema porti **sul campo**, non solo sull'elemento: su una
+ * schermata da venti campi «apro la dialog e cercalo» significa contare i figli a mano, e con un
+ * path a indici (`fields[1].fields[1].fields[0]`) contarli e' letteralmente l'unico modo.
+ *
+ * Il `path` e' testo libero deciso dal backend (§7), e i due formati che si incontrano sono
+ * **entrambi** legittimi: per indice (`fields[1]`) e per nome (`fields[Sezione_1]`). Si
+ * accettano tutti e due, perche' un editor che ne capisce uno solo funziona con metà dei
+ * rilievi e non c'e' modo di accorgersene. Cio' che segue i campi (`.defaultValue.formulaExpression`)
+ * si ignora: individua il campo, non il sottocampo, ed e' il campo che va selezionato.
+ *
+ * `null` quando il path non nomina nessun campo (un rilievo sull'elemento) o quando il campo non
+ * esiste piu': una selezione che punta al vuoto mostrerebbe le proprieta' di un altro campo.
+ */
+declare function parseFieldPath(screen: FlowDynamicScreen | undefined, path: string | null | undefined): FlowScreenFieldPath | null;
+/**
+ * Il percorso di un campo scritto **per nome**: `Indirizzo di residenza › Colonna_3 › CAP`.
+ *
+ * E' l'altra metà dello stesso problema: `fields[1].fields[1].fields[2]` e' un percorso che
+ * l'utente non puo' seguire, e il pannello dei problemi lo stampava così com'era. I nomi li ha
+ * il documento, quindi tradurli e' compito dell'editor e non del backend.
+ */
+declare function describeFieldPath(screen: FlowDynamicScreen | undefined, path: FlowScreenFieldPath | null): string;
 
 /**
  * I dynamic choice set — FRONTEND.md §5.2.
@@ -2800,6 +2879,149 @@ declare function isEmptyReferenceFilter(filter: FlowReferenceFilter | undefined)
 declare function matchesReferenceFilter(entry: FlowTypedEntry, filter: FlowReferenceFilter): boolean;
 declare function filterReferences(references: readonly FlowReference[], filter: FlowReferenceFilter | undefined): FlowReference[];
 
+/**
+ * I riquadri di raggruppamento — FRONTEND.md §3.6.
+ *
+ * Logica pura: geometria e appartenenza. Il documento resta la fonte di verita' e lo scrive
+ * {@link FlowDocumentStore}; qui non si tocca nessun signal.
+ *
+ * Le due cose che un riquadro non lascia indovinare, e che stanno tutte e due qui:
+ *
+ *  - **la geometria puo' essere assente.** `width`/`height` a 0 significa «calcolala sui membri»
+ *    (§3.6), quindi il rettangolo da disegnare non e' cio' che sta scritto nel documento:
+ *    e' {@link groupRect}, che ripiega sull'ingombro dei membri piu' il respiro
+ *    dell'intestazione. Leggere `width` direttamente disegna riquadri di larghezza zero, che
+ *    non si vedono e non si possono nemmeno afferrare per correggerli;
+ *  - **l'appartenenza la dichiara `members`, non la geometria** (§3.6, regola 2). La geometria
+ *    serve solo a **calcolarla** quando l'utente trascina un node dentro o fuori
+ *    ({@link membersInside}), e il risultato va scritto nel documento. Il contrario — dedurre
+ *    l'appartenenza dai rettangoli a ogni disegno — con un auto-layout (tutte le coordinate a 0)
+ *    metterebbe tutti i node in tutti i riquadri.
+ */
+
+/** Il rettangolo di un node o di un riquadro, in coordinate del canvas. */
+interface FlowRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * Altezza della barra del titolo. Serve due volte: e' il respiro sopra i membri quando la
+ * geometria si calcola, ed e' l'altezza del riquadro **chiuso**.
+ */
+declare const GROUP_HEADER_HEIGHT = 30;
+/** Respiro fra il bordo del riquadro e i node che contiene. */
+declare const GROUP_PADDING = 28;
+/** Sotto queste misure il riquadro non si afferra piu': niente titolo, niente maniglia. */
+declare const GROUP_MIN_WIDTH = 160;
+declare const GROUP_MIN_HEIGHT = 90;
+/**
+ * I colori che l'editor propone. `color` e' «un token concordato fra editor e backend» (§3.6),
+ * quindi questo elenco e' una **proposta**, non un dizionario autoritativo: un token che non e'
+ * qui non e' un errore, si disegna con il colore neutro e resta scritto com'e'.
+ */
+declare const FLOW_GROUP_COLORS: ReadonlyArray<{
+    value: string;
+    label: string;
+}>;
+/** La classe che porta il colore. Token sconosciuto → neutro: la libreria non lo interpreta. */
+declare function groupColorClass(color: string | undefined): string;
+/**
+ * L'ingombro di un insieme di rettangoli, piu' il respiro. E' cio' che serve sia a calcolare la
+ * geometria di un riquadro senza misure, sia a crearne uno **attorno alla selezione**.
+ */
+declare function boundsAround(rects: readonly FlowRect[]): FlowRect | null;
+/**
+ * Il rettangolo da disegnare. `width`/`height` a 0 o assenti significano «calcolala sui membri»
+ * (§3.6): si prende l'ingombro dei membri **presenti** — un `members` che nomina un node
+ * cancellato e' normale (§3.6, regola 3) — e se non ne resta nemmeno uno si tiene una misura
+ * minima nel punto dichiarato, perche' un riquadro vuoto deve restare afferrabile per essere
+ * riempito o cancellato.
+ */
+declare function groupRect(group: FlowGroup, memberRects: readonly FlowRect[]): FlowRect;
+/** `true` se la geometria del riquadro e' calcolata sui membri invece che dichiarata. */
+declare function hasAutoSize(group: FlowGroup): boolean;
+/**
+ * I node che il rettangolo contiene, per **centro** e non per intersezione: un node che sporge
+ * da un bordo appartiene al riquadro in cui sta la sua parte maggiore, e con l'intersezione un
+ * node in mezzo a due riquadri finirebbe in entrambi.
+ *
+ * L'ordine e' quello dei node passati, così un `members` ricalcolato non cambia solo perche' si
+ * e' spostato qualcosa.
+ */
+declare function membersInside(rect: FlowRect, nodes: ReadonlyArray<{
+    name: string;
+    rect: FlowRect;
+}>): string[];
+/**
+ * L'elenco dei membri dopo un trascinamento: cio' che il rettangolo contiene, **piu'** due
+ * conservazioni che sembrano dettagli e non lo sono.
+ *
+ *  - **l'ordine di prima si mantiene.** `membersInside` risponde nell'ordine delle collection,
+ *    quindi adottarlo tale e quale riscriveva l'elenco di **ogni** riquadro a ogni spostamento
+ *    di un node qualunque: il documento risultava modificato senza che nulla fosse cambiato, e
+ *    il diff del salvataggio era pieno di righe rimescolate;
+ *  - **i membri che non sono node restano.** Un nome che non corrisponde a nessun node e' cio'
+ *    che resta dopo una cancellazione (§3.6, regola 3): non e' un difetto, e' un avviso da
+ *    ripulire — e ripulirlo di soppiatto mentre si trascina un altro elemento farebbe sparire
+ *    l'avviso senza che nessuno l'abbia deciso. La ripulitura e' un comando, non un effetto
+ *    collaterale.
+ */
+declare function recomputeMembers(previous: readonly string[] | undefined, inside: readonly string[], isNode: (name: string) => boolean): string[];
+/** Due elenchi di membri sono lo stesso elenco: evita di scrivere il documento per niente. */
+declare function sameMembers(left: readonly string[] | undefined, right: readonly string[]): boolean;
+
+/**
+ * Innestare un elemento **su un arco** — cioe' in mezzo a un percorso già collegato.
+ *
+ * Perche' esiste: senza, aggiungere un passo in mezzo a una catena e' tutto lavoro manuale.
+ * L'elemento nasce scollegato nel punto del rilascio, poi si riscrivono **due** connettori a
+ * mano (quello di chi precede e quello del nuovo elemento) e infine si trascina il node al suo
+ * posto — su un flow di quaranta elementi distanti duecento pixel e' il gesto piu' costoso che
+ * l'editor chiede.
+ *
+ * Qui c'e' solo il **piano**: dove va il node, quale sua uscita riprende il percorso, e cosa
+ * va spostato per fargli spazio. Applicarlo e' dello store, che lo fa in una mutazione sola —
+ * un annulla, non quattro.
+ *
+ * Due cose non ovvie.
+ *
+ * La prima: **quale uscita riprende il percorso** non e' «la prima». Una Decision riprende dal
+ * ramo `default` («nessuna regola vera»), non dalla prima regola, perche' le regole sono cio'
+ * che l'autore deve ancora scrivere; un Loop riprende da `loopEnd`, perche' `loopNext` e' il
+ * corpo. E un Custom Error non riprende affatto: interrompe l'esecuzione (§5.12), quindi
+ * innestarlo **scollega** cio' che stava a valle — chi applica il piano lo deve dire.
+ *
+ * La seconda: si sposta qualcosa **solo se serve**. Se fra i due elementi c'e' già spazio per
+ * un node, il resto del flow non si muove: un comando che riordina mezzo grafo per fare posto a
+ * un passo e' peggio del problema che risolve.
+ */
+
+/** Posizione di un elemento sul canvas, come la tiene il documento (§3.5). */
+interface FlowNodePosition {
+    x: number;
+    y: number;
+}
+/** Il piano di un innesto, pronto da applicare. */
+interface FlowEdgeInsertion {
+    /** L'arco su cui si innesta: chi precede e da quale sua uscita. */
+    from: string;
+    outletKey: string;
+    /** Cio' che l'arco raggiungeva: diventa la destinazione del nuovo elemento. */
+    to: string;
+    /** Dove nasce il nuovo elemento. */
+    position: FlowNodePosition;
+    /**
+     * Gli elementi da traslare in basso per fare spazio, con il delta. `null` se lo spazio
+     * c'era già: allora niente si muove.
+     */
+    shift: {
+        names: readonly string[];
+        deltaY: number;
+    } | null;
+}
+
 /** Un node come lo vede l'editor: il node piu' da dove viene. */
 interface FlowNodeRef {
     name: string;
@@ -2821,6 +3043,12 @@ interface FlowEdge {
     label?: string | null;
     isGoTo?: boolean;
 }
+/** Un riquadro di raggruppamento come lo vede l'editor (§3.6). */
+interface FlowGroupRef {
+    name: string;
+    index: number;
+    group: FlowGroup;
+}
 /** Una risorsa come la vede l'editor. */
 interface FlowResourceRef {
     name: string;
@@ -2846,6 +3074,18 @@ declare class FlowDocumentStore {
     readonly nodes: _angular_core.Signal<FlowNodeRef[]>;
     readonly nodeByName: _angular_core.Signal<Map<string, FlowNodeRef>>;
     readonly resources: _angular_core.Signal<FlowResourceRef[]>;
+    /**
+     * §3.6 — i riquadri di raggruppamento. Non sono node: non hanno uscite, non entrano negli
+     * archi e non partecipano alla raggiungibilita'.
+     */
+    readonly groups: _angular_core.Signal<FlowGroupRef[]>;
+    /**
+     * I nomi dei riquadri, che sono uno spazio dei nomi **a parte** (§3.6, regola 1): un riquadro
+     * non e' referenziabile, quindi un omonimo di una variabile non e' `NAME_DUPLICATED` e non
+     * deve comparire in {@link usedNames}. Un riquadro nuovo si confronta solo con questi
+     * (`GROUP_NAME_DUPLICATED`).
+     */
+    readonly groupNames: _angular_core.Signal<string[]>;
     /**
      * §3.3 — l'insieme dei nomi già usati, che e' **uno solo**: node, risorse e le **tre** cose che non
      * sono ne' l'uno ne' l'altro ma il cui nome e' la radice di un riferimento — step di orchestrazione,
@@ -2883,6 +3123,27 @@ declare class FlowDocumentStore {
     redo(): void;
     /** Inserisce un node nella collection indicata dal dizionario (`metadataProperty`). */
     addNode(collection: FlowNodeCollection, node: FlowAnyNode): void;
+    /**
+     * Inserisce un node **in mezzo a un arco**: chi precede punta al nuovo elemento, il nuovo
+     * elemento riprende il percorso da `resumeOutletKey`, e cio' che stava sotto si sposta per
+     * fargli spazio (§3.5).
+     *
+     * Tutto in **una** mutazione: sono quattro modifiche al documento, ma un solo gesto
+     * dell'utente, e annullarlo deve riportare il flow com'era — non a un terzo del lavoro.
+     *
+     * `resumeOutletKey` a `null` e' legittimo e non e' un errore: un Custom Error non ha uscite,
+     * quindi il percorso a valle resta scollegato. Lo decide {@link resumeOutletOf}, e chi chiama
+     * ha il compito di dirlo all'utente.
+     */
+    insertNodeOnEdge(collection: FlowNodeCollection, node: FlowAnyNode, insertion: FlowEdgeInsertion, resumeOutletKey: string | null): void;
+    /** Il node con quel nome dentro una copia di lavoro: la mappa dei nomi vale sul documento. */
+    private static nodeIn;
+    /**
+     * Scrive la destinazione di un'uscita **su un node**, senza passare dallo storico: la usano
+     * `setConnector` (una modifica sola) e `insertNodeOnEdge` (quattro modifiche in un passo).
+     * Staccare un ramo lo **omette** (§2) — vedi il commento di `setConnector`.
+     */
+    private static writeConnector;
     /** Modifica un node per nome. Il mutatore riceve la copia di lavoro. */
     updateNode(name: string, mutate: (node: FlowAnyNode) => void, options?: {
         silent?: boolean;
@@ -2903,6 +3164,8 @@ declare class FlowDocumentStore {
      * e' `CONNECTOR_TARGET_UNKNOWN`, cioe' un errore che blocca l'attivazione (§7).
      */
     removeNode(name: string): void;
+    /** Toglie un nome dai `members` di ogni riquadro; una lista vuota si omette (§2). */
+    private static forgetMember;
     /** Toglie i connector che puntano a un node scomparso, Start compreso. */
     private static clearReferencesTo;
     /**
@@ -2962,10 +3225,61 @@ declare class FlowDocumentStore {
             y: number;
         };
     }): string[];
-    /** Scrive la destinazione di un'uscita. `target` assente → il ramo si stacca del tutto. */
+    /**
+     * Scrive la destinazione di un'uscita. `target` assente → il ramo si stacca del tutto.
+     *
+     * Staccare un ramo lo **omette** (§2), non lascia un oggetto senza destinazione: quello
+     * sarebbe `CONNECTOR_TARGET_MISSING`, cioe' «ramo dichiarato ma non collegato» — un avviso —
+     * mentre un ramo assente e' `CONNECTOR_MISSING`, la nota «il percorso finisce qui», che per
+     * il default di una Decision e' legittimo (§3.5, §5.5). `isGoTo` non tiene in vita il
+     * connector: e' solo un suggerimento di disegno sull'arco, e senza arco non ha niente da
+     * suggerire — conservarlo faceva restare `{isGoTo: true}` e trasformava lo stacco di un arco
+     * «a salto» in un avviso. La scrittura vera e' in `writeConnector`, che condivide con
+     * l'innesto su un arco.
+     */
     setConnector(fromName: string, outletKey: string, target: string | undefined, isGoTo?: boolean): void;
     /** Rimuove un arco: il percorso finisce lì, che e' legittimo (§3.5). */
     removeConnector(fromName: string, outletKey: string): void;
+    addGroup(group: FlowGroup): void;
+    updateGroup(index: number, mutate: (group: FlowGroup) => void, options?: {
+        silent?: boolean;
+    }): void;
+    removeGroup(index: number): void;
+    /**
+     * Sposta un riquadro **e i suoi membri**, in una sola mutazione.
+     *
+     * E' il senso di `members` (§3.6, regola 2): il rettangolo dice come si disegna, l'elenco dice
+     * chi c'e' dentro, e spostare la cornice senza il contenuto sarebbe un gesto che non serve a
+     * nessuno. Un solo passo di storico perche' e' un solo gesto: annullarlo deve riportare
+     * indietro riquadro e node insieme, non prima gli uni e poi l'altro.
+     *
+     * `silent` per il trascinamento: il chiamante registra un solo passo alla fine.
+     */
+    moveGroup(name: string, x: number, y: number, options?: {
+        silent?: boolean;
+    }): void;
+    /**
+     * Scrive la geometria dichiarata di un riquadro: e' il ridimensionamento a mano.
+     *
+     * Scriverla e' anche il modo di **uscire** dal «calcolala sui membri» (§3.6): finche'
+     * `width`/`height` valgono 0 il rettangolo segue i membri, e allora ridimensionarlo non
+     * avrebbe effetto. L'appartenenza non si ricalcola qui: la ricalcola chi conosce le geometrie
+     * dei node, cioe' il canvas.
+     */
+    resizeGroup(name: string, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    /**
+     * Riscrive i membri di un riquadro. Ritorna `true` se il documento e' cambiato: il canvas lo
+     * chiama a ogni fine di trascinamento, e riscrivere un elenco identico riempirebbe lo storico
+     * di passi che non annullano niente.
+     */
+    setGroupMembers(name: string, members: readonly string[], options?: {
+        silent?: boolean;
+    }): boolean;
     addResource(collection: FlowResourceCollection, resource: Record<string, unknown>): void;
     updateResource(collection: FlowResourceCollection, index: number, mutate: (resource: Record<string, unknown>) => void): void;
     removeResource(collection: FlowResourceCollection, index: number): void;
@@ -3467,6 +3781,14 @@ declare function parseTargetConnectorId(id: string): string | null;
 /** L'id del node sul canvas: prefissato per non collidere con quello dei connettori. */
 declare function canvasNodeId(nodeName: string): string;
 declare function parseCanvasNodeId(id: string): string | null;
+/**
+ * L'id di un riquadro sul canvas (§3.6). Prefisso diverso da quello dei node perche' gli
+ * eventi della libreria — `fMoveNodes`, `fSelectionChange`, `fDeleteSelected` — portano node e
+ * riquadri **nello stesso elenco**: senza due prefissi distinti, spostare un riquadro finirebbe
+ * in `moveNode` di un node che non esiste, cioe' in un gesto che non fa niente.
+ */
+declare function canvasGroupId(groupName: string): string;
+declare function parseCanvasGroupId(id: string): string | null;
 interface FlowCanvasNode {
     /** Nome nel documento; `$start` per lo Start, che nel modello non ha nome. */
     name: string;
@@ -3524,6 +3846,40 @@ interface FlowCanvasEdge {
     label?: string | null;
     isGoTo: boolean;
 }
+/**
+ * Un riquadro di raggruppamento come lo disegna il canvas (§3.6).
+ *
+ * Il rettangolo qui dentro e' **già risolto**: `width`/`height` a 0 nel documento significano
+ * «calcolala sui membri», e il template non deve sapere quale delle due strade e' stata presa —
+ * disegnare la geometria del documento farebbe sparire i riquadri auto-dimensionati.
+ */
+interface FlowCanvasGroup {
+    name: string;
+    /** Id per il canvas, prefissato: vedi {@link canvasGroupId}. */
+    id: string;
+    label: string;
+    description?: string | null;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    /** La classe del colore; token fuori elenco → neutro (§3.6: la libreria non lo interpreta). */
+    colorClass: string;
+    isCollapsed: boolean;
+    /** Quanti membri corrispondono a un node esistente. */
+    memberCount: number;
+    /**
+     * Membri che nominano un node che non c'e' piu'. Non e' un difetto (§3.6, regola 3) ed e' un
+     * avviso: si mostra come tale, perche' e' l'unico posto in cui si vede senza validare.
+     */
+    unknownMembers: string[];
+    /** La geometria e' calcolata sui membri: ridimensionarlo la dichiara (§3.6). */
+    isAutoSized: boolean;
+}
 
 /**
  * Dimensioni nominali di un node, usate dal layout automatico.
@@ -3541,6 +3897,11 @@ declare class FlowCanvasComponent {
     private readonly store;
     private readonly dictionaries;
     private readonly validation;
+    /** L'elemento del componente: serve per convertire punti e per il hit test degli archi. */
+    private readonly host;
+    private readonly destroyRef;
+    /** Lo schema dei gesti: serve a scambiare «trascina per spostare la vista» con «per selezionare». */
+    private readonly gestures;
     /**
      * Marker di fine arco: la variante "all states" crea sia quello normale sia quello
      * selezionato, evitando che l'arco selezionato perda la punta.
@@ -3553,8 +3914,16 @@ declare class FlowCanvasComponent {
      * uscirebbe di fianco.
      */
     readonly sides: typeof EFConnectableSide;
+    /**
+     * I lati della maniglia di ridimensionamento di un riquadro. Una sola, in basso a destra:
+     * quattro maniglie su una cornice che sta **sotto** i node sarebbero quattro bersagli da
+     * prendere per sbaglio mentre si lavora al grafo.
+     */
+    readonly resizeHandles: typeof EFResizeHandleType;
     /** Il nome dell'elemento selezionato, `$start` per lo Start. */
     readonly selectedName: _angular_core.InputSignal<string | null>;
+    /** Il riquadro selezionato (§3.6): la selezione dei riquadri e' separata da quella dei node. */
+    readonly selectedGroupName: _angular_core.InputSignal<string | null>;
     /**
      * La selezione **intera**, quando ne fa parte piu' di un elemento: la libreria sa selezionare
      * a rettangolo e con `Ctrl`+`A`, e i comandi che agiscono su un blocco (copia, duplica,
@@ -3581,6 +3950,9 @@ declare class FlowCanvasComponent {
     readonly nodeOpened: _angular_core.OutputEmitterRef<string>;
     readonly nodeRemoveRequested: _angular_core.OutputEmitterRef<string>;
     readonly nodeDuplicateRequested: _angular_core.OutputEmitterRef<string>;
+    /** Un riquadro e' stato scelto: chi ascolta ne apre il pannello (§3.6). */
+    readonly groupSelected: _angular_core.OutputEmitterRef<string>;
+    readonly groupRemoveRequested: _angular_core.OutputEmitterRef<string>;
     /** Rilascio di un elemento dalla palette: tipo + punto nel sistema del canvas. */
     readonly elementDropped: _angular_core.OutputEmitterRef<{
         type: FlowElementType;
@@ -3588,11 +3960,28 @@ declare class FlowCanvasComponent {
         variant?: string;
         x: number;
         y: number;
+        /**
+         * L'arco sotto il puntatore al momento del rilascio, se ce n'era uno: allora l'elemento
+         * non nasce scollegato ma **in mezzo** a quel percorso.
+         */
+        edge?: {
+            from: string;
+            outletKey: string;
+            to: string;
+        };
     }>;
     private readonly canvas;
     private readonly _hasMovedViewport;
     /** L'utente ha zoomato o spostato la vista: il comando per rimetterla a posto ha senso. */
     readonly hasMovedViewport: _angular_core.Signal<boolean>;
+    /**
+     * L'ingrandimento corrente, in percentuale. Esiste perche' senza il numero non si capisce
+     * dove si e': su un flow grande si finisce all'8% con la rotella e sembra che il canvas si
+     * sia svuotato. Si aggiorna dagli eventi della libreria e dopo i nostri comandi — la
+     * libreria non espone un signal.
+     */
+    private readonly _zoomPercent;
+    readonly zoomPercent: _angular_core.Signal<number>;
     /** Il primo `fNodesRendered` inquadra, i successivi no: rifarlo combatterebbe con l'utente. */
     private hasFramedOnce;
     /**
@@ -3603,24 +3992,175 @@ declare class FlowCanvasComponent {
      * vista si spalancherebbe su una card sola.
      */
     onNodesRendered(): void;
+    /**
+     * Porta la vista **su** un elemento: e' l'arrivo della ricerca e del clic su un problema.
+     * Se si stava troppo indietro si avvicina, altrimenti la scala non si tocca — chi stava al
+     * 100% non vuole essere rimpicciolito per aver cercato un nome.
+     */
+    bringIntoView(name: string): void;
+    zoomIn(): void;
+    zoomOut(): void;
+    /**
+     * Torna al 100% **sull'elemento corrente**, non sull'origine del canvas: al 9% l'origine puo'
+     * essere a settemila pixel da cio' che si stava guardando, e un «100%» che porta nel vuoto e'
+     * peggio di nessun comando. Senza selezione l'ancora e' lo Start.
+     */
+    zoomToActual(): void;
+    private applyScale;
+    /** Rilegge la scala dalla libreria: la percentuale mostrata e' quella vera, non una stima. */
+    private syncZoom;
     /**
      * Qualunque zoom o panoramica accende il pulsante. `frameFlow` passa
      * `emitCanvasChange: false`, quindi il ritorno alla vista iniziale non rientra da qui e il
      * pulsante si spegne invece di restare acceso per sempre.
      */
     onCanvasChange(): void;
+    /**
+     * La modalita' selezione: sul canvas vuoto il trascinamento **seleziona** invece di spostare
+     * la vista.
+     *
+     * Esiste per un motivo solo, e non e' un vezzo. Spostare venti elementi su un flow di
+     * produzione richiede di selezionarli, e i due gesti che la libreria offre di serie —
+     * `Ctrl`+clic per aggiungere, `Shift`+trascina per il rettangolo — **non si vedono**: chi non
+     * li conosce sposta un elemento alla volta, che e' esattamente cio' che accadeva. Un
+     * interruttore visibile e' l'unico modo di annunciare un gesto.
+     *
+     * I due gesti di prima restano validi: questo cambia solo cosa fa il **trascinamento nudo**.
+     * Con la modalita' accesa la vista si sposta col tasto centrale — la rotella continua a
+     * zoomare — e per questo la modalita' e' un interruttore e non un cambio permanente: chi ha un
+     * mouse senza tasto centrale la spegne e torna a spostare la vista trascinando.
+     */
+    private readonly _isSelecting;
+    readonly isSelecting: _angular_core.Signal<boolean>;
+    toggleSelectionMode(): void;
+    /**
+     * Quanti elementi sono selezionati. Serve al suggerimento: «trascinane uno per spostarli
+     * tutti» e' l'informazione che rende utile la selezione, e senza dirla si continua a
+     * spostarli uno per uno anche dopo averli selezionati.
+     */
+    readonly selectionCount: _angular_core.Signal<number>;
     resetViewport(): void;
+    /**
+     * Inquadra il flow, ma **non oltre** {@link MIN_READABLE_SCALE}: quando ci starebbe tutto solo
+     * a una scala illeggibile si tiene quella e si inquadra l'**inizio**, che e' il posto da cui
+     * si comincia a leggerlo.
+     *
+     * Le due strade sono **alternative**, e non «fai il fit, poi correggi»: `fitToScreen` applica
+     * in modo asincrono (la libreria rimanda al frame successivo), quindi rileggerne la scala
+     * subito dopo restituisce quella di prima, e la correzione partiva sempre o mai. Per questo la
+     * scala di inquadratura la calcoliamo noi: le geometrie sono nel documento, non c'e' niente da
+     * chiedere alla libreria.
+     */
     private frameFlow;
+    /**
+     * La scala a cui il flow ci starebbe tutto, senza pavimento. Si calcola dal **documento**:
+     * posizioni e ingombri dei node li conosciamo (la larghezza dipende dal numero di rami), e la
+     * viewport e' l'elemento del componente. Non si chiede alla libreria perche' la sua risposta
+     * arriva un frame dopo.
+     */
+    private fittingScale;
     /** Raggiungibilita': backend se c'e', locale altrimenti. */
     private readonly reachability;
     readonly nodes: _angular_core.Signal<FlowCanvasNode[]>;
     private toCanvasNode;
     /** Gli archi con destinazione: solo questi diventano `<f-connection>`. */
     readonly edges: _angular_core.Signal<FlowCanvasEdge[]>;
+    /**
+     * Gli ingombri dei node, per l'appartenenza ai riquadri. Lo Start non c'e': `members` porta i
+     * `name` dei node (§3.6) e lo Start nel modello non ha nome.
+     */
+    private readonly nodeRects;
+    private rectsOf;
+    /**
+     * I riquadri da disegnare. Vengono dal **documento** e non dall'outline: l'outline li porta
+     * (§6.4) ma arriva mezzo secondo dopo, e una cornice che segue il trascinamento con un
+     * ritardo e' peggio di nessuna cornice. Dell'outline si usa la raggiungibilita', che il
+     * client non puo' sapere meglio del backend; la geometria la conosciamo noi.
+     */
+    readonly groups: _angular_core.Signal<FlowCanvasGroup[]>;
+    /**
+     * Ricalcola l'appartenenza dai rettangoli: e' il gesto «trascino un node dentro o fuori dal
+     * riquadro» della §3.6, regola 2 — la geometria non **e'** l'appartenenza, la **calcola**, e
+     * il risultato va scritto in `members`.
+     *
+     * `moved` sono i node appena trascinati, e servono per i riquadri **senza** geometria
+     * dichiarata: lì il rettangolo e' l'ingombro dei membri, quindi comprende sempre il membro
+     * che si sta portando fuori — che così non ne uscirebbe mai. Escludendolo dal calcolo del
+     * rettangolo, il confronto avviene contro la cornice che l'utente vedeva prima del gesto.
+     *
+     * Sempre `silent`: accompagna una mutazione che ha già registrato il suo passo di storico, e
+     * un annulla che riporta indietro l'appartenenza ma non la posizione sarebbe incomprensibile.
+     */
+    private syncGroupMembers;
+    /** Apre e chiude il riquadro. Non tocca i membri: chiuso e' un fatto del disegno (§3.6). */
+    toggleGroupCollapsed(event: Event, name: string): void;
+    onGroupClick(event: Event, name: string): void;
+    onGroupRemoveClick(event: Event, name: string): void;
+    /**
+     * Ridimensionamento a mano: `fGroupSizeChange` porta il rettangolo intero, posizione
+     * compresa — trascinare la maniglia di un lato sposta anche l'angolo opposto.
+     *
+     * Scrivere la geometria e' anche il modo di uscire dal «calcolala sui membri» (§3.6): finche'
+     * `width`/`height` sono 0 la cornice segue i membri, e allora ridimensionarla non si vedrebbe.
+     */
+    onGroupResized(name: string, rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }): void;
+    isGroupSelected(group: FlowCanvasGroup): boolean;
     /** Sintesi mostrata sul node: la cosa che serve sapere senza aprire l'inspector. */
     private subtitleOf;
     /** Sullo Start conta il trigger: e' cio' che decide quando il flow parte (§3.4). */
     private startSubtitle;
+    /**
+     * L'arco su cui si innesterebbe l'elemento che si sta trascinando dalla palette.
+     *
+     * Esiste per **dirlo prima**: senza l'evidenziazione, rilasciare sopra un arco e scoprire dopo
+     * che il flow si e' ricollegato e' una sorpresa, e non ci sarebbe modo di rilasciare *accanto*
+     * di proposito. Con l'arco acceso, il gesto e' una scelta.
+     */
+    private readonly _insertionEdgeId;
+    readonly insertionEdgeId: _angular_core.Signal<string | null>;
+    /** Gli id degli archi disegnati: il hit test accetta solo questi. */
+    private readonly edgeIds;
+    /** L'ascoltatore attivo solo durante un trascinamento dalla palette. */
+    private pointerListener;
+    /**
+     * Inizio di un trascinamento. Interessa **solo** quello di una voce della palette: trascinare
+     * un node o il capo di una connessione non innesta niente, e accendere gli archi in quei casi
+     * sarebbe rumore. La libreria chiama `drag-external-item` quel gesto (`kind`, o `fEventType`
+     * nella forma vecchia).
+     */
+    onDragStarted(event: {
+        kind?: string;
+        fEventType?: string;
+    }): void;
+    onDragEnded(): void;
+    /**
+     * L'arco sotto un punto dello schermo.
+     *
+     * Non serve nessuna geometria: @foblex/flow disegna gia', sotto ogni arco, un secondo path
+     * spesso (`.f-connection-selection`, 14px) con `pointer-events: stroke` — e' quello che rende
+     * cliccabile un arco da 2px, ed e' quello che risponde qui. L'id dell'elemento
+     * `<f-connection>` e' il nostro `fConnectionId`, cioe' `<sorgente>|<uscita>`.
+     *
+     * Si scorre l'elenco invece di guardare il solo primo elemento: sopra l'arco ci sono
+     * l'anteprima del trascinamento e il velo del canvas.
+     */
+    private edgeIdAt;
+    /**
+     * Da coordinate del flow a coordinate dello schermo.
+     *
+     * `f-canvas` porta la trasformazione del canvas (`matrix(s,0,0,s,tx,ty)`) e il suo riquadro
+     * comincia dall'origine del flow: l'angolo del suo `getBoundingClientRect` **e'** il punto
+     * (0,0) del flow, e da li' basta la scala. Serve perche' il rilascio arriva in coordinate del
+     * flow mentre il hit test lavora su quelle dello schermo.
+     */
+    private toClientPoint;
+    /** L'arco da cui viene un id, per rimandare al chiamante anche la destinazione. */
+    private edgeById;
     /**
      * Creazione di un arco. `targetId` assente significa rilascio nel vuoto: il ramo resta
      * **staccato**, cioe' omesso dal documento (`CONNECTOR_MISSING`, «il percorso finisce
@@ -3670,6 +4210,10 @@ declare class FlowCanvasComponent {
             x: number;
             y: number;
         };
+        dropPosition?: {
+            x: number;
+            y: number;
+        };
     }): void;
     onNodeDoubleClick(name: string): void;
     /**
@@ -3699,7 +4243,7 @@ declare class FlowCanvasComponent {
     /** Classe della fascia colorata, per categoria del dizionario. */
     categoryClass(node: FlowCanvasNode): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlowCanvasComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "selectedNames": { "alias": "selectedNames"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "selectedGroupName": { "alias": "selectedGroupName"; "required": false; "isSignal": true; }; "selectedNames": { "alias": "selectedNames"; "required": false; "isSignal": true; }; "outline": { "alias": "outline"; "required": false; "isSignal": true; }; "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; }, { "selectionChange": "selectionChange"; "nodeOpened": "nodeOpened"; "nodeRemoveRequested": "nodeRemoveRequested"; "nodeDuplicateRequested": "nodeDuplicateRequested"; "groupSelected": "groupSelected"; "groupRemoveRequested": "groupRemoveRequested"; "elementDropped": "elementDropped"; }, never, never, true, never>;
 }
 
 /** Il gesto scelto sulla palette: un tipo e, dove esiste, la sua variante (§5.6). */
@@ -3829,6 +4373,7 @@ declare class ReferencePickerComponent {
     private readonly loadError;
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     readonly query: _angular_core.WritableSignal<string>;
+    private readonly panel;
     constructor();
     /**
      * Il riferimento dichiarato piu' **lungo** che sia un prefisso del valore, e la tappa da cui
@@ -4097,6 +4642,20 @@ declare class NamePickerComponent {
     readonly emptyMessage: _angular_core.InputSignal<string>;
     /** Testo monospazio: i nomi tecnici si leggono meglio, ed e' come li mostra il resto del form. */
     readonly isMono: _angular_core.InputSignal<boolean>;
+    /**
+     * Quando si emette cio' che si **digita**.
+     *
+     * `'input'` (predefinito) e' il caso normale: il picker e' legato a un campo del documento, e a
+     * ogni tasto il valore va lì — come in una casella di testo qualunque.
+     *
+     * `'enter'` serve dove il picker **non** e' un campo ma un comando: l'aggiunta di un'opzione a un
+     * elenco (§5.2), dove ogni emissione e' una riga in piu'. Lì «una per tasto» significa che
+     * scrivere `Alta` aggiunge `A`, `Al`, `Alt` e `Alta`: la scelta dall'elenco resta immediata, il
+     * testo scritto a mano si conferma con Invio. Non si conferma sul blur di proposito — il blur
+     * arriva **prima** del click su un'opzione, e confermerebbe la parola incompleta insieme alla
+     * voce scelta.
+     */
+    readonly commitOn: _angular_core.InputSignal<"input" | "enter">;
     readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
     readonly isOpen: _angular_core.WritableSignal<boolean>;
     private readonly query;
@@ -4112,11 +4671,13 @@ declare class NamePickerComponent {
     close(): void;
     toggle(): void;
     onInput(text: string): void;
+    /** Invio: conferma il testo scritto a mano dove non lo fa la digitazione. */
+    commit(): void;
     choose(option: NamePickerOption): void;
     clear(): void;
     describe(option: NamePickerOption): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<NamePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NamePickerComponent, "fb-name-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "unknownMessage": { "alias": "unknownMessage"; "required": false; "isSignal": true; }; "unknownSeverity": { "alias": "unknownSeverity"; "required": false; "isSignal": true; }; "unusableOptions": { "alias": "unusableOptions"; "required": false; "isSignal": true; }; "unusableMessage": { "alias": "unusableMessage"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "isMono": { "alias": "isMono"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NamePickerComponent, "fb-name-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "unknownMessage": { "alias": "unknownMessage"; "required": false; "isSignal": true; }; "unknownSeverity": { "alias": "unknownSeverity"; "required": false; "isSignal": true; }; "unusableOptions": { "alias": "unusableOptions"; "required": false; "isSignal": true; }; "unusableMessage": { "alias": "unusableMessage"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "isMono": { "alias": "isMono"; "required": false; "isSignal": true; }; "commitOn": { "alias": "commitOn"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 declare class StructurePickerComponent {
@@ -4858,6 +5419,11 @@ declare class ElementInspectorComponent {
      * nell'intestazione della dialog, e ripeterli sprecherebbe la riga piu' preziosa.
      */
     readonly showHeader: _angular_core.InputSignal<boolean>;
+    /**
+     * Il campo di screen dinamico da selezionare all'apertura, quando si arriva da un rilievo o
+     * dalla ricerca. Si passa avanti al compositore: qui non si sa nemmeno che forma abbia.
+     */
+    readonly initialFieldPath: _angular_core.InputSignal<FlowScreenFieldPath | null>;
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly removeRequested: _angular_core.OutputEmitterRef<string>;
     readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
@@ -4877,6 +5443,18 @@ declare class ElementInspectorComponent {
     /** I rilievi ancorati all'elemento (§7). */
     readonly issues: _angular_core.Signal<_esfaenza_flow_builder.FlowValidationIssue[]>;
     /** Il nome tecnico in modifica: si applica con un comando esplicito, non a ogni tasto. */
+    /**
+     * I rilievi mostrati per intero o accorciati.
+     *
+     * Un elemento con sei rilievi apriva il form con un muro di 350px di avvisi prima del primo
+     * campo: su una dialog alta 550px e' il 63% di cio' che si vede, e il form sembra non esserci.
+     * Se ne mostrano due — quanti bastano a sapere che qualcosa non va — e il resto si chiede.
+     */
+    readonly issuesExpanded: _angular_core.WritableSignal<boolean>;
+    private static readonly ISSUE_PREVIEW;
+    readonly visibleIssues: _angular_core.Signal<_esfaenza_flow_builder.FlowValidationIssue[]>;
+    readonly hiddenIssueCount: _angular_core.Signal<number>;
+    toggleIssues(): void;
     readonly pendingName: _angular_core.WritableSignal<string | null>;
     readonly nameError: _angular_core.Signal<string | null>;
     /**
@@ -4903,7 +5481,7 @@ declare class ElementInspectorComponent {
         y: number;
     }>;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementInspectorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementInspectorComponent, "fb-element-inspector", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementInspectorComponent, "fb-element-inspector", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "showHeader": { "alias": "showHeader"; "required": false; "isSignal": true; }; "initialFieldPath": { "alias": "initialFieldPath"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
 }
 
 declare class ElementDialogComponent {
@@ -4911,6 +5489,8 @@ declare class ElementDialogComponent {
     private readonly dictionaries;
     /** L'elemento da configurare; `$start` per lo Start. */
     readonly selectedName: _angular_core.InputSignal<string | null>;
+    /** Il campo di screen dinamico da selezionare all'apertura: si passa avanti all'inspector. */
+    readonly initialFieldPath: _angular_core.InputSignal<FlowScreenFieldPath | null>;
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly removeRequested: _angular_core.OutputEmitterRef<string>;
     readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
@@ -4922,12 +5502,42 @@ declare class ElementDialogComponent {
     readonly typeLabel: _angular_core.Signal<string>;
     readonly title: _angular_core.Signal<string>;
     constructor();
+    /**
+     * Vincolo dello spostamento: cio' che deve restare nel builder e' la **maniglia**, non la
+     * finestra. Un `cdkDragBoundary` chiede che l'elemento ci stia tutto, e con una dialog quasi
+     * grande quanto il builder non lascia nessun margine di movimento; qui invece si spinge la
+     * finestra fin quasi fuori — che e' il punto: si sposta per guardare cio' che copre — e
+     * l'intestazione resta comunque sotto il puntatore per riportarla indietro.
+     *
+     * Attenzione alla firma, che non e' simmetrica e il compilatore non lo dice: **in** arriva la
+     * posizione del puntatore in coordinate di pagina, **fuori** deve andare l'angolo in alto a
+     * sinistra dell'**elemento** — con un `constrainPosition` il CDK calcola la trasformazione da
+     * `_initialDomRect`, non dal punto di presa. Restituendo un puntatore la finestra si sposta di
+     * quanto e' distante la presa dal suo bordo, e il vincolo scatta nel posto sbagliato.
+     *
+     * Per lo stesso motivo i conti si fanno in coordinate del **viewport**: `_initialDomRect` viene
+     * da `getBoundingClientRect`, mentre il punto in ingresso comprende lo scorrimento della pagina.
+     */
+    readonly constrainPosition: (point: {
+        x: number;
+        y: number;
+    }, _drag: unknown, dimensions: DOMRect, pickup: {
+        x: number;
+        y: number;
+    }) => {
+        x: number;
+        y: number;
+    };
+    /** Altezza dell'intestazione: la fetta che deve restare visibile in basso. */
+    private static readonly HEAD_HEIGHT;
+    /** Il rettangolo del builder, nelle stesse coordinate in cui il CDK vuole la risposta. */
+    private builderBounds;
     close(): void;
     onRemoveRequested(name: string): void;
     onDuplicateRequested(name: string): void;
     onRenamed(name: string): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ElementDialogComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementDialogComponent, "fb-element-dialog", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ElementDialogComponent, "fb-element-dialog", never, { "selectedName": { "alias": "selectedName"; "required": false; "isSignal": true; }; "initialFieldPath": { "alias": "initialFieldPath"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
 }
 
 declare class PasteDialogComponent {
@@ -5113,6 +5723,16 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     protected readonly dictionary: FlowDictionaryStore;
     readonly elementType: FlowElementType;
     readonly screen: _angular_core.Signal<FlowDynamicScreen>;
+    /**
+     * Il campo da selezionare all'apertura: lo passa chi apre il form (un rilievo del pannello dei
+     * problemi, un risultato della ricerca). L'effetto scatta solo quando l'input **cambia**,
+     * quindi non litiga con la selezione dell'utente; un `null` non e' un'istruzione — significa
+     * «apri come sempre», cioe' sulle proprieta' della schermata.
+     */
+    readonly initialSelection: _angular_core.InputSignal<FlowScreenFieldPath | null>;
+    /** Il compositore: si porta in vista quando la selezione arriva da fuori (vedi il costruttore). */
+    private readonly composer;
+    private readonly injector;
     /** Il percorso del campo selezionato: `null` = nessuno, e a destra ci sono le proprieta'
      * della **schermata** — lo stesso gesto del cliccare fuori da un campo. */
     private readonly selection;
@@ -5453,9 +6073,19 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     /** I flag con default `true` si scrivono solo quando si nega, per non sporcare il diff. */
     setScreenFlag(flag: 'allowBack' | 'allowFinish' | 'allowPause' | 'showHeader' | 'showFooter', value: boolean): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DynamicScreenInspectorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicScreenInspectorComponent, "fb-dynamic-screen-inspector", never, {}, {}, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DynamicScreenInspectorComponent, "fb-dynamic-screen-inspector", never, { "initialSelection": { "alias": "initialSelection"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
+/**
+ * La risorsa su cui aprire il pannello, quando ci arriva dalla ricerca. `token` esiste per far
+ * ripartire l'effetto anche se si scegliesse due volte la stessa risorsa: senza, il secondo
+ * arrivo non cambierebbe l'input e non accadrebbe niente.
+ */
+interface FlowResourceTarget {
+    collection: FlowResourceCollection;
+    index: number;
+    token: number;
+}
 interface ResourceKindDescriptor {
     collection: FlowResourceCollection;
     label: string;
@@ -5469,6 +6099,8 @@ declare class ResourcePanelComponent {
     private readonly dictionaries;
     private readonly catalog;
     readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** Dove aprire il pannello: e' l'arrivo della ricerca su una risorsa. */
+    readonly target: _angular_core.InputSignal<FlowResourceTarget | null>;
     readonly kinds: ResourceKindDescriptor[];
     readonly dataTypes: _angular_core.Signal<_esfaenza_flow_builder.FlowDataTypeEntry[]>;
     readonly sortOrders: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
@@ -5477,6 +6109,12 @@ declare class ResourcePanelComponent {
     readonly activeCollection: _angular_core.WritableSignal<"variables" | "constants" | "formulas" | "textTemplates" | "choices" | "dynamicChoiceSets" | "stages">;
     /** L'indice della risorsa in modifica, o `null`. */
     readonly editingIndex: _angular_core.WritableSignal<number | null>;
+    /**
+     * La risorsa per cui e' stata chiesta la rimozione ma che risulta **usata**: si conferma.
+     * La chiave e' `collection:index`, non la risorsa, perche' l'oggetto viene ricostruito a ogni
+     * ricalcolo del documento.
+     */
+    readonly pendingRemoval: _angular_core.WritableSignal<string | null>;
     constructor();
     readonly enumOptions: _angular_core.Signal<FlowCatalogEntry[]>;
     readonly activeKind: _angular_core.Signal<ResourceKindDescriptor>;
@@ -5487,6 +6125,27 @@ declare class ResourcePanelComponent {
     /** Nome valido e libero nello spazio dei nomi condiviso con i node (§3.3, §13.5). */
     nameError(reference: FlowResourceRef): string | null;
     add(): void;
+    /**
+     * Quante volte la risorsa e' **usata** nel documento.
+     *
+     * Serve dove il danno di una cancellazione non si vede: togliere una variabile non fa sparire
+     * nessun arco dal canvas, e i riferimenti orfani restano lì fino alla validazione successiva.
+     * A zero occorrenze e' l'informazione opposta, ed e' quella che serve su un flow grande: dice
+     * quali delle venti variabili sono morte.
+     *
+     * Il conteggio comprende le **formule**, che citano le risorse per nome dentro l'espressione:
+     * senza, tre formule che leggono una variabile la direbbero «non usata».
+     */
+    usesOf(reference: FlowResourceRef): number;
+    private keyOf;
+    isPendingRemoval(reference: FlowResourceRef): boolean;
+    /**
+     * Il primo clic su «×» di una risorsa usata **chiede**, non cancella: e' l'unico punto
+     * dell'editor in cui un gesto rompe silenziosamente qualcosa che sta altrove. Su una risorsa
+     * che nessuno usa si cancella subito — l'annulla dell'editor basta come rete.
+     */
+    requestRemove(reference: FlowResourceRef): void;
+    cancelRemove(): void;
     remove(reference: FlowResourceRef): void;
     rename(reference: FlowResourceRef, name: string): void;
     setField(reference: FlowResourceRef, field: string, value: unknown): void;
@@ -5555,14 +6214,98 @@ declare class ResourcePanelComponent {
     value(reference: FlowResourceRef): FlowValue | undefined;
     close(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ResourcePanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourcePanelComponent, "fb-resource-panel", never, {}, { "closed": "closed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ResourcePanelComponent, "fb-resource-panel", never, { "target": { "alias": "target"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+/** Il riquadro su cui aprire il pannello. `token` fa ripartire l'effetto sulla stessa scelta. */
+interface FlowGroupTarget {
+    name: string;
+    token: number;
+}
+declare class GroupPanelComponent {
+    private readonly store;
+    readonly isEditable: _angular_core.InputSignal<boolean>;
+    /** La selezione del canvas: e' cio' che si puo' aggiungere a un riquadro con un comando. */
+    readonly selectedNodeNames: _angular_core.InputSignal<readonly string[]>;
+    /** Il riquadro da aprire, quando ci si arriva dal canvas o dal pannello dei problemi. */
+    readonly target: _angular_core.InputSignal<FlowGroupTarget | null>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    /** «Nuovo riquadro»: lo crea il builder, che conosce le geometrie dei node. */
+    readonly createRequested: _angular_core.OutputEmitterRef<void>;
+    /** Un elemento del riquadro: si porta la vista su di lui. */
+    readonly memberFocused: _angular_core.OutputEmitterRef<string>;
+    readonly colors: readonly {
+        value: string;
+        label: string;
+    }[];
+    readonly groups: _angular_core.Signal<_esfaenza_flow_builder.FlowGroupRef[]>;
+    /** Quale riquadro e' aperto, per nome: l'indice cambia quando se ne cancella uno prima. */
+    readonly openName: _angular_core.WritableSignal<string | null>;
+    constructor();
+    toggleOpen(name: string): void;
+    isOpen(name: string): boolean;
+    /** I nomi dei node esistenti: distingue un membro vivo da uno rimasto indietro (regola 3). */
+    private readonly knownNodes;
+    isKnownMember(member: string): boolean;
+    membersOf(index: number): string[];
+    staleMembersOf(index: number): string[];
+    /** La geometria e' calcolata sui membri: si dice, perche' spiega perche' la cornice si muove. */
+    isAutoSized(index: number): boolean;
+    /**
+     * Il doppione si cerca **fra i riquadri** e in nessun altro posto (§3.6, regola 1). E' l'unico
+     * controllo di nome dell'editor che non guarda `usedNames`: un riquadro non e' referenziabile,
+     * quindi non c'e' niente da rendere ambiguo.
+     */
+    nameProblem(index: number): string | null;
+    setName(index: number, value: string): void;
+    setLabel(index: number, value: string): void;
+    setDescription(index: number, value: string): void;
+    setColor(index: number, value: string): void;
+    setCollapsed(index: number, value: boolean): void;
+    /** Aggiunge gli elementi selezionati sul canvas: e' il gesto per i riquadri sovrapposti. */
+    addSelection(index: number): void;
+    removeMember(index: number, member: string): void;
+    /** Toglie i membri che non esistono piu': la ripulitura e' dell'editor (§3.6, regola 3). */
+    cleanStale(index: number): void;
+    /** Il riquadro va via, il contenuto resta: e' un commento, non un contenitore. */
+    remove(index: number): void;
+    canAddSelection(): boolean;
+    /** Il colore scritto nel documento non e' fra quelli proposti: si mostra, non si corregge. */
+    isColorOutOfList(index: number): boolean;
+    colorOf(index: number): string;
+    close(): void;
+    create(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GroupPanelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GroupPanelComponent, "fb-group-panel", never, { "isEditable": { "alias": "isEditable"; "required": false; "isSignal": true; }; "selectedNodeNames": { "alias": "selectedNodeNames"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "createRequested": "createRequested"; "memberFocused": "memberFocused"; }, never, never, true, never>;
 }
 
 type SeverityFilter = 'all' | FlowSeverityBucket;
 declare class ProblemsPanelComponent {
     private readonly validation;
-    /** Chiede di selezionare l'elemento: `$start` per i rilievi sul documento. */
-    readonly elementFocused: _angular_core.OutputEmitterRef<string>;
+    /** Serve solo a **leggere** i nomi: il `path` di un rilievo arriva a indici (vedi `pathLabel`). */
+    private readonly store;
+    /**
+     * Chiede di **mostrare** il rilievo: selezionare l'elemento e portarlo al centro, senza
+     * aprirne il form. E' cio' che fa il clic su una riga, ed e' deliberato: guardare l'elenco dei
+     * problemi vuol dire scorrerlo, e un form che si apre a ogni riga copre il grafo che si sta
+     * leggendo. `$start` per i rilievi che riguardano il documento.
+     */
+    readonly elementFocused: _angular_core.OutputEmitterRef<{
+        name: string;
+        path?: string | null;
+    }>;
+    /**
+     * Chiede di **aprire** il form sul rilievo, che e' il gesto successivo: si guarda dov'e', poi
+     * si va a correggerlo. Sta su un bottone suo (e sul doppio clic) invece di essere il
+     * comportamento della riga.
+     *
+     * Il `path` viaggia col nome perche' e' cio' che permette di selezionare il **campo** dentro
+     * uno screen dinamico, e non solo la schermata che lo contiene.
+     */
+    readonly elementOpened: _angular_core.OutputEmitterRef<{
+        name: string;
+        path?: string | null;
+    }>;
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly filter: _angular_core.WritableSignal<SeverityFilter>;
     readonly isRunning: _angular_core.Signal<boolean>;
@@ -5587,10 +6330,23 @@ declare class ProblemsPanelComponent {
     bucketOf(issue: FlowValidationIssue): FlowSeverityBucket;
     iconText(bucket: FlowSeverityBucket): string;
     labelText(bucket: FlowSeverityBucket): string;
+    /** Clic sulla riga: porta la vista sull'elemento e lo seleziona. Non apre niente. */
     focus(issue: FlowValidationIssue): void;
+    /** Il bottone «✎» e il doppio clic: apre il form, con il campo selezionato quando c'e'. */
+    open(issue: FlowValidationIssue, event?: Event): void;
+    /**
+     * Il `path` del rilievo, scritto in modo che si possa **seguire**.
+     *
+     * Il backend lo manda come percorso di campi (§7), e sugli screen dinamici lo manda spesso a
+     * **indici**: `fields[1].fields[1].fields[0]` e' esatto e inutile, perche' per arrivarci si
+     * devono contare i figli a mano. I nomi li ha il documento, quindi tradurre e' compito
+     * dell'editor. Quando il path non nomina campi — o nomina campi che non esistono piu' — si
+     * mostra tale e quale: inventare un'etichetta sarebbe peggio.
+     */
+    pathLabel(issue: FlowValidationIssue): string;
     close(): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProblemsPanelComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProblemsPanelComponent, "fb-problems-panel", never, {}, { "elementFocused": "elementFocused"; "closed": "closed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProblemsPanelComponent, "fb-problems-panel", never, {}, { "elementFocused": "elementFocused"; "elementOpened": "elementOpened"; "closed": "closed"; }, never, never, true, never>;
 }
 
 declare class VersionPanelComponent {
@@ -5714,7 +6470,47 @@ declare class DebugPanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DebugPanelComponent, "fb-debug-panel", never, { "outcome": { "alias": "outcome"; "required": false; "isSignal": true; }; "wasDebug": { "alias": "wasDebug"; "required": false; "isSignal": true; }; "isRunning": { "alias": "isRunning"; "required": false; "isSignal": true; }; }, { "closed": "closed"; "elementFocused": "elementFocused"; "cleared": "cleared"; }, never, never, true, never>;
 }
 
-type SidePanel = 'inspector' | 'resources' | 'versions' | 'debug';
+/**
+ * Trovare qualcosa **nel documento** per nome.
+ *
+ * Non esisteva: l'unica casella di ricerca dell'editor filtra i **tipi** della palette, cioe'
+ * cio' che si puo' aggiungere, non cio' che c'e'. Su un flow da dieci elementi non serve — si
+ * vedono tutti; su uno da quaranta, distribuiti su settemila pixel di canvas, cercare
+ * `CreaRigaEle` a occhio e' l'operazione piu' frequente e la piu' lenta.
+ *
+ * Cosa entra nell'indice: tutto cio' che ha un **nome nello spazio dei nomi comune** (§3.3) —
+ * elementi, risorse, e le tre cose che non sono ne' l'uno ne' l'altro ma il cui nome e' la
+ * radice di un riferimento: step di orchestrazione, campi di screen dinamico e screen action.
+ * E' lo stesso insieme di `usedNames` dello store, e non e' una coincidenza: se un nome puo'
+ * comparire in un riferimento, deve essere cercabile.
+ *
+ * Quello che l'indice **non** fa e' cercare nei valori: un'espressione che cita `Totale` non
+ * rende `Totale` un risultato per «Totale», perche' il risultato sarebbe l'espressione. Il
+ * «dove e' usato» e' un'altra domanda, e la risposta sta in `flow-references.ts`.
+ */
+
+/** Cosa e' stato trovato: decide dove porta il clic. */
+type FlowSearchKind = 'node' | 'field' | 'action' | 'step' | 'resource';
+interface FlowSearchHit {
+    kind: FlowSearchKind;
+    /** Il nome nello spazio dei nomi comune: e' cio' su cui si cerca. */
+    name: string;
+    /** Testo mostrato in grande: l'etichetta se c'e', il nome altrimenti. */
+    label: string;
+    /** Riga secondaria: il tipo, e per cio' che sta dentro un elemento l'elemento che lo contiene. */
+    detail: string;
+    /** L'elemento su cui portare l'utente. Per una risorsa e' assente. */
+    elementName?: string;
+    /** Il percorso del campo dentro lo screen dinamico, quando `kind` e' `field`. */
+    fieldPath?: FlowScreenFieldPath;
+    /** Dove sta la risorsa, quando `kind` e' `resource`. */
+    resource?: {
+        collection: string;
+        index: number;
+    };
+}
+
+type SidePanel = 'inspector' | 'resources' | 'groups' | 'versions' | 'debug';
 interface Notice {
     kind: 'info' | 'error';
     message: string;
@@ -5758,6 +6554,30 @@ declare class FlowBuilderComponent {
     readonly notice: _angular_core.WritableSignal<Notice | null>;
     readonly outline: _angular_core.WritableSignal<FlowOutline | null>;
     readonly isLoading: _angular_core.WritableSignal<boolean>;
+    /** Il canvas: serve per portare la vista su un elemento (ricerca, clic su un problema). */
+    private readonly canvas;
+    private readonly search;
+    /**
+     * Il campo di screen dinamico da selezionare quando il form si apre.
+     *
+     * Esiste perche' «apri l'elemento» non basta: un rilievo su `fields[1].fields[1].fields[0]`
+     * porta su una schermata da venti campi, e senza la selezione il campo va ritrovato contando
+     * i figli a mano. Si azzera appena il form lo consuma: e' un'istruzione per un'apertura, non
+     * uno stato dell'editor.
+     */
+    readonly pendingFieldPath: _angular_core.WritableSignal<FlowScreenFieldPath | null>;
+    /** La risorsa su cui aprire il pannello: e' l'arrivo della ricerca su una risorsa. */
+    readonly resourceTarget: _angular_core.WritableSignal<FlowResourceTarget | null>;
+    private resourceReveals;
+    /**
+     * Il riquadro corrente (§3.6). E' una selezione **separata** da `selectedName`: un riquadro
+     * non e' un elemento — non si copia, non si duplica, non si valida come tale — e tenerlo nella
+     * stessa variabile avrebbe fatto puntare l'inspector a un nome che nelle collection dei node
+     * non esiste.
+     */
+    readonly selectedGroupName: _angular_core.WritableSignal<string | null>;
+    readonly groupTarget: _angular_core.WritableSignal<FlowGroupTarget | null>;
+    private groupReveals;
     /** Il documento e' cambiato: usato per riscadenzare validazione e outline. */
     private lastDocument?;
     private outlineTimer?;
@@ -5819,10 +6639,40 @@ declare class FlowBuilderComponent {
     onSelectionChange(names: string[]): void;
     /** Doppio click o bottone «✎» sul node: qui il dettaglio si apre. */
     onNodeOpened(name: string): void;
-    /** Porta l'utente sull'elemento **e** ne apre il form: e' l'ancora dei problemi (§7). */
-    focusElement(name: string): void;
+    /**
+     * **Mostra** il rilievo: seleziona l'elemento e lo porta al centro, senza aprire niente.
+     *
+     * E' il clic su una riga del pannello dei problemi, ed e' cio' che serve nel 90% dei casi:
+     * l'elenco si scorre, e il primo bisogno e' capire **dove** sta la cosa segnalata. Aprire il
+     * form a ogni riga copriva il grafo che si stava leggendo, e per tornare a guardarlo si doveva
+     * chiudere una finestra per riga.
+     *
+     * Un riquadro (§3.6) si seleziona come tale: gli spazi dei nomi sono due, e l'elemento vince
+     * sull'omonimia per la stessa ragione di {@link openIssueElement}.
+     */
+    revealIssueElement(event: string | {
+        name: string;
+        path?: string | null;
+    }): void;
+    /**
+     * Porta l'utente sull'elemento **e** ne apre il form: e' il bottone «✎» di una riga dei
+     * problemi, e il doppio clic sulla riga (§7).
+     *
+     * Il `path` del rilievo, quando nomina un campo di uno screen dinamico, diventa la selezione
+     * dentro il form: e' la differenza fra «ti apro la schermata» e «ti apro il campo».
+     */
+    openIssueElement(event: string | {
+        name: string;
+        path?: string | null;
+    }): void;
     /** Apre il dettaglio dell'elemento, nella dialog o nel pannello secondo la modalita'. */
-    openElement(name: string): void;
+    openElement(name: string, fieldPath?: FlowScreenFieldPath | null): void;
+    /**
+     * L'arrivo della ricerca. Un elemento si apre; cio' che sta **dentro** un elemento apre
+     * l'elemento che lo contiene (con il campo selezionato, quando e' un campo); una risorsa apre
+     * il pannello delle risorse su di lei — non c'e' niente da inquadrare sul canvas.
+     */
+    onSearchPicked(hit: FlowSearchHit): void;
     /** Il comando della top bar: apre il dettaglio di cio' che e' selezionato. */
     openSelectedElement(): void;
     closeDialog(): void;
@@ -5832,16 +6682,36 @@ declare class FlowBuilderComponent {
      * sostituirlo con l'inspector farebbe sparire la traccia che si stava leggendo.
      */
     highlightElement(name: string): void;
-    /** Rilascio dalla palette: il punto di rilascio diventa `locationX`/`locationY` (§11). */
+    /**
+     * Rilascio dalla palette: il punto di rilascio diventa `locationX`/`locationY` (§11), a meno
+     * che sotto il puntatore non ci fosse un **arco** — allora l'elemento si innesta in quel
+     * percorso e la posizione la decide il piano di innesto.
+     */
     onElementDropped(event: {
         type: FlowElementType;
         variant?: string;
         x: number;
         y: number;
+        edge?: {
+            from: string;
+            outletKey: string;
+            to: string;
+        };
     }): void;
     /** Click sulla palette: l'elemento si posiziona in una zona libera. */
     onElementPicked(pick: FlowPalettePick): void;
     private createElement;
+    /**
+     * Innesta l'elemento appena costruito **in mezzo** all'arco su cui e' stato rilasciato.
+     *
+     * Il piano lo calcola `core/flow-insert.ts` e lo applica lo store in una mutazione sola. Qui
+     * restano le due cose che sono dell'interfaccia: la posizione scritta nel node — il punto del
+     * rilascio non conta piu', conta il varco fra i due elementi — e il messaggio nel caso in cui
+     * l'elemento **non abbia uscite** (un Custom Error interrompe l'esecuzione, §5.12): il
+     * percorso a valle resta scollegato, e va detto subito invece di lasciarlo scoprire dal
+     * pannello dei problemi.
+     */
+    private insertOnEdge;
     onRemoveNode(name: string): void;
     /**
      * La selezione dell'editor e' il **nome** dell'elemento: dopo una rinomina il nome vecchio
@@ -5849,6 +6719,23 @@ declare class FlowBuilderComponent {
      */
     onNodeRenamed(newName: string): void;
     onDuplicateNode(name: string): void;
+    /**
+     * Crea un riquadro **attorno alla selezione**, che e' il gesto per cui serve: si selezionano
+     * gli elementi che vanno insieme e si dice «questi sono una cosa». Senza selezione nasce un
+     * riquadro vuoto sotto il flow, da riempire trascinandoci dentro gli elementi.
+     *
+     * La geometria si scrive sempre, anche se il contratto ammette lo 0 («calcolala sui membri»,
+     * §3.6): un riquadro nato con una misura si puo' spostare e ridimensionare subito, mentre uno
+     * auto-dimensionato segue i membri e la maniglia non farebbe niente.
+     */
+    createGroup(): void;
+    /** Apre il pannello dei riquadri su uno di loro. Il token lo riapre anche sulla stessa scelta. */
+    private revealGroup;
+    onGroupSelected(name: string): void;
+    /** Il riquadro va via, gli elementi che conteneva restano: e' documentazione (§3.6). */
+    onGroupRemoved(name: string): void;
+    /** Un membro del riquadro: si porta la vista su di lui, senza aprirne il form. */
+    focusMember(name: string): void;
     /** La selezione del canvas per intero; `selectedName` resta l'elemento «corrente». */
     readonly selectedNames: _angular_core.WritableSignal<string[]>;
     /** L'anteprima dell'incolla, mentre la finestra e' aperta. */
@@ -5989,5 +6876,5 @@ declare class SelectValueDirective implements AfterViewChecked {
     static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SelectValueDirective, "select[fbValue]", never, { "fbValue": { "alias": "fbValue"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, DynamicScreenInspectorComponent, ENUM_CHOICE_SET_DEFAULT_DISPLAY_FIELD, ENUM_CHOICE_SET_DEFAULT_VALUE_FIELD, ENUM_CHOICE_SET_FIELDS, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_CLIPBOARD_KIND, FLOW_CLIPBOARD_VERSION, FLOW_ELEMENT_ICONS, FLOW_ELEMENT_VARIANT_FIELDS, FLOW_ELEMENT_VARIANT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_REFERENCE_FIELDS, FLOW_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FieldValuePickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowClipboardService, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, PasteDialogComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, RunDialogComponent, SEVERITY_BUCKETS, SEVERITY_ICON, SEVERITY_LABEL, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, StructureMemberPickerComponent, StructurePickerComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, allFieldsOf, applyPaste, areTypesComparable, buildClipboardPayload, canvasNodeId, checkConditionLogic, checkFlowName, choiceSetSourceOf, declaredChoiceSetSources, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, enumChoiceSetFieldType, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, innerNamesOf, insertField, isClipboardPayload, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isUnknownEnumChoiceSetField, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, moveField, navigatePath, otherSourceFieldsOf, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, planPaste, referenceRoot, referencedRootsOf, remapConditionLogic, removeCondition, removeField, resolvePath, rewriteReferences, samePath, screenActionNames, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, typeOfCollection, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
-export type { ChoiceSetSource, FieldAssignmentHolder, FilterFieldOption, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowClipboardNode, FlowClipboardPayload, FlowClipboardResource, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowDynamicScreen, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowEnumValue, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormKind, FlowFormula, FlowFormulaFunction, FlowFormulaFunctionParameter, FlowFormulaIssue, FlowFormulaUsage, FlowFormulaValidationRequest, FlowFormulaValidationResult, FlowGlobalVariableEntry, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOrchestratedStage, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPalettePick, FlowPastePlan, FlowPasteRename, FlowPasteResource, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowReference, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowRunOutcome, FlowRunRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenAction, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, FlowScreenTrigger, FlowScreenTriggerInitBehavior, FlowScreenValidationRule, FlowScriptPluginCall, FlowSeverityBucket, FlowSortOption, FlowSortOrder, FlowStage, FlowStageStep, FlowStageStepActionType, FlowStageStepAssignee, FlowStageStepConditionActionType, FlowStageStepRequest, FlowStageStepState, FlowStageStepStatus, FlowStageStepTypeEntry, FlowStart, FlowStartInterviewRequest, FlowStructureDescribed, FlowStructureDescription, FlowStructureInstance, FlowStructureMember, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedEntry, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, NamePickerOption, PaletteGroup, PaletteItem, ParameterHolder, PathCatalog, PathContainer, PathContainerKind, PathEntry, PathLevel, PathLevelStatus, PathNavigation, PathNavigationRequest, PathResolution, PathStopReason, PathValueSet, StructureMemberUsage, ValueMode };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, DynamicScreenInspectorComponent, ENUM_CHOICE_SET_DEFAULT_DISPLAY_FIELD, ENUM_CHOICE_SET_DEFAULT_VALUE_FIELD, ENUM_CHOICE_SET_FIELDS, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, FLOW_CLIPBOARD_KIND, FLOW_CLIPBOARD_VERSION, FLOW_ELEMENT_ICONS, FLOW_ELEMENT_VARIANT_FIELDS, FLOW_ELEMENT_VARIANT_ICONS, FLOW_ERROR_FALLBACK_MESSAGE, FLOW_ERROR_HTTP_STATUS, FLOW_GROUP_COLORS, FLOW_NAME_PATTERN, FLOW_NODE_COLLECTIONS, FLOW_NODE_HEIGHT, FLOW_NODE_WIDTH, FLOW_REFERENCE_FIELDS, FLOW_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FieldValuePickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowClipboardService, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, GROUP_HEADER_HEIGHT, GROUP_MIN_HEIGHT, GROUP_MIN_WIDTH, GROUP_PADDING, GroupPanelComponent, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, PasteDialogComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, RunDialogComponent, SEVERITY_BUCKETS, SEVERITY_ICON, SEVERITY_LABEL, START_NODE_NAME, SelectValueDirective, StartInspectorComponent, StructureMemberPickerComponent, StructurePickerComponent, TYPES_WITH_AUTOMATIC_OUTPUT, TYPE_BY_COLLECTION, UNSUPPORTED_TYPES, ValueEditorComponent, VersionPanelComponent, allFieldsOf, applyPaste, areTypesComparable, boundsAround, buildClipboardPayload, canvasGroupId, canvasNodeId, checkConditionLogic, checkFlowName, choiceSetSourceOf, declaredChoiceSetSources, describeFieldPath, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, enumChoiceSetFieldType, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, groupColorClass, groupRect, hasAutoSize, innerNamesOf, insertField, isClipboardPayload, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isUnknownEnumChoiceSetField, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, membersInside, moveCondition, moveField, navigatePath, otherSourceFieldsOf, outletByKey, outletsOf, parseCanvasGroupId, parseCanvasNodeId, parseFieldPath, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, planPaste, recomputeMembers, referenceRoot, referencedRootsOf, remapConditionLogic, removeCondition, removeField, resolvePath, rewriteReferences, sameMembers, samePath, screenActionNames, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, typeOfCollection, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
+export type { ChoiceSetSource, FieldAssignmentHolder, FilterFieldOption, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasGroup, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, FlowClipboardNode, FlowClipboardPayload, FlowClipboardResource, FlowCloneRequest, FlowCollectionProcessor, FlowCollectionProcessorType, FlowComparisonOperator, FlowComparisonOperatorEntry, FlowCondition, FlowConditionHolder, FlowConditionLogic, FlowConflictState, FlowConnectionKind, FlowConnector, FlowConnectorTarget, FlowConstant, FlowCreateRequest, FlowCustomError, FlowCustomErrorMessage, FlowCustomProperty, FlowDataType, FlowDataTypeEntry, FlowDecision, FlowDecisionRule, FlowDefinition, FlowDictionaries, FlowDictionaryEntry, FlowDynamicChoiceSet, FlowDynamicScreen, FlowEdge, FlowElementType, FlowElementTypeEntry, FlowEnumValue, FlowErrorCategory, FlowExportQuery, FlowFieldDescription, FlowFieldUsage, FlowFieldValue, FlowFormKind, FlowFormula, FlowFormulaFunction, FlowFormulaFunctionParameter, FlowFormulaIssue, FlowFormulaUsage, FlowFormulaValidationRequest, FlowFormulaValidationResult, FlowGlobalVariableEntry, FlowGroup, FlowGroupRef, FlowGroupTarget, FlowInputFieldAssignment, FlowInputParameter, FlowInterviewResult, FlowInterviewStatus, FlowIssueSeverity, FlowLayoutDirection, FlowLayoutNodeInput, FlowLayoutOptions, FlowLayoutResult, FlowListQuery, FlowLoop, FlowNameCheck, FlowNameProblem, FlowNewVersionRequest, FlowNodeBase, FlowNodeCollection, FlowNodeRef, FlowObjectDescription, FlowObjectSummary, FlowOffsetUnit, FlowOrchestratedStage, FlowOutlet, FlowOutline, FlowOutlineConnection, FlowOutlineGroup, FlowOutlineNode, FlowOutputFieldAssignment, FlowOutputParameter, FlowPalettePick, FlowPastePlan, FlowPasteRename, FlowPasteResource, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowRect, FlowReference, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResourceTarget, FlowResumeRequest, FlowRunOutcome, FlowRunRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenAction, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, FlowScreenTrigger, FlowScreenTriggerInitBehavior, FlowScreenValidationRule, FlowScriptPluginCall, FlowSeverityBucket, FlowSortOption, FlowSortOrder, FlowStage, FlowStageStep, FlowStageStepActionType, FlowStageStepAssignee, FlowStageStepConditionActionType, FlowStageStepRequest, FlowStageStepState, FlowStageStepStatus, FlowStageStepTypeEntry, FlowStart, FlowStartInterviewRequest, FlowStructureDescribed, FlowStructureDescription, FlowStructureInstance, FlowStructureMember, FlowSubflow, FlowSubflowInputAssignment, FlowSubflowOutputAssignment, FlowSummary, FlowTextTemplate, FlowTraceEntry, FlowTransactionModel, FlowTransform, FlowTransformType, FlowTransformValue, FlowTransformValueAction, FlowTriggerType, FlowTypedEntry, FlowTypedValue, FlowUnsupportedNode, FlowValidationIssue, FlowValidationResult, FlowValue, FlowVariable, FlowVersionStatus, FlowVersionSummary, FlowWait, FlowWaitEvent, NamePickerOption, PaletteGroup, PaletteItem, ParameterHolder, PathCatalog, PathContainer, PathContainerKind, PathEntry, PathLevel, PathLevelStatus, PathNavigation, PathNavigationRequest, PathResolution, PathStopReason, PathValueSet, StructureMemberUsage, ValueMode };