@esfaenza/flow-builder 20.3.16 → 20.3.18

package/index.d.ts

@@ -256,6 +256,54 @@ interface FlowScreenField {
     /** Come una regola di Decision: rivalutata sui valori appena inviati (§5.2). */
     visibilityRule?: FlowConditionHolder;
 }
+/**
+ * §5.2 — una **screen action**: un'action del flow i cui risultati finiscono negli **altri campi
+ * della stessa schermata**. E' il caso «inserisci il codice fiscale e, se la persona e' già a
+ * sistema, nome e cognome compaiono da soli», e senza di essa lo si farebbe spezzando lo screen in
+ * due con un elemento Action in mezzo.
+ *
+ * Identificazione e parametri sono **gli stessi** di un elemento Action (§5.9), codici di
+ * validazione compresi. Cambia una cosa sola, e riguarda l'editor: l'`assignToReference` di un
+ * `outputParameters` accetta anche i **campi di questa schermata**, che ovunque altrove sono di sola
+ * lettura.
+ */
+interface FlowScreenAction {
+    /**
+     * Il nome con cui la citano i `triggers`, e la radice di `Cerca.nome` con l'output automatico. Vive
+     * nello spazio dei nomi **comune** (§3.3): un'action omonima di una variabile o di un node e'
+     * `NAME_DUPLICATED`, ed e' l'unica cosa che tiene quel riferimento non ambiguo.
+     */
+    name?: string;
+    actionType?: string;
+    /** Obbligatorio: senza, `ACTION_NAME_MISSING`; fuori catalogo, `ACTION_UNKNOWN`. */
+    actionName?: string;
+    inputParameters?: FlowInputParameter[];
+    outputParameters?: FlowOutputParameter[];
+    /**
+     * Rende gli output leggibili come `<NomeAction>.<NomeOutput>`. **Non scrive in nessun campo**: e'
+     * la forma da proporre quando il risultato serve a una condizione, non a precompilare (§5.2).
+     */
+    storeOutputAutomatically?: boolean;
+}
+/**
+ * §5.2 — cosa fa scattare una screen action all'arrivo sulla schermata. L'unico valore ammesso e'
+ * `runOnLoad`: il `runOnRevisit` della specifica Salesforce e'
+ * `SCREEN_TRIGGER_INIT_BEHAVIOR_UNKNOWN`.
+ */
+type FlowScreenTriggerInitBehavior = 'runOnLoad' | string;
+/**
+ * §5.2 — chi invoca una screen action, e quando. Sta separato dalle `actions` perche' **piu' trigger
+ * possono invocare la stessa action**.
+ *
+ * Senza ne' `triggerFieldName` ne' `initBehavior` non scatterebbe mai: `SCREEN_TRIGGER_WITHOUT_CAUSE`.
+ */
+interface FlowScreenTrigger extends FlowConditionHolder {
+    /** Una delle `actions` **dello stesso screen**: altrimenti `SCREEN_ACTION_UNKNOWN`. */
+    screenActionName?: string;
+    /** Un campo **di questo screen**: altrimenti `SCREEN_TRIGGER_FIELD_UNKNOWN`. */
+    triggerFieldName?: string;
+    initBehavior?: FlowScreenTriggerInitBehavior;
+}
 /**
  * §5.2 — lo screen dinamico: **descrive i propri campi**, invece di referenziare un form.
  *
@@ -276,6 +324,10 @@ interface FlowDynamicScreen extends FlowNodeBase {
     /** Nome di uno stage dichiarato: alimenta l'indicatore di avanzamento. */
     stageReference?: string;
     fields?: FlowScreenField[];
+    /** Le action invocabili dai campi di questa schermata (§5.2). */
+    actions?: FlowScreenAction[];
+    /** Chi le invoca, e quando: due pezzi perche' piu' trigger possono chiamare la stessa action. */
+    triggers?: FlowScreenTrigger[];
     connector?: FlowConnector;
 }
 type FlowAssignmentOperator = 'Assign' | 'Add' | 'Subtract' | 'AddAtStart' | 'AssignCount' | 'RemoveFirst' | 'RemoveAll' | 'RemovePosition' | 'RemoveAfterFirst' | 'RemoveBeforeFirst' | 'RemoveUncommon' | string;
@@ -284,12 +336,12 @@ interface FlowAssignmentItem {
     operator?: FlowAssignmentOperator;
     value?: FlowValue;
 }
-/** §5.2 — le operazioni sono eseguite nell'ordine dichiarato. */
+/** §5.3 — le operazioni sono eseguite nell'ordine dichiarato. */
 interface FlowAssignment extends FlowNodeBase {
     assignmentItems?: FlowAssignmentItem[];
     connector?: FlowConnector;
 }
-/** §5.3 — una regola per ramo; l'ordine e' semantico. */
+/** §5.4 — una regola per ramo; l'ordine e' semantico. */
 interface FlowDecisionRule extends FlowConditionHolder {
     name?: string;
     label?: string;
@@ -301,7 +353,7 @@ interface FlowDecision extends FlowNodeBase {
     defaultConnector?: FlowConnector;
     defaultConnectorLabel?: string;
 }
-/** §5.4 */
+/** §5.5 */
 interface FlowLoop extends FlowNodeBase {
     collectionReference?: string;
     assignNextValueToReference?: string;
@@ -314,7 +366,7 @@ interface FlowSortOption {
     sortOrder?: FlowSortOrder;
     doesPutEmptyStringAndNullFirst?: boolean;
 }
-/** §5.5 — `assignNextValueToReference` e' l'elemento in esame, non la destinazione. */
+/** §5.6 — `assignNextValueToReference` e' l'elemento in esame, non la destinazione. */
 interface FlowCollectionProcessor extends FlowNodeBase, FlowConditionHolder {
     collectionProcessorType?: FlowCollectionProcessorType;
     collectionReference?: string;
@@ -323,7 +375,7 @@ interface FlowCollectionProcessor extends FlowNodeBase, FlowConditionHolder {
     sortOptions?: FlowSortOption[];
     connector?: FlowConnector;
 }
-/** §5.6 */
+/** §5.7 */
 interface FlowRecordLookup extends FlowNodeBase {
     object?: string;
     filterLogic?: FlowConditionLogic;
@@ -338,12 +390,12 @@ interface FlowRecordLookup extends FlowNodeBase {
     storeOutputAutomatically?: boolean;
     outputReference?: string;
     outputAssignments?: FlowOutputFieldAssignment[];
-    /** Modellato ma non tradotto in query (§5.6). */
+    /** Modellato ma non tradotto in query (§5.7). */
     relatedRecords?: unknown[];
     connector?: FlowConnector;
     faultConnector?: FlowConnector;
 }
-/** §5.7 */
+/** §5.8 */
 interface FlowRecordCreate extends FlowNodeBase {
     object?: string;
     inputReference?: string;
@@ -371,7 +423,7 @@ interface FlowRecordUpdate extends FlowNodeBase {
 interface FlowRecordDelete extends FlowNodeBase {
     object?: string;
     inputReference?: string;
-    /** Senza filtri e' un **errore**, non un avviso (§5.7). */
+    /** Senza filtri e' un **errore**, non un avviso (§5.8). */
     filters?: FlowRecordFilter[];
     connector?: FlowConnector;
     faultConnector?: FlowConnector;
@@ -379,7 +431,7 @@ interface FlowRecordDelete extends FlowNodeBase {
 interface FlowRecordRollback extends FlowNodeBase {
     connector?: FlowConnector;
 }
-/** §5.8 */
+/** §5.9 */
 interface FlowActionCall extends FlowNodeBase {
     actionType?: string;
     actionName?: string;
@@ -404,7 +456,7 @@ interface FlowScriptPluginCall extends FlowNodeBase {
     connector?: FlowConnector;
     faultConnector?: FlowConnector;
 }
-/** §5.9 — i `name` sono le variabili isInput/isOutput del flow **invocato**. */
+/** §5.10 — i `name` sono le variabili isInput/isOutput del flow **invocato**. */
 interface FlowSubflowInputAssignment {
     name?: string;
     value?: FlowValue;
@@ -420,7 +472,7 @@ interface FlowSubflow extends FlowNodeBase {
     storeOutputAutomatically?: boolean;
     connector?: FlowConnector;
 }
-/** §5.10 */
+/** §5.11 */
 interface FlowWaitEvent extends FlowConditionHolder {
     name?: string;
     label?: string;
@@ -438,7 +490,7 @@ interface FlowWait extends FlowNodeBase {
     defaultConnectorLabel?: string;
     faultConnector?: FlowConnector;
 }
-/** §5.11 */
+/** §5.12 */
 interface FlowCustomErrorMessage {
     errorMessage?: string;
     isFieldError?: boolean;
@@ -447,12 +499,12 @@ interface FlowCustomErrorMessage {
 interface FlowCustomError extends FlowNodeBase {
     customErrorMessages?: FlowCustomErrorMessage[];
 }
-/** §5.12 */
+/** §5.13 */
 interface FlowTransformValueAction {
     transformType?: FlowTransformType;
     /**
      * Il campo di destinazione, oppure — se il target e' una `Structure` — il nome del
-     * **membro** della classe (§5.12, §4.7).
+     * **membro** della classe (§5.13, §4.7).
      */
     outputFieldApiName?: string;
     value?: FlowValue;
@@ -475,7 +527,7 @@ interface FlowUnsupportedNode extends FlowNodeBase {
     [key: string]: unknown;
 }
 /**
- * §5.13 — i tre tipi di step. `stepMuleSoft` non esiste in questo sistema
+ * §5.14 — i tre tipi di step. `stepMuleSoft` non esiste in questo sistema
  * (`ELEMENT_NOT_SUPPORTED`); l'elenco autoritativo e' il dizionario `stageStepTypes`.
  */
 type FlowStageStepActionType = 'stepBackground' | 'stepInteractive' | 'stepApproval' | string;
@@ -487,7 +539,7 @@ interface FlowStageStepAssignee {
 /** Il nome di un *evaluation flow* che decide una condizione di ingresso o di uscita. */
 type FlowStageStepConditionActionType = 'EvaluationFlow' | string;
 /**
- * §5.13 — uno step di uno stage.
+ * §5.14 — uno step di uno stage.
  *
  * Due cose che non si vedono dal tipo:
  *  - gli step **non hanno un ordine di esecuzione**: parte quello le cui `entryConditions`
@@ -510,9 +562,9 @@ interface FlowStageStep {
     assignees?: FlowStageStepAssignee[];
     /** `"0"` o `"1"`: il modello lo porta come stringa. */
     requiresMultiMemberApproval?: string;
-    /** *Se* lo step si applica: se non si avverano, viene saltato (§5.13). */
+    /** *Se* lo step si applica: se non si avverano, viene saltato (§5.14). */
     entryConditions?: FlowCondition[];
-    /** *Quando* lo step libera lo stage: se restano false, lo stage va in stallo (§5.13). */
+    /** *Quando* lo step libera lo stage: se restano false, lo stage va in stallo (§5.14). */
     exitConditions?: FlowCondition[];
     /** Evaluation flow che decide l'ingresso: deve restituire `isOrchestrationConditionMet`. */
     entryActionName?: string;
@@ -520,7 +572,7 @@ interface FlowStageStep {
     exitActionName?: string;
     exitActionType?: FlowStageStepConditionActionType;
     inputParameters?: FlowInputParameter[];
-    /** `assignToReference` e' facoltativo: l'output e' già referenziabile (§5.13). */
+    /** `assignToReference` e' facoltativo: l'output e' già referenziabile (§5.14). */
     outputParameters?: FlowOutputParameter[];
     /** `true` → usa `outputConfigParams` come output finti, senza eseguire lo step. */
     debugSimulateStep?: boolean;
@@ -531,7 +583,7 @@ interface FlowOrchestratedStage extends FlowNodeBase {
     connector?: FlowConnector;
     /**
      * **Non** e' un ramo di guasto: e' il ramo percorso quando uno step viene rifiutato.
-     * Senza, un rifiuto fa fallire l'interview (§5.13).
+     * Senza, un rifiuto fa fallire l'interview (§5.14).
      */
     faultConnector?: FlowConnector;
 }
@@ -684,7 +736,7 @@ interface FlowComparisonOperatorEntry extends FlowDictionaryEntry {
     /** Tipi a cui l'operatore si applica; vuoto o assente = qualunque tipo. */
     appliesTo?: FlowDataType[] | null;
 }
-/** §5.2 — operatore di assegnazione. */
+/** §5.3 — operatore di assegnazione. */
 interface FlowAssignmentOperatorEntry extends FlowDictionaryEntry {
     /** Ha senso solo su destinazioni collection; altrove e' un avviso. */
     expectsCollection?: boolean;
@@ -707,7 +759,7 @@ interface FlowGlobalVariableEntry extends FlowDictionaryEntry {
     requiresRecordTrigger?: boolean;
 }
 /**
- * §5.13 — i tipi di step di uno stage di orchestrazione (`stageStepTypes`).
+ * §5.14 — i tipi di step di uno stage di orchestrazione (`stageStepTypes`).
  * Le colonne dicono cosa il tipo pretende: senza, l'editor dovrebbe cablare i tre nomi.
  */
 interface FlowStageStepTypeEntry extends FlowDictionaryEntry {
@@ -804,14 +856,14 @@ interface FlowFieldDescription {
     /**
      * `false` → non si puo' filtrare su questo campo. Non e' un dettaglio: la chiave di
      * un'entita' con chiave composta puo' essere **non filtrabile** (porta la forma canonica
-     * della chiave), e il filtro «per identificativo» va scritto una colonna alla volta (§5.7).
+     * della chiave), e il filtro «per identificativo» va scritto una colonna alla volta (§5.8).
      */
     isFilterable?: boolean;
     isSortable?: boolean;
-    /** Aggiornabile da un Update: altrimenti `FIELD_NOT_UPDATEABLE` (§5.7). */
+    /** Aggiornabile da un Update: altrimenti `FIELD_NOT_UPDATEABLE` (§5.8). */
     isUpdateable?: boolean;
     /**
-     * Valorizzabile da un Create: altrimenti `FIELD_NOT_CREATEABLE` (§5.7). **Non** e' lo stesso
+     * Valorizzabile da un Create: altrimenti `FIELD_NOT_CREATEABLE` (§5.8). **Non** e' lo stesso
      * insieme di `isUpdateable` — la colonna di una chiave naturale la scrive chi crea il record
      * e non si cambia dopo, un identificativo generato dal database e' l'opposto.
      */
@@ -880,15 +932,31 @@ interface FlowStructureDescription {
      */
     members?: FlowStructureMember[];
 }
+/**
+ * In quale dei due ruoli un artefatto del frontend e' utilizzabile (§5.1, §5.2, §6.4).
+ *
+ * `Form` e' una **schermata intera** (`formName` di uno Screen), `Component` un **componente**
+ * montabile dentro uno screen dinamico (`extensionName` di un `ComponentInstance`). `Any` — che
+ * e' anche cio' che significa il campo assente — dice «va bene in entrambi i posti»: un catalogo
+ * che il ruolo non lo dichiara non deve diventare un catalogo che vieta tutto.
+ */
+type FlowFormKind = 'Form' | 'Component' | 'Any' | string;
 /** Voce di catalogo per action, script, form, eventi, tipi di enum, classi. */
 interface FlowCatalogEntry {
     name: string;
     label?: string | null;
     description?: string | null;
+    /**
+     * Solo per il catalogo dei form. Assente = `Any`: proponibile sia come schermata sia come
+     * componente. Una voce usata nel ruolo sbagliato e' `FORM_KIND_MISMATCH`, che e' un errore
+     * **diverso** da «il nome non esiste» — il nome esiste, e dirlo sconosciuto manderebbe a
+     * cercare un artefatto che c'e' (§5.1, §7).
+     */
+    formKind?: FlowFormKind | null;
 }
 /**
  * Parametro dichiarato da un'action, uno script o un form.
- * Con il catalogo popolato un parametro inesistente e' un **errore** (§5.8).
+ * Con il catalogo popolato un parametro inesistente e' un **errore** (§5.9).
  */
 interface FlowCatalogParameter {
     name: string;
@@ -1147,11 +1215,11 @@ interface FlowPendingScreen {
     canPause?: boolean;
 }
 /**
- * §5.13 — lo stato che un assegnatario comunica concludendo uno step.
+ * §5.14 — lo stato che un assegnatario comunica concludendo uno step.
  * `Pending` non e' accettato in scrittura: e' `INVALID_REQUEST`.
  */
 type FlowStageStepStatus = 'Completed' | 'Rejected' | 'Cancelled' | 'Pending' | string;
-/** Lo stato di uno step, come lo riporta l'ispezione di una sospesa (§5.13, §6.5). */
+/** Lo stato di uno step, come lo riporta l'ispezione di una sospesa (§5.14, §6.5). */
 interface FlowStageStepState {
     stepName?: string;
     label?: string | null;
@@ -1191,7 +1259,7 @@ interface FlowInterviewResult {
      */
     isWaitingForEvent?: boolean;
     isWaitingForStageStep?: boolean;
-    /** Con `isWaitingForStageStep`: lo stato di ogni step dello stage corrente (§5.13). */
+    /** Con `isWaitingForStageStep`: lo stato di ogni step dello stage corrente (§5.14). */
     stageSteps?: FlowStageStepState[];
     isSuccess?: boolean;
 }
@@ -1213,7 +1281,7 @@ interface FlowResumeRequest {
     debug?: boolean;
 }
 /**
- * §5.13 — `POST /interviews/{key}/stage-step`: un assegnatario conclude uno step.
+ * §5.14 — `POST /interviews/{key}/stage-step`: un assegnatario conclude uno step.
  * Se lo stage si sospende di nuovo, la risposta porta una `interviewKey` **nuova** e la
  * vecchia non e' piu' valida.
  */
@@ -1391,7 +1459,7 @@ declare abstract class FlowBuilderApi {
      * `POST /flows/references/writable` — le variabili **piu' le globali assegnabili**, per i
      * campi di destinazione. Le globali assegnabili sono **due**, `$Flow.CurrentStage` e
      * `$Flow.ActiveStages`: quelle dell'host sono sempre di sola lettura e il catalogo non ha un
-     * flag per dichiararne una scrivibile (§5.2). La primitiva le comprende già, l'editor non le
+     * flag per dichiararne una scrivibile (§5.3). La primitiva le comprende già, l'editor non le
      * aggiunge. Restano fuori i campi di `$Record`, che dipendono dallo schema: quelli arrivano da
      * `listFields(object, 'updateable')` (§6.4).
      *
@@ -1424,8 +1492,18 @@ declare abstract class FlowBuilderApi {
     abstract listScripts(): Promise<FlowCatalogEntry[]>;
     /** `GET /catalog/scripts/{name}/parameters` */
     abstract listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
-    /** `GET /catalog/forms` — i form realizzati a mano nel frontend applicativo (§5.1). */
-    abstract listForms(): Promise<FlowCatalogEntry[]>;
+    /**
+     * `GET /catalog/forms?kind=` — gli artefatti realizzati a mano nel frontend applicativo (§5.1,
+     * §5.2). Un solo catalogo per due ruoli: le **schermate intere** che uno Screen mostra
+     * (`formName`) e i **componenti** che uno screen dinamico monta (`extensionName`) sono la
+     * stessa domanda al frontend — cosa sa rendere, e con quali parametri.
+     *
+     * `kind` filtra: `Form`, `Component`, o assente per tutto. Chiederlo non e' un dettaglio —
+     * proporre una schermata intera dove va un componente porta a `FORM_KIND_MISMATCH`, che e' un
+     * errore e blocca l'attivazione. Una voce senza `formKind` vale `Any` e resta proponibile in
+     * entrambi i posti: un catalogo che il ruolo non lo dichiara non deve vietare tutto (§6.4).
+     */
+    abstract listForms(kind?: FlowFormKind): Promise<FlowCatalogEntry[]>;
     /** `GET /catalog/forms/{name}/parameters` */
     abstract listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     /** `GET /catalog/enum-types` — per `objectType` delle risorse `Enum`. */
@@ -1483,7 +1561,7 @@ declare abstract class FlowBuilderApi {
     abstract listEvents(): Promise<FlowCatalogEntry[]>;
     /**
      * `GET /flows/subflow-candidates?excluding=` — solo i flow con una versione attiva,
-     * escluso quello corrente (§5.9).
+     * escluso quello corrente (§5.10).
      */
     abstract listSubflowCandidates(excluding?: string): Promise<FlowSummary[]>;
     /**
@@ -1497,14 +1575,14 @@ declare abstract class FlowBuilderApi {
     /** `POST /interviews/resume` — riprende un'esecuzione in pausa. */
     resumeInterview(request: FlowResumeRequest): Promise<FlowInterviewResult>;
     /**
-     * `POST /interviews/{key}/stage-step` — un assegnatario conclude uno step (§5.13).
+     * `POST /interviews/{key}/stage-step` — un assegnatario conclude uno step (§5.14).
      * Se lo stage si sospende di nuovo, la risposta porta una `interviewKey` **nuova**: la
      * vecchia non e' piu' valida e va sostituita, non conservata.
      */
     completeStageStep(request: FlowStageStepRequest): Promise<FlowInterviewResult>;
     /**
      * `GET /interviews/{key}` — ispeziona una sospesa senza consumarla.
-     * Con `isWaitingForStageStep` porta `stageSteps` con lo stato di ognuno (§5.13).
+     * Con `isWaitingForStageStep` porta `stageSteps` con lo stato di ognuno (§5.14).
      */
     inspectInterview(interviewKey: string): Promise<FlowInterviewResult>;
     /** `DELETE /interviews/{key}` — abbandona. */
@@ -1589,7 +1667,7 @@ declare class HttpFlowBuilderApi extends FlowBuilderApi {
     listActionParameters(actionType: string, actionName: string): Promise<FlowCatalogParameter[]>;
     listScripts(): Promise<FlowCatalogEntry[]>;
     listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
-    listForms(): Promise<FlowCatalogEntry[]>;
+    listForms(kind?: FlowFormKind): Promise<FlowCatalogEntry[]>;
     listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     listEnumTypes(): Promise<FlowCatalogEntry[]>;
     /** §4.6 — i valori di un tipo: `enumType` e' l'`objectType`, e va nel path come segmento. */
@@ -1658,7 +1736,7 @@ interface FlowOutlet {
      *
      * Vale sui soli elementi che possono fallire (Record*, ActionCall, ScriptCall, Wait):
      * il `faultConnector` di un `OrchestratedStage` porta `kind: 'Fault'` ma e' il ramo
-     * dello **step rifiutato** (§5.13), non un ramo di guasto, e la §7 non lo comprende.
+     * dello **step rifiutato** (§5.14), non un ramo di guasto, e la §7 non lo comprende.
      */
     isFaultRecovery?: boolean;
     read(node: FlowAnyNode): FlowConnector | undefined;
@@ -1695,7 +1773,7 @@ declare const TYPES_WITH_AUTOMATIC_OUTPUT: ReadonlySet<string>;
  */
 declare const FLOW_ELEMENT_ICONS: Record<string, string>;
 /**
- * Il glifo delle varianti (§5.5): due voci di palette dello stesso tipo con lo stesso simbolo
+ * Il glifo delle varianti (§5.6): due voci di palette dello stesso tipo con lo stesso simbolo
  * si distinguerebbero solo dall'etichetta, e sulla palette il simbolo e' la prima cosa che si
  * guarda. La chiave e' `tipo:variante`.
  */
@@ -1708,7 +1786,7 @@ declare const FLOW_ELEMENT_VARIANT_ICONS: Record<string, string>;
 declare function elementIcon(type: string, label?: string, variant?: string): string;
 
 /**
- * I tipi che sulla palette valgono per **piu' di una voce** — FRONTEND.md §5.5.
+ * I tipi che sulla palette valgono per **piu' di una voce** — FRONTEND.md §5.6.
  *
  * Il Collection Processor e' un solo tipo di node con un discriminatore
  * (`collectionProcessorType`: `Sort` o `Filter`), e i campi rilevanti cambiano con esso: un
@@ -1893,7 +1971,7 @@ declare function valuedFieldsOf(value: FlowValue | undefined | null): (keyof Flo
 declare function valuedFieldOf(value: FlowValue | undefined | null): keyof FlowValue | undefined;
 
 /**
- * Gli step di uno stage di orchestrazione — FRONTEND.md §5.13.
+ * Gli step di uno stage di orchestrazione — FRONTEND.md §5.14.
  *
  * Tre regole del contratto che non si vedono guardando il tipo, e che qui stanno in un posto
  * solo perche' le usano l'inspector, lo spazio dei nomi del documento e la validazione locale:
@@ -1913,14 +1991,14 @@ declare function stepsOf(stage: FlowOrchestratedStage | undefined): FlowStageSte
 /**
  * Il nome dello step il cui output un riferimento sta leggendo, se e' uno degli step passati.
  * `undefined` quando il riferimento e' legittimo. Serve a impedire nell'editor la condizione
- * che referenzia l'output di un altro step (§5.13, punto 4): la strada corretta e' scrivere
+ * che referenzia l'output di un altro step (§5.14, punto 4): la strada corretta e' scrivere
  * quel risultato in una variabile con `outputParameters.assignToReference` e condizionare
  * su quella.
  */
 declare function stageStepOutputReferenced(reference: string | undefined, steps: FlowStageStep[]): string | undefined;
 /**
  * L'unico output che il runtime legge da un evaluation flow di condizione. Dichiararne altri
- * e' `STAGE_ACTION_INVALID` (§5.13, punto 7).
+ * e' `STAGE_ACTION_INVALID` (§5.14, punto 7).
  */
 declare const ORCHESTRATION_CONDITION_OUTPUT = "isOrchestrationConditionMet";
 
@@ -1967,6 +2045,18 @@ declare function allFieldsOf(screen: FlowDynamicScreen | undefined): FlowScreenF
  * Chi vuole i **soli** riferimenti proponibili usa `isFieldResource`.
  */
 declare function screenFieldNames(definition: FlowDefinition | undefined): string[];
+/**
+ * §3.3, §5.2 — i nomi delle **screen action** di tutti gli screen dinamici del documento.
+ *
+ * Stanno nello spazio dei nomi comune per la stessa ragione dei campi e degli step: con
+ * `storeOutputAutomatically` il nome dell'action e' la **radice** di un riferimento (`Cerca.nome`), e
+ * un'omonimia con una variabile — o con una `Structure` chiamata `Cerca` — renderebbe quel riferimento
+ * ambiguo. Quindi entrano in `usedNames` e un omonimo e' `NAME_DUPLICATED`.
+ *
+ * Ci entrano **tutte**, anche senza output automatico: il nome e' unico o non lo e', e farlo dipendere
+ * da un flag significherebbe che accendere quel flag fa comparire un errore altrove.
+ */
+declare function screenActionNames(definition: FlowDefinition | undefined): string[];
 /**
  * §5.2 — il campo e' una risorsa del flow (`kind: "ScreenField"`), quindi referenziabile
  * per nome ovunque e **di sola lettura**.
@@ -2101,7 +2191,7 @@ declare class FlowDictionaryStore {
     readonly paletteCategories: _angular_core.Signal<string[]>;
     elementType(value: string): FlowElementTypeEntry | undefined;
     /**
-     * Le varianti di un tipo, cioe' i valori del suo discriminatore (§5.5). L'unico oggi e' il
+     * Le varianti di un tipo, cioe' i valori del suo discriminatore (§5.6). L'unico oggi e' il
      * Collection Processor. Elenco vuoto = tipo senza varianti, **oppure** dizionario non
      * disponibile: in entrambi i casi la palette mostra una voce sola, che e' l'unica cosa
      * onesta da fare quando non si sa quali varianti esistano.
@@ -2141,11 +2231,11 @@ declare class FlowDictionaryStore {
     isGlobalScopeVerifiable(scope: string | undefined | null): boolean;
     /** I percorsi noti di uno scope, già prefissati: `$User.Email`. */
     globalPathsOf(scope: string | undefined | null): string[];
-    /** §5.13 — la voce di `stageStepTypes` di un `actionType`. */
+    /** §5.14 — la voce di `stageStepTypes` di un `actionType`. */
     stageStepType(value: string | undefined | null): FlowStageStepTypeEntry | undefined;
     /** `stepBackground` vuole `actionName`; il fallback serve se il dizionario non lo dichiara. */
     stageStepRequiresActionName(actionType: string | undefined | null): boolean;
-    /** `stepInteractive` e `stepApproval` vogliono gli assegnatari (§5.13). */
+    /** `stepInteractive` e `stepApproval` vogliono gli assegnatari (§5.14). */
     stageStepRequiresAssignees(actionType: string | undefined | null): boolean;
     dataType(value: string | undefined | null): FlowDataTypeEntry | undefined;
     /** §4.6, §4.7 — `Object`, `Enum` e `Structure` richiedono `objectType`. */
@@ -2215,7 +2305,12 @@ declare class FlowCatalogStore {
     listActionParameters(actionType: string, actionName: string): Promise<FlowCatalogParameter[]>;
     listScripts(): Promise<FlowCatalogEntry[]>;
     listScriptParameters(scriptName: string): Promise<FlowCatalogParameter[]>;
-    listForms(): Promise<FlowCatalogEntry[]>;
+    /**
+     * La cache e' **per ruolo**: `Form` e `Component` sono due risposte diverse dello stesso
+     * catalogo, e una chiave sola le farebbe sovrascrivere a vicenda — il primo inspector aperto
+     * deciderebbe cosa vede il secondo (§6.4).
+     */
+    listForms(kind?: FlowFormKind): Promise<FlowCatalogEntry[]>;
     listFormParameters(formName: string): Promise<FlowCatalogParameter[]>;
     listEnumTypes(): Promise<FlowCatalogEntry[]>;
     /**
@@ -2251,7 +2346,7 @@ declare class FlowCatalogStore {
 }
 
 /**
- * Navigazione dei percorsi puntati — FRONTEND.md §4.4, §4.7, §4.7.1, §5.2, §5.7.
+ * Navigazione dei percorsi puntati — FRONTEND.md §4.4, §4.7, §4.7.1, §5.2, §5.8.
  *
  * La specifica e' cambiata su questo punto: i percorsi con il punto **si verificano**. Un percorso
  * di relazione (`Cliente.Citta`) si naviga un segmento alla volta e l'ultimo si verifica come un
@@ -2274,7 +2369,7 @@ declare class FlowCatalogStore {
  *  - **scrivibile** non vuol dire la stessa cosa nei due mondi: un membro porta il proprio
  *    `isWritable`, un campo no — fuori da un Create o da un Update il contesto non c'e', quindi
  *    basta che sia `isCreateable` **oppure** `isUpdateable`, e un campo che non e' ne' l'uno ne'
- *    l'altro e' `TARGET_NOT_WRITABLE` in qualunque contesto (§5.7).
+ *    l'altro e' `TARGET_NOT_WRITABLE` in qualunque contesto (§5.8).
  */
 
 /** Una tappa navigabile: un'entita' dello schema, oppure una classe (§4.7). */
@@ -2503,12 +2598,15 @@ declare class FlowDocumentStore {
     readonly nodeByName: _angular_core.Signal<Map<string, FlowNodeRef>>;
     readonly resources: _angular_core.Signal<FlowResourceRef[]>;
     /**
-     * §3.3 — l'insieme dei nomi già usati: node, risorse, step di orchestrazione **e campi di
-     * screen dinamico**, un unico spazio di nomi. Il controllo di unicita' che guarda solo le
-     * variabili lascia passare una variabile omonima di un node (§13.5); quello che dimentica gli
-     * step lascia passare uno step omonimo di una variabile (§5.13); quello che dimentica i campi
-     * lascia passare un campo omonimo di una variabile, che e' `NAME_DUPLICATED` come gli altri
-     * — e lì il danno e' peggiore, perche' un campo **e' un riferimento** (§5.2).
+     * §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,
+     * campi di screen dinamico e screen action.
+     *
+     * Il controllo di unicita' che guarda solo le variabili lascia passare una variabile omonima di un
+     * node (§13.5); quello che dimentica gli step lascia passare uno step omonimo di una variabile;
+     * quello che dimentica i campi o le action lascia passare un omonimo che e' `NAME_DUPLICATED` come
+     * gli altri — e lì il danno e' peggiore, perche' quel nome **e' un riferimento**: un campo si legge
+     * per nome, e il nome di un'action e' la radice dei suoi output automatici (`Cerca.nome`, §5.2).
      */
     readonly usedNames: _angular_core.Signal<string[]>;
     /** Gli archi derivati dal documento, Start incluso. */
@@ -2587,7 +2685,7 @@ declare class FlowDocumentStore {
         x: number;
         y: number;
     }): void;
-    /** Scrive la destinazione di un'uscita. `target` assente → il ramo resta incompleto. */
+    /** Scrive la destinazione di un'uscita. `target` assente → il ramo si stacca del tutto. */
     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;
@@ -2752,7 +2850,15 @@ declare class FlowEditorSession {
     readonly lastSaveResult: _angular_core.Signal<FlowSaveResult | null>;
     readonly conflict: _angular_core.Signal<FlowConflictState | null>;
     readonly expectedUpdatedAt: _angular_core.Signal<string | undefined>;
-    /** `true` finche' il flow non e' mai stato salvato: il comando e' "Crea", non "Salva". */
+    /**
+     * `true` finche' il flow non e' mai stato salvato: il comando e' "Crea", non "Salva".
+     *
+     * Il confronto e' `== null` e non `=== null` di proposito: il segnale e' tipato
+     * `number | null`, ma cio' che ci arriva viene da una risposta del backend, e una risposta
+     * senza `version` porta `undefined`. Con `=== null` un `undefined` sarebbe «versione nota»:
+     * lo stato diventa «Nuovo» con il chip «v», il comando primario «Nuova versione» e l'editor
+     * in sola lettura, tutti insieme, senza nessun errore che lo spieghi.
+     */
     readonly isNew: _angular_core.Signal<boolean>;
     readonly currentVersionSummary: _angular_core.Signal<FlowVersionSummary | undefined>;
     /**
@@ -2775,8 +2881,18 @@ declare class FlowEditorSession {
     open(flowName: string, version?: number): Promise<void>;
     /** Senza `version` il backend restituisce la versione attiva, altrimenti l'ultima (§6.1). */
     private static pickVersion;
-    /** Ricarica l'elenco versioni: dopo un'attivazione la precedente e' `Obsolete` (§8.4). */
-    refreshVersions(): Promise<void>;
+    /**
+     * Ricarica l'elenco versioni: dopo un'attivazione la precedente e' `Obsolete` (§8.4).
+     *
+     * `adoptVersion` serve dopo una scrittura la cui risposta non porta il numero di versione
+     * (§6.2): l'elenco e' l'altra fonte che quel numero lo sa, e senza il ripiego un flow appena
+     * creato resterebbe «Nuovo» — cioe' il salvataggio successivo tenterebbe una *creazione* su un
+     * nome che esiste già. Sta dietro un flag perche' altrove una versione assente e' un flow
+     * davvero nuovo, e adottarla lo farebbe passare per salvato.
+     */
+    refreshVersions(options?: {
+        adoptVersion?: boolean;
+    }): Promise<void>;
     /**
      * Crea o salva, a seconda dello stato. Non lancia su definizione invalida: il
      * salvataggio riesce anche con errori e il chiamante legge `validation` (§8.2).
@@ -2788,7 +2904,44 @@ declare class FlowEditorSession {
         activate?: boolean;
         flowName?: string;
     }): Promise<FlowSaveResult>;
+    /**
+     * Il risultato di una scrittura riportato alla forma su cui l'editor puo' contare.
+     *
+     * La §6.2 dice che `flowName` e `version` ci sono sempre, ma se mancano — risposta vuota,
+     * `204`, o piu' spesso un host che serializza in PascalCase, dove `Version` non e' `version` —
+     * il difetto non e' un errore: e' `undefined` che entra nello stato della sessione e ricompare
+     * ovunque. Il chip della versione diventa «v», il banner dice «Versione undefined attivata», e
+     * al salvataggio successivo si manda `flowName: undefined`. Nessuna eccezione, nessun rilievo.
+     *
+     * Cio' che sappiamo lo sappiamo già: il nome del flow e la versione sono quelli che abbiamo
+     * appena chiesto di scrivere. Si tengono, e la discrepanza si dice **una volta** in console —
+     * a chi integra, perche' e' la sua risposta a non avere la forma del contratto.
+     */
+    private normalizeResult;
+    private static readonly warned;
+    private static warnOnce;
     private applySaveResult;
+    /**
+     * Duplica: scrive il flow **sotto un altro nome** e sposta la sessione sulla copia
+     * (§6.2, «Duplica»).
+     *
+     * Due strade, e la differenza non e' un dettaglio di implementazione: `cloneFlow` copia cio'
+     * che il backend ha **salvato**, quindi su un documento con modifiche in corso la copia
+     * nascerebbe senza quelle modifiche — senza nessun errore, e chi duplica per mettere al
+     * sicuro cio' che ha appena scritto si ritroverebbe la versione vecchia. Per questo la
+     * primitiva si usa solo su un documento pulito; altrimenti la copia si crea con `createFlow`
+     * mandando il documento in mano. La stessa strada e' il ripiego quando `cloneFlow` non c'e':
+     * e' opzionale, e `createFlow` no (§10).
+     *
+     * La sessione si sposta sulla copia perche' e' cio' che «salva con nome» significa: restare
+     * sull'originale farebbe finire il salvataggio successivo nel flow sbagliato. Chi monta il
+     * builder lo scopre dall'output `saved`, il cui `flowName` e' quello nuovo.
+     */
+    saveAs(targetFlowName: string, options?: {
+        label?: string;
+    }): Promise<FlowSaveResult>;
+    /** La copia creata dal documento in lavorazione, modifiche non salvate comprese. */
+    private createCopy;
     /** Copia la versione corrente in una nuova bozza (§8.1): il comando delle versioni chiuse. */
     createNewVersion(): Promise<FlowSaveResult>;
     /**
@@ -2949,7 +3102,7 @@ declare class FlowCanvasComponent {
     /** Rilascio di un elemento dalla palette: tipo + punto nel sistema del canvas. */
     readonly elementDropped: _angular_core.OutputEmitterRef<{
         type: FlowElementType;
-        /** La variante scelta sulla palette, dove il tipo ne ha (§5.5). */
+        /** La variante scelta sulla palette, dove il tipo ne ha (§5.6). */
         variant?: string;
         x: number;
         y: number;
@@ -2987,9 +3140,10 @@ declare class FlowCanvasComponent {
     /** Sullo Start conta il trigger: e' cio' che decide quando il flow parte (§3.4). */
     private startSubtitle;
     /**
-     * Creazione di un arco. `targetId` assente significa rilascio nel vuoto: si lascia il
-     * ramo dichiarato ma senza destinazione, che e' esattamente il "ramo incompleto" del
-     * modello, invece di scartare il gesto.
+     * Creazione di un arco. `targetId` assente significa rilascio nel vuoto: il ramo resta
+     * **staccato**, cioe' omesso dal documento (`CONNECTOR_MISSING`, «il percorso finisce
+     * qui»), non dichiarato-senza-destinazione — che sarebbe `CONNECTOR_TARGET_MISSING`, un
+     * avviso su un ramo che l'utente non ha mai voluto collegare.
      */
     onCreateConnection(event: {
         sourceId: string;
@@ -3059,7 +3213,7 @@ declare class FlowCanvasComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlowCanvasComponent, "fb-flow-canvas", never, { "selectedName": { "alias": "selectedName"; "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>;
 }
 
-/** Il gesto scelto sulla palette: un tipo e, dove esiste, la sua variante (§5.5). */
+/** Il gesto scelto sulla palette: un tipo e, dove esiste, la sua variante (§5.6). */
 interface FlowPalettePick {
     type: FlowElementType;
     variant?: string;
@@ -3113,7 +3267,7 @@ declare class ElementPaletteComponent {
     /**
      * L'etichetta del ramo di fault, presa dalla mappa delle uscite invece di scrivere «ramo di
      * errore» per tutti: su uno stage di orchestrazione quel ramo **non** e' un guasto, e' lo step
-     * rifiutato (§5.13). Un tipo nuovo eredita l'etichetta giusta senza toccare la palette.
+     * rifiutato (§5.14). Un tipo nuovo eredita l'etichetta giusta senza toccare la palette.
      */
     faultLabel(item: PaletteItem): string | null;
     categoryClass(category: string): string;
@@ -3144,6 +3298,18 @@ declare class ReferencePickerComponent {
      * `WasVisited` e `HasError` (§4.3).
      */
     readonly elementsOnly: _angular_core.InputSignal<boolean>;
+    /**
+     * Destinazioni in piu' rispetto a cio' che la primitiva restituisce, e oggi ce n'e' **un solo**
+     * chiamante: l'`assignToReference` di una **screen action**, che accetta i campi della schermata
+     * che si sta modificando (§5.2). Altrove quei campi sono di sola lettura, e
+     * `POST /flows/references/writable` continua a escluderli — giustamente: un Assignment che ci
+     * scrive resta `TARGET_NOT_WRITABLE`. Non e' quindi una scorciatoia per aggiungere riferimenti che
+     * il backend non conosce: e' l'unico punto in cui la regola del contratto e' diversa.
+     *
+     * Entrano **sia** fra le proposte **sia** fra le radici: senza le radici un nome scritto a mano
+     * verrebbe accusato di non esistere.
+     */
+    readonly extraReferences: _angular_core.InputSignal<FlowReference[]>;
     readonly valueChange: _angular_core.OutputEmitterRef<string | undefined>;
     /**
      * L'elenco come arriva dalla primitiva, **senza** il filtro di tipo.
@@ -3185,7 +3351,20 @@ declare class ReferencePickerComponent {
      * `String` sta solo nell'elenco non filtrato.
      */
     private readonly declaredPrefix;
+    /**
+     * La radice **verificabile**: e' quella su cui si giudica il valore scritto (`valueState`), e
+     * tiene fuori gli output automatici perche' la validazione non guarda i loro percorsi (§4.5, §7).
+     */
     private readonly navigableRoot;
+    /**
+     * La radice da cui si **propone**, che comprende anche gli output automatici. Sono due computed e
+     * non uno perche' le due domande sono diverse: proporre i campi di `Leggi_Ordine` aiuta a scrivere
+     * `Leggi_Ordine.Numero` — un riferimento valido — mentre giudicarne i segmenti significherebbe
+     * accusare cio' che il backend non verifica. Con una radice sola una delle due cose sarebbe
+     * sbagliata: o la riga sparisce dai campi tipizzati, o un campo scritto a mano diventa
+     * `FIELD_UNKNOWN` senza che nessuna primitiva lo dica.
+     */
+    private readonly proposalRoot;
     /** Il percorso dopo la radice: `Cliente.Email` di `Richiesta.Cliente.Email`. */
     private readonly navigatedPath;
     private readonly navigation;
@@ -3195,16 +3374,22 @@ declare class ReferencePickerComponent {
     /**
      * I segmenti come riferimenti navigati: `Richiesta.Cliente.Email`, col tipo del segmento. Un
      * segmento di sola lettura non si propone in un campo di destinazione, a meno che da lì il
-     * percorso continui: `Richiesta.Cliente` non si assegna, ma `Richiesta.Cliente.Email` sì (§5.7).
+     * percorso continui: `Richiesta.Cliente` non si assegna, ma `Richiesta.Cliente.Email` sì (§5.8).
      */
     /**
-     * §5.2 — dentro una globale dell'host **niente** e' scrivibile, per quanto il membro si dichiari
+     * §5.3 — dentro una globale dell'host **niente** e' scrivibile, per quanto il membro si dichiari
      * tale: le globali le risolve un componente che non ha modo di scriverle, e proporle come
      * destinazione farebbe attivare un flow che poi fallisce davanti all'utente. L'eccezione sono i
      * campi del record che innesca, che si assegnano (§4.1).
      */
     private readonly isReadOnlyPath;
     private readonly pathReferences;
+    /**
+     * Cosa dire di un segmento proposto. Sotto un output automatico «sola lettura» sarebbe vero ma
+     * fuorviante — in un campo che vuole un valore nessuno stava cercando una destinazione: cio' che
+     * cambia il comportamento e' che il percorso non lo verifica nessuno (§4.5).
+     */
+    private segmentDescription;
     /**
      * Lo stesso filtro delle radici (§6.4), applicato ai segmenti di un percorso: in un parametro
      * `String` non si propone un membro `Date`. Un segmento da cui si scende resta comunque proposto
@@ -3268,14 +3453,24 @@ declare class ReferencePickerComponent {
      * essere il riferimento che si vuole **oppure** la tappa da cui continuare.
      */
     descend(reference: FlowReference): void;
-    /** `true` se da questo riferimento il percorso continua: la sua forma e' dichiarata. */
+    /**
+     * `true` se da questo riferimento il percorso continua, cioe' se si conosce la forma di cio' che
+     * designa. Comprende gli **output automatici** di un elemento: `Leggi_Ordine` dichiara la propria
+     * entita', quindi i suoi campi si possono proporre — che il backend non verifichi i segmenti dopo
+     * il punto (§4.5) cambia cosa si **dice** del valore scritto, non cosa si puo' proporre. Prima
+     * l'esclusione era qui, e l'effetto era che in un campo tipizzato la riga spariva del tutto: il
+     * filtro di tipo scarta il record, e senza `›` non restava nessuna strada verso `Leggi_Ordine.Numero`.
+     *
+     * Una collection resta esclusa: il riferimento designa l'insieme, e un campo di un insieme non
+     * esiste — per scorrerlo c'e' il Loop.
+     */
     canDescend(reference: FlowReference): boolean;
     /** Scrittura libera: indispensabile per gli scope dell'host e per i percorsi non enumerabili. */
     onManualInput(value: string): void;
     clear(): void;
     describe(reference: FlowReference): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReferencePickerComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReferencePickerComponent, "fb-reference-picker", never, { "value": { "alias": "value"; "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; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "isCollection": { "alias": "isCollection"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; "writableOnly": { "alias": "writableOnly"; "required": false; "isSignal": true; }; "elementsOnly": { "alias": "elementsOnly"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReferencePickerComponent, "fb-reference-picker", never, { "value": { "alias": "value"; "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; }; "dataType": { "alias": "dataType"; "required": false; "isSignal": true; }; "isCollection": { "alias": "isCollection"; "required": false; "isSignal": true; }; "objectType": { "alias": "objectType"; "required": false; "isSignal": true; }; "writableOnly": { "alias": "writableOnly"; "required": false; "isSignal": true; }; "elementsOnly": { "alias": "elementsOnly"; "required": false; "isSignal": true; }; "extraReferences": { "alias": "extraReferences"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 declare class ObjectPickerComponent {
@@ -3400,6 +3595,15 @@ declare class NamePickerComponent {
      * senza versione attiva e' un avviso. Mostrarli con lo stesso colore direbbe il falso.
      */
     readonly unknownSeverity: _angular_core.InputSignal<"error" | "warn">;
+    /**
+     * Nomi che **esistono** ma non sono utilizzabili qui. Il caso vero e' il catalogo dei form,
+     * dove una schermata intera e un componente vivono nello stesso elenco e si distinguono per
+     * `formKind`: usare l'uno al posto dell'altro e' `FORM_KIND_MISMATCH`, non `FORM_UNKNOWN`
+     * (§5.1, §5.2). Senza questo secondo elenco il picker direbbe «non esiste» di un nome che c'e',
+     * e manderebbe a cercare un artefatto già scritto.
+     */
+    readonly unusableOptions: _angular_core.InputSignal<NamePickerOption[]>;
+    readonly unusableMessage: _angular_core.InputSignal<string>;
     /** Cosa dire quando l'elenco e' vuoto: e' il caso "non lo so", non un errore. */
     readonly emptyMessage: _angular_core.InputSignal<string>;
     /** Testo monospazio: i nomi tecnici si leggono meglio, ed e' come li mostra il resto del form. */
@@ -3411,6 +3615,8 @@ declare class NamePickerComponent {
     readonly text: _angular_core.Signal<string>;
     readonly visibleOptions: _angular_core.Signal<NamePickerOption[]>;
     readonly hasOptions: _angular_core.Signal<boolean>;
+    /** Il nome c'e' nel catalogo, ma in un ruolo che qui non va: e' un errore a se' (§7). */
+    readonly isUnusable: _angular_core.Signal<boolean>;
     readonly isUnknown: _angular_core.Signal<boolean>;
     readonly labelOfValue: _angular_core.Signal<string | null>;
     open(): void;
@@ -3421,7 +3627,7 @@ declare class NamePickerComponent {
     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; }; "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; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 declare class StructurePickerComponent {
@@ -3501,7 +3707,7 @@ declare class StructureMemberPickerComponent {
     /**
      * Un segmento che esiste ma non e' scrivibile, scelto dove serve una destinazione: capita su un
      * documento scritto altrove, e va detto qui invece di lasciarlo scoprire dall'attivazione. Su un
-     * campo di record "scrivibile" vuol dire `createable` **oppure** `updateable` (§5.7).
+     * campo di record "scrivibile" vuol dire `createable` **oppure** `updateable` (§5.8).
      */
     readonly isNotWritable: _angular_core.Signal<boolean>;
     readonly notWritableMessage: _angular_core.Signal<"Questo campo non si scrive ne’ creando ne’ aggiornando un record: assegnarlo e’ TARGET_NOT_WRITABLE." | "Questo membro e’ calcolato: si legge, ma assegnarlo e’ TARGET_NOT_WRITABLE.">;
@@ -3742,7 +3948,7 @@ declare class ConditionEditorComponent {
     readonly allowFormula: _angular_core.InputSignal<boolean>;
     /**
      * `false` dove il modello porta **solo** la lista di condizioni, senza un campo per la
-     * logica: gli `entryConditions` / `exitConditions` di uno step di orchestrazione (§5.13).
+     * logica: gli `entryConditions` / `exitConditions` di uno step di orchestrazione (§5.14).
      * Mostrare i pulsanti della logica lì scriverebbe un campo che il contratto non prevede.
      */
     readonly allowLogic: _angular_core.InputSignal<boolean>;
@@ -3783,7 +3989,7 @@ declare class ConditionEditorComponent {
      */
     hasTypeMismatch(condition: FlowCondition): boolean;
     typeMismatchMessage(condition: FlowCondition): string;
-    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "custom" | "formula">;
     readonly customLogic: _angular_core.Signal<string>;
     /** Feedback immediato sull'espressione: la verita' resta della validazione backend. */
     readonly customLogicError: _angular_core.Signal<string | null>;
@@ -3848,12 +4054,12 @@ declare class RecordFilterEditorComponent {
     /**
      * Avviso da mostrare quando la lista e' vuota. Un Delete senza filtri e' un **errore**,
      * un Update senza filtri e' solo un avviso — ma aggiorna tutti i record dell'entita'
-     * (§5.7, §13.10).
+     * (§5.8, §13.10).
      */
     readonly emptyWarning: _angular_core.InputSignal<string | null>;
     readonly emptyWarningSeverity: _angular_core.InputSignal<"error" | "warn">;
     readonly changed: _angular_core.OutputEmitterRef<(holder: FilterHolder) => void>;
-    /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.7). */
+    /** Tutti i campi, filtrabili o no: serve solo a riconoscere le chiavi composte (§5.8). */
     private readonly allFields;
     readonly filters: _angular_core.Signal<FlowRecordFilter[]>;
     readonly operators: _angular_core.Signal<_esfaenza_flow_builder.FlowDictionaryEntry[]>;
@@ -3869,12 +4075,12 @@ declare class RecordFilterEditorComponent {
     private readonly types;
     constructor();
     /**
-     * §5.7 — l'identificativo esiste ma **non e' filtrabile**: e' il caso di una chiave composta,
+     * §5.8 — l'identificativo esiste ma **non e' filtrabile**: e' il caso di una chiave composta,
      * dove `Id` porta la forma canonica della chiave e le colonne filtrabili sono altre. Dirlo
      * evita la ricerca di un campo che nell'elenco non c'e' e non ci sara'.
      */
     readonly identifierNotFilterable: _angular_core.Signal<boolean>;
-    readonly logicMode: _angular_core.Signal<"and" | "or" | "formula" | "custom">;
+    readonly logicMode: _angular_core.Signal<"and" | "or" | "custom" | "formula">;
     readonly customLogic: _angular_core.Signal<string>;
     readonly showEmptyWarning: _angular_core.Signal<boolean>;
     addFilter(): void;
@@ -3917,6 +4123,12 @@ declare class ParameterEditorComponent {
     readonly showOutputs: _angular_core.InputSignal<boolean>;
     /** `true` → gli output vanno all'output automatico, e i parametri sono ignorati. */
     readonly outputsDisabledReason: _angular_core.InputSignal<string | null>;
+    /**
+     * Destinazioni in piu' per `assignToReference`, oltre a quelle scrivibili. Serve alle **screen
+     * action**, dove un output si assegna a un campo della schermata (§5.2): e' l'unico posto in cui
+     * quei campi sono una destinazione, e per questo non e' un default ma un parametro del chiamante.
+     */
+    readonly extraTargets: _angular_core.InputSignal<FlowReference[]>;
     readonly changed: _angular_core.OutputEmitterRef<(holder: ParameterHolder) => void>;
     readonly inputs: _angular_core.Signal<FlowInputParameter[]>;
     readonly outputs: _angular_core.Signal<FlowOutputParameter[]>;
@@ -3945,7 +4157,7 @@ declare class ParameterEditorComponent {
     setOutputName(index: number, name: string): void;
     setOutputTarget(index: number, reference: string | undefined): void;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<ParameterEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ParameterEditorComponent, "fb-parameter-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "catalogParameters": { "alias": "catalogParameters"; "required": false; "isSignal": true; }; "inputTitle": { "alias": "inputTitle"; "required": false; "isSignal": true; }; "outputTitle": { "alias": "outputTitle"; "required": false; "isSignal": true; }; "showInputs": { "alias": "showInputs"; "required": false; "isSignal": true; }; "showOutputs": { "alias": "showOutputs"; "required": false; "isSignal": true; }; "outputsDisabledReason": { "alias": "outputsDisabledReason"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ParameterEditorComponent, "fb-parameter-editor", never, { "holder": { "alias": "holder"; "required": true; "isSignal": true; }; "catalogParameters": { "alias": "catalogParameters"; "required": false; "isSignal": true; }; "inputTitle": { "alias": "inputTitle"; "required": false; "isSignal": true; }; "outputTitle": { "alias": "outputTitle"; "required": false; "isSignal": true; }; "showInputs": { "alias": "showInputs"; "required": false; "isSignal": true; }; "showOutputs": { "alias": "showOutputs"; "required": false; "isSignal": true; }; "outputsDisabledReason": { "alias": "outputsDisabledReason"; "required": false; "isSignal": true; }; "extraTargets": { "alias": "extraTargets"; "required": false; "isSignal": true; }; }, { "changed": "changed"; }, never, never, true, never>;
 }
 
 interface FieldAssignmentHolder {
@@ -3955,7 +4167,7 @@ declare class FieldAssignmentEditorComponent {
     private readonly catalog;
     readonly holder: _angular_core.InputSignal<FieldAssignmentHolder>;
     readonly object: _angular_core.InputSignal<string | undefined>;
-    /** `createable` su un Create, `updateable` su un Update: lo decide il chiamante (§5.7). */
+    /** `createable` su un Create, `updateable` su un Update: lo decide il chiamante (§5.8). */
     readonly usage: _angular_core.InputSignal<FlowFieldUsage>;
     readonly title: _angular_core.InputSignal<string>;
     readonly disabledReason: _angular_core.InputSignal<string | null>;
@@ -4055,6 +4267,13 @@ declare class ElementInspectorComponent {
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly removeRequested: _angular_core.OutputEmitterRef<string>;
     readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Il nuovo nome, dopo la rinomina. La selezione dell'editor e' **il nome**: se non la
+     * riportiamo sul nome nuovo, `selectedName` punta a un elemento che non esiste piu' e il
+     * form del tipo — che sta dietro `@if (node())` — spariva, lasciando la dialog mezza vuota
+     * finche' non la si chiudeva e riapriva.
+     */
+    readonly renamed: _angular_core.OutputEmitterRef<string>;
     readonly isStart: _angular_core.Signal<boolean>;
     readonly reference: _angular_core.Signal<_esfaenza_flow_builder.FlowNodeRef | undefined>;
     readonly node: _angular_core.Signal<FlowAnyNode | undefined>;
@@ -4090,7 +4309,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"; }, 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; }; }, { "closed": "closed"; "removeRequested": "removeRequested"; "duplicateRequested": "duplicateRequested"; "renamed": "renamed"; }, never, never, true, never>;
 }
 
 declare class ElementDialogComponent {
@@ -4101,6 +4320,8 @@ declare class ElementDialogComponent {
     readonly closed: _angular_core.OutputEmitterRef<void>;
     readonly removeRequested: _angular_core.OutputEmitterRef<string>;
     readonly duplicateRequested: _angular_core.OutputEmitterRef<string>;
+    /** Il nuovo nome dopo una rinomina: la selezione dell'editor deve seguirlo. */
+    readonly renamed: _angular_core.OutputEmitterRef<string>;
     private readonly panel;
     readonly isStart: _angular_core.Signal<boolean>;
     private readonly reference;
@@ -4110,8 +4331,9 @@ declare class ElementDialogComponent {
     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"; }, never, never, true, 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>;
 }
 
 declare class StartInspectorComponent {
@@ -4174,7 +4396,7 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
     readonly conditionOutputName = "isOrchestrationConditionMet";
     /**
      * I flow proponibili come step in background o come evaluation flow. Una lista vuota
-     * significa "non lo so": in quel caso il campo resta scrivibile a mano (§5.9, §7).
+     * significa "non lo so": in quel caso il campo resta scrivibile a mano (§5.10, §7).
      */
     private readonly flowCandidates;
     constructor();
@@ -4200,14 +4422,14 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
     stepNameError(step: FlowStageStep): string | null;
     /**
      * Il nome dello step il cui output una condizione sta leggendo: e' irrisolvibile finche'
-     * quello step non ha girato (§5.13, punto 4). `undefined` quando va tutto bene.
+     * quello step non ha girato (§5.14, punto 4). `undefined` quando va tutto bene.
      */
     stepOutputInConditions(step: FlowStageStep): string | undefined;
     /** Lo step tiene un output senza destinazione: e' lecito, ma vale la pena dirlo. */
     hasSimulatedOutputs(step: FlowStageStep): boolean;
     addStep(): void;
     removeStep(index: number): void;
-    /** Sposta lo step nell'ordine d'**esame**: non e' un ordine di esecuzione (§5.13). */
+    /** Sposta lo step nell'ordine d'**esame**: non e' un ordine di esecuzione (§5.14). */
     moveStep(index: number, direction: -1 | 1): void;
     private patchStep;
     setStepLabel(index: number, label: string): void;
@@ -4240,7 +4462,7 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
     setEntryActionName(index: number, actionName: string): void;
     setExitActionName(index: number, actionName: string): void;
     onParametersChanged(index: number, mutate: (holder: ParameterHolder) => void): void;
-    /** Il ramo del rifiuto e' disegnato: senza, un rifiuto fa fallire l'interview (§5.13). */
+    /** Il ramo del rifiuto e' disegnato: senza, un rifiuto fa fallire l'interview (§5.14). */
     readonly hasRejectionBranch: _angular_core.Signal<boolean>;
     /** C'e' almeno uno step il cui rifiuto e' un esito previsto. */
     readonly hasApprovalStep: _angular_core.Signal<boolean>;
@@ -4252,6 +4474,20 @@ declare class OrchestratedStageInspectorComponent extends NodeInspectorBase {
 interface DropTarget {
     parent: FlowScreenFieldPath;
     index: number;
+    /**
+     * Dove disegnare la barra di inserimento, in coordinate del frame dell'anteprima. La calcola
+     * {@link DynamicScreenInspectorComponent.hitTest} perche' e' lì che si conoscono i rettangoli
+     * dei fratelli, e la barra e' un **velo**: non sta nel flusso (vedi `dropMarker`). Assente per
+     * il bersaglio dei comandi a clic, che non nasce da un puntatore e non disegna niente.
+     */
+    marker?: DropMarker;
+}
+/** La barra di inserimento, in pixel relativi al frame dell'anteprima. */
+interface DropMarker {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
 }
 declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     private readonly catalog;
@@ -4281,12 +4517,27 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     setPaletteTab(tab: 'components' | 'fields'): void;
     setFieldsObject(object: string | undefined): void;
     /** Componenti e form sono la stessa domanda al frontend, e lo stesso catalogo (§5.2). */
+    /** I soli **componenti**: `GET /catalog/forms?kind=Component` (§5.2, §6.4). */
     private readonly components;
+    /**
+     * Le schermate intere, che qui non vanno. Serve a dire la cosa giusta su un nome che esiste:
+     * `FORM_KIND_MISMATCH` e non `SCREEN_COMPONENT_UNKNOWN` (§5.2).
+     */
+    private readonly forms;
     private readonly componentParameters;
     /** I tipi di enumerazione: dizionario chiuso, quindi `<select>` e non combo (§4.6). */
     private readonly enumTypes;
     constructor();
+    /** Scarta la risposta di un tipo che non e' piu' quello scelto: la corsa e' fra risposte, non fra tipi. */
+    private applyActions;
+    /** Stessa regola per i parametri, che dipendono da tipo **e** nome dell'action. */
+    private applyActionParameters;
     readonly componentOptions: _angular_core.Signal<NamePickerOption[]>;
+    /**
+     * Le schermate che **non** sono anche componenti: una voce senza `formKind` vale `Any` e
+     * compare in entrambe le risposte, quindi qui non va accusata (§6.4).
+     */
+    readonly unusableComponents: _angular_core.Signal<NamePickerOption[]>;
     readonly enumOptions: _angular_core.Signal<FlowCatalogEntry[]>;
     readonly componentParameterList: _angular_core.Signal<FlowCatalogParameter[]>;
     /**
@@ -4326,8 +4577,22 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     /** Il punto di inserimento corrente, disegnato come una barra fra i campi. */
     readonly dropTarget: _angular_core.WritableSignal<DropTarget | null>;
     isDragging(path: FlowScreenFieldPath): boolean;
-    /** `true` se la barra di inserimento va disegnata qui. */
-    isDropAt(parent: FlowScreenFieldPath, index: number): boolean;
+    /**
+     * La barra di inserimento, disegnata **sopra** l'anteprima e non dentro il contenitore.
+     *
+     * Un tempo era un figlio del contenitore di rilascio, e in una griglia a 12 tracce questo la
+     * rendeva ingovernabile: una barra orizzontale prende `1 / -1`, cioe' una **riga intera piu' il
+     * gap**, e spinge in basso tutto cio' che la segue — compresa la sezione che si stava puntando,
+     * che si sposta di sotto il puntatore. Il gesto successivo rimisurava allora una geometria che
+     * la barra stessa aveva cambiato, il bersaglio cambiava, la barra spariva, la sezione risaliva:
+     * un'oscillazione a ogni movimento, e nessun modo di rilasciare dentro la sezione. Fuori dal
+     * flusso la barra non muove niente, e `hitTest` misura sempre la stessa anteprima.
+     *
+     * Il secondo difetto che questo risolve: fra due colonne che riempivano tutte e 12 le tracce la
+     * barra verticale finiva mandata a capo su una riga di altezza zero, cioe' **invisibile** —
+     * proprio dove serviva di piu'.
+     */
+    readonly dropMarker: _angular_core.Signal<DropMarker | null>;
     onFieldDragStarted(path: FlowScreenFieldPath): void;
     onFieldDragMoved(event: CdkDragMove): void;
     onFieldDragEnded(event: CdkDragEnd, path: FlowScreenFieldPath): void;
@@ -4352,8 +4617,32 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
      *
      * L'indice viene dal confronto con la mezzeria dei fratelli, sull'asse del contenitore: le
      * colonne di una sezione stanno in riga, tutto il resto in colonna.
+     *
+     * La misura e' **sempre** su un'anteprima senza barra di inserimento: la barra e' un velo
+     * assoluto (vedi `dropMarker`), quindi non c'e' il ciclo per cui disegnarla spostava cio' che
+     * si stava puntando.
      */
     private hitTest;
+    /** Barra verticale a sinistra di un campo, alta quanto lui. */
+    private barBefore;
+    /** Barra verticale a destra di un campo. */
+    private barAfter;
+    /** Barra orizzontale sopra un campo, larga quanto le tracce del contenitore. */
+    private barAbove;
+    /** Barra orizzontale sotto un campo. */
+    private barBelow;
+    /** Barra orizzontale in mezzo a un contenitore vuoto, dov'e' il segnaposto. */
+    private barInside;
+    /** La banda occupata dalle tracce della griglia: il rettangolo del contenitore meno il padding. */
+    private contentBand;
+    /** `true` se il campo occupa tutte le tracce, cioe' se la sua riga e' sua e basta. */
+    private fillsRow;
+    /**
+     * Da coordinate del viewport a coordinate del frame dell'anteprima, che e' il contenitore
+     * posizionato in cui vive il velo. Senza la conversione la barra sarebbe fuori posto appena la
+     * dialog e' scorsa.
+     */
+    private toFrame;
     /** `"0.2"` → `[0, 2]`; la radice e' la stringa vuota. */
     private static parsePath;
     /** Il valore dell'attributo che marca un contenitore di rilascio. */
@@ -4460,6 +4749,88 @@ declare class DynamicScreenInspectorComponent extends NodeInspectorBase {
     /** `ObjectProvided`: oggetto e campo si scrivono in un unico `<Oggetto>.<Campo>` (§5.2). */
     setProvidedObject(value: string | undefined): void;
     setProvidedField(value: string | undefined): void;
+    readonly screenActions: _angular_core.Signal<FlowScreenAction[]>;
+    readonly screenTriggers: _angular_core.Signal<FlowScreenTrigger[]>;
+    /** Quale action e' aperta nel dettaglio; `null` = solo l'elenco. */
+    private readonly actionSelection;
+    readonly selectedActionIndex: _angular_core.Signal<number | null>;
+    readonly selectedAction: _angular_core.Signal<FlowScreenAction | undefined>;
+    private readonly actionTypes;
+    private readonly actionsOfType;
+    private readonly actionParameters;
+    readonly actionTypeOptions: _angular_core.Signal<NamePickerOption[]>;
+    readonly actionOptions: _angular_core.Signal<NamePickerOption[]>;
+    readonly actionParameterCatalog: _angular_core.Signal<FlowCatalogParameter[]>;
+    selectAction(index: number | null): void;
+    /**
+     * Le destinazioni **in piu'** per gli output di una screen action: i campi di **questa**
+     * schermata. È l'unico posto in cui un campo di screen e' scrivibile (§5.2) —
+     * `POST /flows/references/writable` continua a escluderlo, e giustamente: un Assignment che ci
+     * scrive resta `TARGET_NOT_WRITABLE`. Quindi l'allargamento e' qui, non nel picker.
+     */
+    readonly screenFieldTargets: _angular_core.Signal<FlowReference[]>;
+    /** I campi che raccolgono un valore: gli unici che un'action possa riempire, e gli unici che innescano. */
+    private valueFieldsOfScreen;
+    /**
+     * I campi proponibili come innesco. Sono **i campi di questa schermata**, non i riferimenti in
+     * generale: un trigger che nomina altro e' `SCREEN_TRIGGER_FIELD_UNKNOWN` (§5.2).
+     */
+    readonly triggerFieldOptions: _angular_core.Signal<NamePickerOption[]>;
+    /** Le action **di questo screen**: un `screenActionName` fuori da qui e' `SCREEN_ACTION_UNKNOWN`. */
+    readonly screenActionOptions: _angular_core.Signal<NamePickerOption[]>;
+    /**
+     * §5.2 — un'action senza `outputParameters` e senza `storeOutputAutomatically` viene invocata e
+     * il suo risultato si perde: `SCREEN_ACTION_WITHOUT_OUTPUTS`, avviso.
+     */
+    actionLosesResult(action: FlowScreenAction): boolean;
+    /** §5.2 — nessuno la invoca: l'action e' scritta ma nessun trigger la cita. */
+    actionHasNoTrigger(action: FlowScreenAction): boolean;
+    /** §5.2 — senza campo e senza `initBehavior` il trigger non scattera' mai: `SCREEN_TRIGGER_WITHOUT_CAUSE`. */
+    triggerHasNoCause(trigger: FlowScreenTrigger): boolean;
+    /**
+     * §5.2 — l'unico valore ammesso e' `runOnLoad`. Il `runOnRevisit` della specifica Salesforce e'
+     * `SCREEN_TRIGGER_INIT_BEHAVIOR_UNKNOWN`, e vale la pena dirlo qui: chi arriva da quella
+     * specifica lo scrive per abitudine.
+     */
+    triggerInitIsUnknown(trigger: FlowScreenTrigger): boolean;
+    /**
+     * §3.3 — il nome dell'action, con lo **stesso** controllo del nome di uno step: la regexp e le
+     * occorrenze in `usedNames`, che le action le comprende già. Una sola occorrenza e' questa action,
+     * due sono un omonimo — e qui l'omonimia non e' formale, perche' con l'output automatico quel nome
+     * e' la radice di `Cerca.nome`.
+     */
+    actionNameError(action: FlowScreenAction): string | null;
+    /** Il blocco condizioni di un trigger: mai `undefined`, altrimenti l'editor non si apre. */
+    triggerConditions(trigger: FlowScreenTrigger): FlowConditionHolder;
+    /**
+     * Un'action nuova. Il nome sta nello spazio dei nomi **comune** (§3.3): con l'output automatico la
+     * si legge come `<NomeAction>.<NomeOutput>`, e un omonimo di una variabile — o di una `Structure`
+     * chiamata come lei — renderebbe ambiguo quel riferimento. `usedNames` le comprende già, quindi qui
+     * non c'e' niente da aggiungere all'elenco.
+     */
+    addScreenAction(): void;
+    removeScreenAction(index: number): void;
+    private patchAction;
+    /**
+     * Rinominare un'action riscrive i trigger che la citano: sono l'unico posto che la nomina, e
+     * lasciarli indietro trasformerebbe una rinomina in `SCREEN_ACTION_UNKNOWN`.
+     */
+    setActionName(index: number, value: string): void;
+    /** Cambiare tipo cambia l'insieme delle action e dei loro parametri: com'e' su un elemento Action. */
+    setActionType(index: number, value: string): void;
+    setActionTarget(index: number, value: string): void;
+    setActionStoreOutput(index: number, value: boolean): void;
+    onActionParametersChanged(index: number, mutate: (holder: ParameterHolder) => void): void;
+    /** Un trigger nuovo. Se un'action e' aperta, nasce già collegata a quella. */
+    addScreenTrigger(): void;
+    removeScreenTrigger(index: number): void;
+    private patchTrigger;
+    setTriggerProperty(index: number, property: 'screenActionName' | 'triggerFieldName' | 'initBehavior', value: string): void;
+    /**
+     * Le condizioni di un trigger sono una regola come quella di una Decision (§5.2). Assenti,
+     * l'action gira a ogni cambio del campo: un blocco vuoto si omette invece di scriverlo (§2).
+     */
+    onTriggerConditionsChanged(index: number, mutate: (holder: FlowConditionHolder) => void): void;
     setScreenText(property: string, value: string): void;
     /** 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;
@@ -4634,7 +5005,7 @@ declare class DebugPanelComponent {
     readonly status: _angular_core.Signal<string | null>;
     readonly pendingScreen: _angular_core.Signal<_esfaenza_flow_builder.FlowPendingScreen | null>;
     readonly isWaitingForScreen: _angular_core.Signal<boolean>;
-    /** §5.13 — l'attesa e' su uno step assegnato a una persona, non su un evento. */
+    /** §5.14 — l'attesa e' su uno step assegnato a una persona, non su un evento. */
     readonly isWaitingForStageStep: _angular_core.Signal<boolean>;
     readonly stageSteps: _angular_core.Signal<FlowStageStepState[]>;
     /** Lo step su cui c'e' un work item aperto: e' quello che si puo' concludere. */
@@ -4706,6 +5077,8 @@ interface Notice {
 declare class FlowBuilderComponent {
     private readonly api;
     private readonly destroyRef;
+    /** Serve a `afterNextRender` chiamato fuori dal costruttore. */
+    private readonly injector;
     protected readonly store: FlowDocumentStore;
     protected readonly dictionaries: FlowDictionaryStore;
     protected readonly session: FlowEditorSession;
@@ -4824,12 +5197,46 @@ declare class FlowBuilderComponent {
     onElementPicked(pick: FlowPalettePick): void;
     private createElement;
     onRemoveNode(name: string): void;
+    /**
+     * La selezione dell'editor e' il **nome** dell'elemento: dopo una rinomina il nome vecchio
+     * non esiste piu' e va sostituito, altrimenti inspector e dialog restano puntati sul vuoto.
+     */
+    onNodeRenamed(newName: string): void;
     onDuplicateNode(name: string): void;
     /** Riordina il grafo e **scrive** le coordinate nel documento (§3.5). */
     autoLayout(): void;
     undo(): void;
     redo(): void;
     save(): Promise<void>;
+    /** Il modulo del duplicato e' aperto. */
+    readonly isCopyOpen: _angular_core.WritableSignal<boolean>;
+    readonly copyName: _angular_core.WritableSignal<string>;
+    readonly copyLabel: _angular_core.WritableSignal<string>;
+    private readonly copyNameInput;
+    /**
+     * Si duplica un flow che esiste: su uno mai salvato il comando e' «Crea», e il nome lo si
+     * scrive nell'intestazione.
+     */
+    readonly canDuplicate: _angular_core.Signal<boolean>;
+    /**
+     * Il nome della copia non e' verificabile lato client — i nomi dei flow stanno nel catalogo
+     * del backend, ed e' lui a rifiutare un doppione con `AlreadyExists` (§6.2). Qui si fermano
+     * le due cose che si sanno senza chiedere: la forma del nome tecnico e l'uguaglianza con
+     * l'originale, che duplicare non e'.
+     */
+    readonly copyNameProblem: _angular_core.Signal<string | null>;
+    /**
+     * Cosa verra' copiato. Con modifiche non salvate la copia le comprende, perche' nasce dal
+     * documento in mano e non dalla versione salvata: dirlo evita la domanda «devo salvare
+     * prima?», che ha risposte opposte nei due casi.
+     */
+    readonly copyHint: _angular_core.Signal<"La copia comprende le modifiche non salvate; l’originale resta come e’ ora." | "La copia nasce come versione 1 di un flow nuovo.">;
+    startCopy(): void;
+    cancelCopy(): void;
+    setCopyName(value: string): void;
+    setCopyLabel(value: string): void;
+    /** Scrive la copia e continua a lavorare su di essa (§6.2). */
+    confirmCopy(): Promise<void>;
     createNewVersion(): Promise<void>;
     activate(): Promise<void>;
     /** §9.3 — prima opzione davanti a un conflitto. */
@@ -4865,5 +5272,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, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, 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_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, 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, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, insertField, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, moveField, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, removeField, resolvePath, samePath, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
-export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, 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, FlowFormula, 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, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowReference, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, FlowSaveRequest, FlowSaveResult, FlowSchedule, FlowScheduledPath, FlowScreen, FlowScreenField, FlowScreenFieldInputsRevisited, FlowScreenFieldNode, FlowScreenFieldPath, FlowScreenFieldType, FlowScreenFieldTypeEntry, FlowScreenNavigation, FlowScreenResponseRequest, 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, StructureMemberUsage, ValueMode };
+export { ConditionEditorComponent, ConnectorEditorComponent, DebugPanelComponent, DynamicScreenInspectorComponent, ElementDialogComponent, ElementInspectorComponent, ElementPaletteComponent, EnumValuePickerComponent, FALLBACK_COLLECTION_BY_TYPE, FALLBACK_TYPE_LABEL, FLOW_BUILDER_HTTP_CONFIG, 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_RESOURCE_COLLECTIONS, FLOW_VALUE_FIELDS, FLOW_VALUE_LITERAL_FIELDS, FieldAssignmentEditorComponent, FieldPickerComponent, FlowApiError, FlowBuilderApi, FlowBuilderComponent, FlowCanvasComponent, FlowCatalogStore, FlowDictionaryStore, FlowDocumentStore, FlowEditorSession, FlowLayoutService, FlowValidationStore, FormulaEditorComponent, FormulaValidationService, HttpFlowBuilderApi, NamePickerComponent, NodeInspectorBase, ORCHESTRATION_CONDITION_OUTPUT, ObjectPickerComponent, OrchestratedStageInspectorComponent, ParameterEditorComponent, ProblemsPanelComponent, RecordFilterEditorComponent, ReferencePickerComponent, ResourcePanelComponent, 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, areTypesComparable, canvasNodeId, checkConditionLogic, checkFlowName, describePathEntry, duplicateField, elementIcon, emptyFlowDefinition, fieldAt, filterReferences, flattenFields, flowNodeWidth, flowNodeWidthClass, insertField, isCustomConditionLogic, isEmptyReferenceFilter, isFieldResource, isGlobalReference, isNumericType, isPathInside, isTypeCheckedOperator, isValidFlowName, isValued, loadPathLevel, matchesReferenceFilter, moveCondition, moveField, navigatePath, outletByKey, outletsOf, parseCanvasNodeId, parseInvariantNumber, parseSourceConnectorId, parseTargetConnectorId, pathAvailableNames, pathContainerLabel, pathKey, pathNotVerifiableMessage, referenceRoot, remapConditionLogic, removeCondition, removeField, resolvePath, samePath, screenActionNames, screenFieldNames, severityBucket, slugifyFlowName, sourceConnectorId, stageStepNames, stageStepOutputReferenced, stepsOf, targetConnectorId, uniqueFlowName, valuedFieldOf, valuedFieldsOf, variantFieldOf, variantOf, variantPresetOf };
+export type { FieldAssignmentHolder, FilterHolder, FlowActionCall, FlowAnyNode, FlowAssignment, FlowAssignmentItem, FlowAssignmentOperator, FlowAssignmentOperatorEntry, FlowBuilderHttpConfig, FlowCanvasEdge, FlowCanvasNode, FlowCatalogEntry, FlowCatalogParameter, FlowChoice, 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, 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, FlowPendingScreen, FlowProcessType, FlowRecordCreate, FlowRecordDelete, FlowRecordFilter, FlowRecordFilterOperator, FlowRecordLookup, FlowRecordRollback, FlowRecordTriggerType, FlowRecordUpdate, FlowRecordValue, FlowReference, FlowReferenceFilter, FlowReferenceKind, FlowRegionContainerType, FlowResourceCollection, FlowResourceKindEntry, FlowResourceRef, FlowResumeRequest, 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, StructureMemberUsage, ValueMode };