@esfaenza/dpe-builder 20.3.12 → 20.3.13

package/index.d.ts

@@ -217,9 +217,18 @@ interface AggregateNode extends DpeNode {
 type TransformKind = 'Expression' | 'Slice' | 'ComputeRelative';
 interface ExpressionField extends DpeExtensible {
     alias: string;
-    /** **SQL nativo del dialetto della definizione** (ADR 0006): passa verbatim. */
+    /**
+     * Una **formula** nel linguaggio del compilatore registrato dall'ospite (ADR 0031): non e'
+     * SQL, e il frontend non ne conosce la grammatica. Forma `Value` sotto `Expression`, forma
+     * `WindowFunction` sotto `ComputeRelative`.
+     */
     expression: string;
-    /** **Autorevole e non verificato** (ADR 0006). */
+    /**
+     * **Dichiarato dall'utente e autorevole** (ADR 0033): lo schema resta una funzione pura della
+     * definizione, quindi il tipo di una colonna calcolata e' questo e non quello inferito dal
+     * compilatore. Il compilatore lo **verifica** — `DPE_EXPR_TYPE_MISMATCH` /
+     * `DPE_EXPR_TYPE_WIDENED` / `DPE_EXPR_TYPE_UNVERIFIED` — ma non lo determina.
+     */
     declaredType: ColumnType;
 }
 interface TransformNode extends DpeNode {
@@ -316,6 +325,16 @@ interface CustomNode extends DpeNode {
 type WritebackTargetKind = 'Database' | 'Json' | 'Csv';
 type WritebackOperation = 'Insert' | 'Update' | 'Upsert' | 'Delete';
 type WritebackFieldRole = 'Value' | 'PrimaryKey' | 'QualifierKey';
+/**
+ * Granularita' del fallimento che l'host deve rispettare applicando un writeback (ADR 0040).
+ *
+ * `PerRecord`: l'host **puo'** applicare le righe indipendentemente e riportare i fallimenti per
+ * riga. `Atomic`: l'host **deve** applicare l'intero writeback in una transazione sola.
+ *
+ * Dichiarata e **non eseguita**: la libreria non apre transazioni e questo valore non cambia di
+ * una virgola l'SQL generato.
+ */
+type WritebackFailureHandling = 'Atomic' | 'PerRecord';
 interface WritebackFieldMapping extends DpeExtensible {
     /** Condiz.: alias a monte; assente quando `runtimeParameterName` e' presente. */
     sourceFieldName?: string;
@@ -361,12 +380,34 @@ interface WritebackNode extends DpeNode {
     operation?: WritebackOperation;
     /** Obbligatorio (>=1) in un nodo valido. */
     fields?: WritebackFieldMapping[];
-    /** Espressione SQL nativa applicata al risultato (ADR 0006). */
+    /**
+     * Predicato applicato al risultato: e' il **terzo sito di authoring di formule** (ADR 0031 §1),
+     * quello che si dimentica, e passa dal compilatore nella forma `Predicate`. Non e' SQL.
+     */
     filterCondition?: string;
     /** Condiz.: richiesto per `operation === 'Upsert'`. */
     externalIdFieldName?: string;
     /** Default `false`. */
     onlyChangedRows?: boolean;
+    /**
+     * `targetFieldName` della colonna con cui l'host raggruppa le righe per la rilavorazione
+     * (ADR 0040). Solo `target === 'Database'`. Dichiarato e non eseguito: la libreria non
+     * raggruppa niente, e senza questo campo l'unico lotto di lavoro possibile e' il writeback
+     * intero.
+     */
+    processingGroupFieldName?: string;
+    /**
+     * Solo `target === 'Database'`, e **assente** vuol dire «non dichiarato», che non e' la stessa
+     * cosa di `PerRecord`: il valore efficace lo calcola il backend e arriva su
+     * `DpeWritebackStep.failureHandling`.
+     *
+     * L'opzionalita' non e' comodita': e' cio' che permette a un salva-dopo-carica di rispedire il
+     * documento **identico** (**I7**). Se l'editor scrivesse un default qui, una definizione che non
+     * dichiara niente tornerebbe al backend dichiarando `PerRecord`, e su un membro di gruppo
+     * atomico quella riga in piu' diventerebbe `DPE_MODEL_CONDITIONAL_FORBIDDEN` su un campo che
+     * nessuno ha toccato.
+     */
+    failureHandling?: WritebackFailureHandling;
     /** Solo `target === 'Json'`. */
     jsonOptions?: JsonArtifactOptions;
     /** Solo `target === 'Csv'`. */
@@ -415,7 +456,14 @@ type DpeAnyNode = DpeNodeCollectionMap[DpeNodeCollectionName];
 /**
  * L'elenco dei nomi di collezione in forma di valore, nell'ordine in cui i nodi si leggono
  * (sorgenti -> trasformazioni -> sink). `keyof` non produce un array a runtime: questo
- * elenco e' l'unico posto in cui vive l'ordine.
+ * elenco e' l'unico posto in cui vive l'ordine. Lo leggono il cammino del documento
+ * (`dpe-graph.ts`) e la palette, attraverso `DPE_NODE_CATEGORIES` che ne deriva.
+ *
+ * **Totale e senza ripetizioni, e a dirlo e' il compilatore.** Un array non si verifica contro
+ * un'unione: una collezione aggiunta a `DpeNodeCollectionMap` e dimenticata qui compilerebbe, e
+ * sparirebbe in silenzio dal cammino del documento (archi che non compaiono, rinomine
+ * incomplete) e dalla palette. Il controllo `COLLECTION_ORDER_IS_TOTAL` trasforma l'omissione, e
+ * la ripetizione, in un errore di build che nomina il membro.
  */
 declare const DPE_NODE_COLLECTIONS: readonly DpeNodeCollectionName[];
 
@@ -474,6 +522,18 @@ interface Diagnostic {
  * duplicazione del dominio: e' la sola distinzione che cambia **come si rende** un rilievo.
  */
 declare const DPE_NODE_NOT_COMPILABLE = "DPE_NODE_NOT_COMPILABLE";
+/**
+ * Il codice che il contratto (`contracts.md` §5 e §7) prescrive di mostrare **in testa** quando il
+ * catalogo delle formule non e' stato prodotto: nomina la sorgente il cui schema non si risolve,
+ * mentre le diagnostiche strutturali che lo accompagnano ne dicono la causa.
+ *
+ * Seconda e ultima costante di codice dichiarata dalla libreria, per lo stesso criterio della
+ * prima: non e' un elenco di dominio duplicato, e' l'unica cosa che cambia **come si rende** un
+ * sacco di rilievi. Senza di essa la riga che l'architetto ha aggiunto apposta — «una riga da
+ * mostrare in testa» — finirebbe in mezzo alle altre, che e' il rumore indistinguibile che il
+ * codice esiste per evitare.
+ */
+declare const DPE_CATALOG_UNAVAILABLE = "DPE_CATALOG_UNAVAILABLE";
 /** Rappresentazione testuale del percorso, nella forma usata dai messaggi del backend. */
 declare function diagnosticPathToString(path: DiagnosticPath | undefined): string;
 
@@ -498,6 +558,172 @@ declare function diagnosticPathToString(path: DiagnosticPath | undefined): strin
 interface DpeEnvironment {
     /** Il dialetto del database di destinazione. Dichiarato, mai scelto dall'utente dell'editor. */
     readonly dialect: SqlDialectKind;
+    /**
+     * Nome del linguaggio in cui si scrivono le espressioni, dal compilatore di formule registrato
+     * dall'ospite (ADR 0031/0036).
+     *
+     * Serve **all'etichetta del campo**, e per questo sta qui e non nel catalogo: il catalogo puo'
+     * legittimamente non arrivare — il compilatore non descrive il proprio linguaggio
+     * (`ProvidesCatalog == false`), oppure il dialetto della definizione non e' fra quelli che
+     * copre e allora il catalogo e' nullo — mentre il nome del linguaggio si sa sempre. Un editor
+     * che leggesse il nome dal catalogo resterebbe muto proprio nei casi in cui l'utente ha piu'
+     * bisogno di sapere in che lingua sta scrivendo.
+     *
+     * Assente = l'editor non nomina nessun linguaggio. Non nomina il **dialetto** al suo posto: il
+     * dialetto non c'entra piu' con cio' che si scrive in quel campo (ADR 0031).
+     */
+    readonly expressionLanguage?: string;
+    /**
+     * Il compilatore descrive il proprio linguaggio. Falso o assente: **non chiamare**
+     * `getFormulaCatalog`.
+     *
+     * Si interroga **prima** di chiamare, per la stessa ragione per cui la disponibilita' di un
+     * comando si sa prima del clic (`contracts.md` §7): una chiamata che si sa inutile costa al
+     * backend una passata completa di grafo e di metadati per restituire un catalogo vuoto.
+     */
+    readonly providesFormulaCatalog?: boolean;
+    /**
+     * Le **forme** che il compilatore registrato sa produrre (`Capabilities.SupportedForms`, ADR
+     * 0031). Incrociata con `DpeNodeSchemaInfo.requiredForm` — che e' per **nodo** e arriva con la
+     * validazione — permette di **disabilitare** un campo formula che non potra' mai essere
+     * compilato.
+     *
+     * Le due meta' stanno in due posti perche' hanno due sorgenti e due vite: la forma richiesta
+     * viene dalla **definizione**, le forme supportate dal **compilatore registrato**, cioe'
+     * dall'installazione, come `expressionLanguage` e `providesFormulaCatalog` qui accanto.
+     * L'editor le incrocia e non deduce nessuna delle due.
+     *
+     * **Assente (o `null`) significa: non si disabilita niente.** Non e' un ripiego prudente, e' la
+     * politica: non sapere quali forme il compilatore copra non autorizza a indovinare, e un campo
+     * spento per ignoranza e' peggio di un campo acceso che il backend rifiutera' dicendo perche'.
+     * Un elenco **vuoto** e' un'altra cosa — e' una dichiarazione, e dice «nessuna forma».
+     *
+     * Opzionale **e** nullabile per la regola dei tipi di rispecchiamento: descrivono cio' che
+     * arriva **sul filo**, e l'ospite di riferimento ignora i nulli come politica globale, quindi la
+     * proprieta' puo' non comparire affatto.
+     */
+    readonly supportedForms?: readonly DpeExpressionForm[] | null;
+}
+/**
+ * La **forma** che i siti di espressione di un nodo pretendono (ADR 0031 §1).
+ *
+ * Attraversa il confine su `DpeNodeSchemaInfo.requiredForm` per una ragione sola: dedurla dal tipo
+ * di nodo — «una trasformazione `Expression` vuole un valore, il filtro di un writeback vuole un
+ * predicato» — sarebbe una **regola di dominio in TypeScript**, che e' vietata. La sa il backend, e
+ * la dice.
+ *
+ * Il tipo sta in questa sezione e non accanto agli schemi perche' e' la **stessa** enumerazione che
+ * `DpeEnvironment.supportedForms` dichiara: sono i due operandi dell'incrocio, e un'enumerazione
+ * dichiarata due volte diverge.
+ */
+type DpeExpressionForm = 'Value' | 'Predicate' | 'WindowFunction';
+/**
+ * L'**involucro** di `getFormulaCatalog`, rispecchiamento di `DpeFormulaCatalogResult`
+ * (`contracts.md` §7, normativo). La rotta consegna questo, non il catalogo nudo.
+ *
+ * Il motivo e' misurato, non di principio: il service distingue **tre** esiti e il filo ne
+ * consegnava **due** — o un catalogo o un errore di trasporto — quindi *dialetto non coperto* e
+ * *backend rotto* arrivavano all'editor identici, e il degrado era silenzioso.
+ *
+ * **Il discriminante e' `diagnostics`, non `catalog`:** diagnostiche non vuote significa
+ * fallimento, e si mostrano; altrimenti un catalogo c'e', e la tavolozza si mostra se ha
+ * contenuto. In particolare un compilatore che non descrive il proprio linguaggio consegna il
+ * catalogo **presente e vuoto**, con `languageName` valorizzato e zero diagnostiche: chi ramasse
+ * su `catalog == null` non entrerebbe **mai** in quel caso.
+ *
+ * La derivazione dei tre esiti sta in `dpeFormulaCatalogOutcome`, una funzione pura, e non in un
+ * `if` dentro un componente.
+ */
+interface DpeFormulaCatalogResult {
+    /**
+     * Il catalogo. **Assente o `null` significa una cosa sola: non e' stato prodotto** — non
+     * «prodotto vuoto», che e' un esito diverso e si riconosce dagli elenchi vuoti.
+     *
+     * Opzionale **e** nullabile insieme, e non e' pignoleria: un tipo di rispecchiamento descrive
+     * cio' che arriva **sul filo**, non cio' che il record C# dichiara, e ospiti diversi
+     * serializzano diversamente. L'ospite di riferimento ignora i nulli come politica globale,
+     * quindi la proprieta' non compare affatto e arriva `undefined` mentre un tipo con il solo
+     * `| null` prometterebbe altro. `check:modelli` confronta i **nomi** dei campi e questa classe
+     * di divergenza non la vede.
+     */
+    readonly catalog?: DpeFormulaCatalog | null;
+    /**
+     * Le diagnostiche del service. Mai nulla; **vuota** quando il compilatore semplicemente non
+     * descrive il proprio linguaggio, che non e' un errore.
+     *
+     * `DPE_CATALOG_UNAVAILABLE` e' la riga da mostrare **in testa**: nomina la sorgente il cui
+     * schema non si risolve, e le strutturali che la seguono ne dicono la causa. Non si filtrano
+     * per pertinenza — l'errore che spiega lo schema puo' stare a piu' salti di distanza — quindi
+     * diventano dettaglio espandibile invece di rumore indistinguibile.
+     */
+    readonly diagnostics: readonly Diagnostic[];
+    readonly hasErrors: boolean;
+}
+/**
+ * Rispecchiamento sul filo di `Jace.DPE.Expressions.DpeFormulaCatalog`: cosa il linguaggio di
+ * formule dell'ospite mette a disposizione **nel punto** in cui si sta scrivendo.
+ *
+ * **Non e' una regola di dominio e non ne diventa una** (`contracts.md` §7). L'editor lo usa per
+ * *mostrare* cosa esiste; non lo usa per validare cio' che l'utente scrive. La grammatica e' del
+ * compilatore, il frontend non la conosce, e nessuna validazione di formula viene scritta in
+ * TypeScript — per nessun motivo, nemmeno «solo per il caso banale»: una regola duplicata diverge,
+ * e quando diverge l'editor mente all'utente.
+ *
+ * Un catalogo **vuoto e' legittimo** (ADR 0036 §5) e non e' un errore: significa che il
+ * compilatore non descrive il proprio linguaggio, e l'editor mostra un campo di testo semplice.
+ */
+interface DpeFormulaCatalog {
+    /**
+     * Nome del linguaggio secondo il compilatore. **Non** e' la fonte dell'etichetta del campo:
+     * quella e' `DpeEnvironment.expressionLanguage`, che arriva anche quando il catalogo non arriva.
+     */
+    readonly languageName: string;
+    readonly functions: readonly DpeFormulaFunction[];
+    readonly operators: readonly DpeFormulaOperator[];
+    readonly symbols: readonly DpeFormulaSymbol[];
+}
+interface DpeFormulaFunction {
+    /** Gruppo con cui l'elenco raggruppa la voce. */
+    readonly group: string;
+    readonly name: string;
+    readonly description?: string;
+    /**
+     * Assente quando il tipo di ritorno **dipende dagli argomenti** e un elenco statico non puo'
+     * dichiararlo (ADR 0036 §4). Assente significa «non si sa qui», non `String`.
+     */
+    readonly returnType?: ColumnType;
+    readonly parameters: readonly DpeFormulaFunctionParameter[];
+}
+interface DpeFormulaFunctionParameter {
+    readonly name: string;
+    readonly description?: string;
+    readonly type?: ColumnType;
+    readonly isOptional?: boolean;
+    /**
+     * Il parametro appartiene a un gruppo che **si ripete** (funzione variadica). Un solo campo al
+     * posto della coppia gruppo/ordine del sistema di origine: il matching delle firme e' lavoro del
+     * compilatore, a un elenco per l'utente serve sapere che il gruppo si ripete.
+     */
+    readonly isRepeating?: boolean;
+}
+interface DpeFormulaOperator {
+    readonly group: string;
+    readonly symbol: string;
+    readonly description?: string;
+}
+/**
+ * Provenienza di un simbolo. Le tre sono strutturalmente diverse e l'elenco le raggruppa: una
+ * colonna a monte, un parametro di runtime della definizione e una costante del linguaggio non si
+ * correggono nello stesso modo quando il nome e' sbagliato.
+ */
+type DpeFormulaSymbolKind = 'Column' | 'Parameter' | 'Constant';
+interface DpeFormulaSymbol {
+    readonly name: string;
+    readonly description?: string;
+    /** `null`/assente quando il compilatore non sa mapparlo sui sei tipi logici: una mancanza
+     * dichiarata e' meglio di una bugia. */
+    readonly type?: ColumnType;
+    readonly kind: DpeFormulaSymbolKind;
 }
 /**
  * Riga di catalogo: identita' e fatti che l'ospite conosce **senza** caricare la definizione.
@@ -586,14 +812,66 @@ interface DpeColumnInfo {
      */
     isNullable: boolean;
 }
+/**
+ * **Cio' che la libreria ha derivato su un nodo**: schema di uscita, compilabilita' e forma pretesa
+ * dai suoi siti di espressione. Arriva con **ogni** validazione, e da ADR 0041 con **una voce per
+ * ogni nodo della definizione, sempre** — anche per i nodi che il grafo non ha potuto ordinare.
+ *
+ * La presenza di una voce dice «questo nodo esiste, ed ecco cio' che la libreria ha potuto derivare
+ * su di esso»; **non** dice «il suo schema e' noto». Quello lo dice `hasSchema`, e solo quello.
+ */
 interface DpeNodeSchemaInfo {
     nodeName: string;
-    columns?: DpeColumnInfo[];
+    /**
+     * Colonne di uscita. **Vuota non significa "nessuna colonna"** finche' non si e' letto
+     * `hasSchema`: e' vuota anche quando lo schema e' ignoto. Contarle senza guardare `hasSchema`
+     * afferma un fatto che il backend non ha affermato — ed e' il difetto misurato sul canvas prima
+     * dell'ADR 0041.
+     *
+     * **Obbligatoria**, come nel contratto (`contracts.md` §5): in C# e' `IReadOnlyList` mai nulla e
+     * arriva come `[]` quando e' vuota, quindi un ospite che omette la collezione vuota e' fuori
+     * contratto e non un caso da assecondare nel tipo. Dichiararla opzionale costringeva a un `?? []`
+     * a ogni lettura, e quel `?? []` e' **indistinguibile fra «vuota» e «non arrivata»** — cioe' la
+     * stessa ambiguita' che l'ADR 0041 ha tolto da `Columns`, riaperta un livello piu' in basso e in
+     * TypeScript. La regola generale (`contracts.md` §7): cio' che puo' mancare si dichiara opzionale
+     * **e** nullabile insieme, e una collezione non e' fra quelle cose.
+     */
+    columns: DpeColumnInfo[];
+    /**
+     * Il discriminante fra «schema derivato» e «schema ignoto» (ADR 0041).
+     *
+     * - `true` = `columns` e' un **fatto**. Vuota vuol dire davvero zero colonne — stato
+     *   raggiungibile, e gia' diagnosticato con `DPE_SCHEMA_EMPTY`.
+     * - `false` = schema **ignoto**: la derivazione non e' arrivata a una risposta (fallita qui o a
+     *   monte, oppure nodo dentro un ciclo). `columns` e' vuota e **non significa niente**.
+     *
+     * **Assente = `false`.** Un ospite che serializza omettendo i falsi non manda affatto la
+     * proprieta', e qui l'omissione coincide con la risposta prudente: e' il motivo per cui il campo
+     * si chiama `hasSchema` e non `isSchemaUnknown`. Chi legge confronta quindi con `=== true`, mai
+     * per veridicita', e non lo deduce da `columns.length` — dedurlo sarebbe rimettere in TypeScript
+     * la regola che questo campo esiste per portare.
+     */
+    hasSchema?: boolean;
     /**
      * `false` = nodo **valido ma non compilabile** (**I10**): e' un limite nostro, non un
      * errore dell'utente, e va reso diverso da un nodo invalido.
      */
     isCompilable: boolean;
+    /**
+     * La forma pretesa dai siti di espressione di questo nodo, oppure assente/`null` se il nodo non
+     * ne ha — che e' uno stato normale, non una mancanza.
+     *
+     * Sta qui e non sul risultato del catalogo perche' e' una cosa che la **libreria deriva** dal
+     * tipo del nodo (ADR 0031 §1), non una cosa che il **compilatore offre**: l'editor la riceve
+     * sempre, anche quando il catalogo non lo chiede affatto. Dedurla lato editor sarebbe una regola
+     * di dominio in TypeScript, che e' vietata; incrociarla con `DpeEnvironment.supportedForms`
+     * permette invece di **disabilitare** un campo che il compilatore registrato non compilera' mai.
+     *
+     * Opzionale **e** nullabile: un tipo di rispecchiamento descrive cio' che arriva **sul filo**, e
+     * l'ospite di riferimento omette i nulli come politica globale — quindi la proprieta' puo' non
+     * comparire affatto.
+     */
+    requiredForm?: DpeExpressionForm | null;
 }
 interface DpeWritebackStep {
     writebackName: string;
@@ -610,6 +888,23 @@ interface DpeWritebackStep {
     externalIdFieldName?: string;
     /** Presente se il writeback appartiene a un gruppo atomico. */
     atomicGroupName?: string;
+    /**
+     * Il valore **efficace** per `target === 'Database'` (ADR 0040): membro di un gruppo atomico ->
+     * `Atomic`, altrimenti il valore dichiarato sul nodo, altrimenti `PerRecord`.
+     *
+     * **Assente per `Json`/`Csv`**, e segue la regola comune a tutti i campi dello `Step` che
+     * istruiscono chi scrive — `operation`, `tableName`, `externalIdFieldName`,
+     * `processingGroupFieldName`, `tenantColumnName`: sono assenti quando l'ospite non scrive.
+     * L'assenza dice una cosa precisa, «questo non lo scrivi tu», e dirla e' meglio di un
+     * `PerRecord` che su un artefatto sarebbe pure falso: un file si scrive per intero o per niente.
+     *
+     * Non e' il campo del nodo con un altro nome. `WritebackNode.failureHandling` e' cio' che
+     * l'autore ha scritto, questo e' cio' che l'host deve fare: ricavarlo qui incrociando
+     * `atomicGroupName` con il valore dichiarato e con il default vorrebbe dire reimplementare tre
+     * regole di dominio nell'editor, che e' esattamente cio' che l'editor non fa. Se il dato serve,
+     * arriva di qui.
+     */
+    failureHandling?: WritebackFailureHandling;
     /**
      * Dichiarato, **non implementato dalla libreria**: il change tracking e' dell'host
      * (ADR 0011) e non influenza l'SQL generato. Va mostrato come una dichiarazione che l'host
@@ -673,12 +968,66 @@ interface DpeCompiledWriteback {
     /** Vedi {@link DpeFieldMappingInfo}: forma provvisoria. */
     targetMapping?: DpeFieldMappingInfo[];
 }
+/**
+ * Il formato dell'artefatto prodotto. Due soli valori: `Database` non e' un artefatto e qui e'
+ * impossibile per costruzione — per questo il piano non riusa `WritebackTargetKind`.
+ */
+type ArtifactKind = 'Json' | 'Csv';
+/**
+ * Una colonna dell'artefatto, con i **due nomi** che l'ADR 0015 tiene distinti: `resultName`
+ * lega la colonna del result set, `headerName` e' l'unico che viene scritto nel file.
+ * Mostrarli come uno solo nasconderebbe proprio la divergenza che quell'ADR ha chiuso.
+ */
+interface DpeArtifactColumn {
+    /** Alias SQL: serve a legare la colonna del result set. */
+    resultName: string;
+    /** Nome authored: e' quello che finisce nel file (ADR 0015). */
+    headerName: string;
+    type: LogicalType;
+}
+/**
+ * Il payload auto-sufficiente con cui l'ospite puo' **schedulare** la scrittura di un artefatto
+ * (ADR 0029): lo accoda, lo rilegge dopo un riavvio e lo riporta a `WriteArtifact`.
+ *
+ * L'editor non lo esegue e non lo materializza — `DpeBuilderApi` non acquista nessuna primitiva
+ * per questo — ma lo riceve dentro `DpeCompileResult.fileWritebacks`, e l'anteprima ne mostra
+ * l'SQL di lettura.
+ *
+ * `tenant` del record C# **non** e' qui, e non per dimenticanza: l'ambito tenant non attraversa
+ * il confine verso l'editor, per la stessa ragione per cui `getTable` reda la colonna di tenant
+ * (ADR 0027). Un backend che lo serializzi comunque non e' un errore: il client lo ignora.
+ */
+interface DpeArtifactPlan {
+    /**
+     * Timbro del formato del payload. Il piano puo' tornare indietro **vecchio** da una coda, e un
+     * valore ignoto viene rifiutato dal backend invece che tollerato.
+     */
+    formatVersion: number;
+    definitionName: string;
+    /** E' anche il nome passato al sink dell'ospite: il piano non porta un `artifactName` distinto. */
+    writebackName: string;
+    sequence: number;
+    kind: ArtifactKind;
+    /** Lo legge l'ospite per scegliere la connessione, non la libreria. */
+    dialect: SqlDialectKind;
+    /** SQL di **lettura**: nessun artefatto e' stato prodotto. */
+    statement: SqlStatement;
+    columns?: DpeArtifactColumn[];
+    /** Presenti solo per il `kind` corrispondente. */
+    jsonOptions?: JsonArtifactOptions;
+    csvOptions?: CsvArtifactOptions;
+}
 interface DpeCompileResult {
     hasErrors: boolean;
     diagnostics?: Diagnostic[];
     databaseWritebacks?: DpeCompiledWriteback[];
-    /** SQL di lettura, non ancora eseguito. */
-    fileWritebacks?: DpeCompiledWriteback[];
+    /**
+     * ADR 0029: **piani di artefatto**, non writeback compilati. Portano gia' kind, opzioni e
+     * intestazioni authored, cioe' tutto cio' che serve a scrivere il file; il `step` non c'e'
+     * perche' per un file sarebbe fatto di soli campi nulli. L'SQL di lettura non e' ancora stato
+     * eseguito.
+     */
+    fileWritebacks?: DpeArtifactPlan[];
     writebackSequence?: DpeWritebackStep[];
 }
 
@@ -699,14 +1048,14 @@ interface DpeCompileResult {
  * l'editor la considera disponibile e mostra il comando attivo.
  *
  * **Dichiarazione sottrattiva (ADR 0020).** Da quando la libreria spedisce un client HTTP che
- * implementa tutte e dieci le primitive, l'identita' da sola non basta: chi eredita quel client
+ * implementa tutte le primitive, l'identita' da sola non basta: chi eredita quel client
  * non puo' dis-sovrascrivere un metodo. Disponibile diventa quindi «**sovrascritta** e **non
  * elencata** in `unsupportedPrimitives`». La seconda meta' e' solo sottrattiva — non rende
  * disponibile cio' che non e' implementato — e resta calcolata in questo file e in nessun altro.
  */
 
 /** Le primitive che un ambiente ospite puo' legittimamente non offrire. */
-type DpeOptionalPrimitive = 'compilePreview' | 'load' | 'save' | 'getEnvironment' | 'listDefinitions' | 'createDefinition' | 'deleteDefinition';
+type DpeOptionalPrimitive = 'compilePreview' | 'load' | 'save' | 'getEnvironment' | 'getFormulaCatalog' | 'listDefinitions' | 'createDefinition' | 'deleteDefinition';
 declare function dpeIsPrimitiveAvailable(api: DpeBuilderApi, primitive: DpeOptionalPrimitive): boolean;
 /** L'insieme delle primitive disponibili: comodo per fotografarlo una volta alla costruzione. */
 interface DpeCapabilities {
@@ -714,6 +1063,15 @@ interface DpeCapabilities {
     readonly load: boolean;
     readonly save: boolean;
     readonly getEnvironment: boolean;
+    /**
+     * Il catalogo del linguaggio di formule (ADR 0036). **Condizione necessaria e non sufficiente**
+     * per chiederlo: l'altra meta' e' `DpeEnvironment.providesFormulaCatalog`, che e' un fatto del
+     * compilatore e non del trasporto. Le due stanno separate perche' sono due cose diverse — «il
+     * backend non serve questa rotta» e «il compilatore non descrive il proprio linguaggio» — e
+     * mescolarle renderebbe impossibile distinguere un ambiente incompleto da un compilatore
+     * laconico.
+     */
+    readonly getFormulaCatalog: boolean;
     readonly listDefinitions: boolean;
     readonly createDefinition: boolean;
     readonly deleteDefinition: boolean;
@@ -733,9 +1091,10 @@ interface DpeCommandAvailability {
  * (`contracts.md` §7, normativo): `createDefinition` per scrivere, e `getEnvironment` perche' il
  * dialetto della definizione nuova viene dall'ambiente (ADR 0017).
  *
- * Perche' senza `getEnvironment` si disabilita invece di ripiegare su un dialetto qualsiasi: una
- * definizione creata per il dialetto sbagliato porta espressioni SQL native (ADR 0006) da
- * riscrivere tutte, e chiederlo all'utente e' proprio la scelta che l'ADR 0017 ha tolto. Un
+ * Perche' senza `getEnvironment` si disabilita invece di ripiegare su un dialetto qualsiasi: il
+ * dialetto decide con quali capacita' la definizione verra' compilata, e quali costrutti il
+ * compilatore di formule copre (ADR 0031 §5: un dialetto fuori da `SupportedDialects` non compila
+ * **nessuna** espressione), e chiederlo all'utente e' proprio la scelta che l'ADR 0017 ha tolto. Un
  * comando disabilitato che dice perche' e' meglio di entrambe; il rimedio per l'ospite e' una
  * riga, implementare `getEnvironment`.
  *
@@ -799,6 +1158,14 @@ declare abstract class DpeBuilderApi {
      *
      * Prende la definizione **in lavorazione**, non quella salvata: cio' che l'editor mostra
      * deve riferirsi a cio' che l'utente sta scrivendo. Va invocata con debounce.
+     *
+     * **`schemas` porta anche `requiredForm`**, la forma che i siti di espressione di quel nodo
+     * pretendono. Sta li' e non sul risultato del catalogo delle formule perche' e' cio' che la
+     * libreria **deriva** sul nodo, come le colonne e la compilabilita', mentre il catalogo e' cio'
+     * che il compilatore **offre** e arriva solo quando il compilatore risponde: un ospite che
+     * dichiara `providesFormulaCatalog` falso non fa chiamare quella rotta, e la forma non arrivava
+     * mai. Chi implementa questo metodo la valorizza: senza, un campo formula non dice cosa vuole e
+     * non si blocca quando il compilatore non sa produrre quella forma.
      */
     abstract validate(definition: DpeDefinition): Observable<DpeValidateResult>;
     /**
@@ -830,7 +1197,7 @@ declare abstract class DpeBuilderApi {
      * definizione che gli viene passata dall'ospite.
      *
      * La deserializzazione (`IDpeService.Deserialize`) resta del backend: qui arriva un
-     * documento già letto, con le sue eventuali diagnostiche già emesse.
+     * documento gia' letto, con le sue eventuali diagnostiche gia' emesse.
      */
     load(name: string): Observable<DpeDefinition>;
     /** Salvataggio. Opzionale: un editor in sola lettura e' un uso legittimo. */
@@ -843,13 +1210,46 @@ declare abstract class DpeBuilderApi {
      * Cosa l'editor fa con la risposta, e cosa non fa: mostra il dialetto in sola lettura e, se
      * differisce da quello della definizione (ADR 0009: e' li' che vive, ed e' da li' che il
      * backend lo legge), **lo segnala senza correggere**. Riscrivere `definition.dialect` sarebbe
-     * una migrazione silenziosa di tutte le espressioni SQL native (ADR 0006), per giunta eseguita
+     * una migrazione silenziosa delle capacita' con cui la definizione verra' compilata, per giunta eseguita
      * all'apertura e capace di marcare come «modificata» una definizione che nessuno ha toccato.
      *
      * Opzionale come le altre: dove manca, l'editor mostra il dialetto della definizione e non
      * dice nient'altro.
      */
     getEnvironment(): Observable<DpeEnvironment>;
+    /**
+     * `IDpeService.GetFormulaCatalog` — cosa il linguaggio di formule mette a disposizione **nel
+     * nodo indicato** (ADR 0031/0036). Opzionale: senza, l'editor mostra un campo di testo semplice,
+     * che e' esattamente cio' che mostrava prima che il catalogo esistesse.
+     *
+     * **Prende la definizione e il nome del nodo, non uno schema.** Il catalogo dipende dallo schema
+     * a monte — i simboli `Column` sono le colonne che quel nodo vede — e risolvere uno schema e' del
+     * backend (**I4**): il frontend non sa farlo e non deve imparare. La definizione e' quella **in
+     * lavorazione**, perche' quella aperta nell'editor puo' non essere ancora salvata.
+     *
+     * **Non e' una chiamata leggera** (`frontend.md` §5-quater, normativo): lato libreria costa una
+     * passata completa di grafo e di propagazione, e interroga il provider di metadati per tutti i
+     * datasource della definizione. Chi la consuma la chiede **una volta per nodo** e la conserva —
+     * `DpeFormulaCatalogStore` lo fa — e non a ogni apertura di un campo, che e' il modo naturale di
+     * scriverlo e quello sbagliato.
+     *
+     * Si interroga `DpeEnvironment.providesFormulaCatalog` **prima** di chiamare: un compilatore che
+     * non descrive il proprio linguaggio risponde un catalogo vuoto, e farsi pagare quella passata di
+     * grafo per riceverlo e' spreco puro (ADR 0036 §5).
+     *
+     * **Restituisce l'involucro, non il catalogo nudo** (`contracts.md` §7). Il service distingue
+     * tre esiti e il filo ne consegnava due, quindi un dialetto non coperto e un backend rotto
+     * arrivavano qui identici: la differenza fra «non lo so» e «non si puo'» si perdeva prima di
+     * raggiungere lo schermo. Chi implementa questo metodo non trasforma un esito con diagnostiche
+     * in un errore di trasporto: le diagnostiche **sono** la risposta.
+     *
+     * **`requiredForm` non e' piu' in questa risposta**: sta su `DpeNodeSchemaInfo.requiredForm`,
+     * cioe' negli schemi di `validate`. La ragione e' proprio la riga qui sopra — questa risposta
+     * arriva solo quando il compilatore parla, e la forma la libreria la sa senza chiedere niente a
+     * nessuno. Chi implementa questo metodo non la rimette qui: due copie dello stesso fatto
+     * divergono (ADR 0018).
+     */
+    getFormulaCatalog(definition: DpeDefinition, nodeName: string): Observable<DpeFormulaCatalogResult>;
     /**
      * Elenco delle definizioni disponibili — **catalogo** (ADR 0019). Opzionale: dove manca, un
      * catalogo montato dall'ospite mostra il perche' invece di un elenco vuoto.
@@ -891,7 +1291,7 @@ declare abstract class DpeBuilderApi {
  *
  * L'editor si comporta in base alla **categoria**, mai leggendo il messaggio: chi implementa
  * {@link DpeBuilderApi} traduce l'errore di trasporto (status HTTP, payload, timeout) in un
- * `DpeApiError`, e da lì in poi nella libreria non esiste piu' nessuna nozione di HTTP
+ * `DpeApiError`, e da li' in poi nella libreria non esiste piu' nessuna nozione di HTTP
  * (ADR 0007).
  */
 /**
@@ -960,7 +1360,8 @@ declare const DPE_API_ERROR_FALLBACK_MESSAGE: Record<DpeApiErrorCategory, string
  * nessuna cache, nessun debounce, nessuna intestazione propria. Traduce trasporto ed errori e
  * nient'altro — la cache vive negli store, il debounce nel chiamante, i tentativi e
  * l'autenticazione negli interceptor dell'ospite. E non tocca `definition.dialect` in nessun
- * metodo (ADR 0009 e 0017): sarebbe una migrazione silenziosa delle espressioni SQL native.
+ * metodo (ADR 0009 e 0017): sarebbe una migrazione silenziosa delle capacita' con cui il backend
+ * compilera' la definizione.
  */
 
 /**
@@ -973,7 +1374,7 @@ interface DpeBuilderHttpConfig {
     /**
      * Primitive opzionali che questo ambiente **non serve** (`contracts.md` §7, dichiarazione
      * sottrattiva). E' l'unico modo che ha l'ospite di spegnere una primitiva che questo client
-     * implementa per forza: conoscendo tutti e dieci gli endpoint, li dichiarerebbe altrimenti tutti
+     * implementa per forza: conoscendo tutti e undici gli endpoint, li dichiarerebbe altrimenti tutti
      * disponibili, e un comando attivo su un endpoint non servito fallisce alla pressione.
      */
     unsupported?: readonly DpeOptionalPrimitive[];
@@ -990,7 +1391,7 @@ declare class HttpDpeBuilderApi extends DpeBuilderApi {
      */
     readonly unsupportedPrimitives: readonly DpeOptionalPrimitive[];
     /**
-     * Composizione dell'URL. Sovrascriverlo basta a spostare tutte e dieci le rotte sotto un altro
+     * Composizione dell'URL. Sovrascriverlo basta a spostare tutte e undici le rotte sotto un altro
      * prefisso senza toccare un metodo.
      *
      * `?? ''` e non un default: `baseUrl: ''` e' una configurazione **valida** e significa «rotte
@@ -1053,6 +1454,13 @@ declare class HttpDpeBuilderApi extends DpeBuilderApi {
     protected httpPost<T>(path: string, body: unknown): Observable<T>;
     protected httpPut<T>(path: string, body: unknown): Observable<T>;
     protected httpDelete<T>(path: string): Observable<T>;
+    /**
+     * La rotta della validazione. Dal trasloco di `requiredForm` i suoi `schemas` portano **tre**
+     * fatti per nodo e non due — colonne, compilabilita' e forma richiesta dai siti di espressione —
+     * e un ospite che serva questa rotta a mano deve valorizzare anche il terzo: e' l'unica strada
+     * per cui la forma arriva all'editor, e senza di essa un campo formula non dice cosa vuole ne'
+     * si blocca quando il compilatore non sa produrla.
+     */
     validate(definition: DpeDefinition): Observable<DpeValidateResult>;
     getTables(): Observable<TableSummary[]>;
     getTable(tableName: string): Observable<TableLookupResult>;
@@ -1113,6 +1521,36 @@ declare class HttpDpeBuilderApi extends DpeBuilderApi {
      * senza correggere se differisce da quello della definizione.
      */
     getEnvironment(): Observable<DpeEnvironment>;
+    /**
+     * L'**undicesima rotta** (ADR 0036): `POST {base}/formula-catalog/{nodeName}`, corpo il documento
+     * nudo. Le altre dieci non cambiano.
+     *
+     * Perche' un `POST` e non un `GET`: il catalogo dipende dallo **schema a monte** del nodo, che il
+     * backend sa risolvere solo avendo la definizione, e la definizione aperta nell'editor puo' non
+     * essere ancora salvata. Un `GET` con il solo nome del nodo risponderebbe sul documento
+     * archiviato, cioe' su un altro documento.
+     *
+     * Perche' il nome del nodo sta nel **percorso** e non nel corpo: un involucro
+     * `{ definition, nodeName }` e' esattamente l'errore silenzioso del contratto — un backend che
+     * deserializza una `DpeDefinition` da `{definition: …}` non riconosce nessuna proprieta',
+     * risponde `200`, e l'editor riceve il catalogo di una definizione vuota. Meglio una rotta che
+     * non puo' sbagliare che un secondo corpo con involucro.
+     *
+     * **La risposta e' `DpeFormulaCatalogResult`, non `DpeFormulaCatalog`** (`contracts.md` §7-bis).
+     * E' l'unica correzione di questa rotta: consegnava il catalogo nudo, quindi i tre esiti del
+     * service ne diventavano due e un dialetto non coperto si presentava come un guasto di rete. Il
+     * client non interpreta niente di cio' che riceve — la tricotomia si legge in
+     * `dpeFormulaCatalogOutcome`, dove e' pura e verificabile.
+     *
+     * **Rottura dichiarata del contratto di rotta:** la risposta non porta piu' `requiredForm`. La
+     * forma richiesta dai siti di espressione di un nodo sta ora su `DpeNodeSchemaInfo.requiredForm`,
+     * cioe' negli schemi di `POST {base}/validate`. Un ospite che la serializzi ancora qui non rompe
+     * niente — il client passa il corpo intero e nessuno la legge — ma resta l'unica copia di un
+     * fatto che l'editor prende da un'altra parte. Il motivo del trasloco e' che questa rotta
+     * l'editor non la chiama affatto quando `DpeEnvironment.providesFormulaCatalog` e' falso: la
+     * forma non arrivava mai, proprio dagli ospiti piu' laconici.
+     */
+    getFormulaCatalog(definition: DpeDefinition, nodeName: string): Observable<DpeFormulaCatalogResult>;
     /** Nessun parametro di interrogazione: il filtro del catalogo e' locale, di proposito. */
     listDefinitions(): Observable<DpeDefinitionSummary[]>;
     /**
@@ -1198,9 +1636,10 @@ declare class DpeCatalogStore {
      * contratto, e non deve esistere — si comporrebbe di queste due comunque, e una primitiva
      * dedicata dovrebbe ridecidere lato host cosa cambia.
      *
-     * Il dialetto e' quello della **definizione di partenza**, non quello dell'ambiente: le
-     * espressioni sono SQL nativo (ADR 0006) e cambiare dialetto duplicando sarebbe una migrazione
-     * silenziosa.
+     * Il dialetto e' quello della **definizione di partenza**, non quello dell'ambiente: cambiarlo
+     * duplicando sarebbe una migrazione silenziosa: il dialetto decide le capacita' con cui si
+     * compila, e se il compilatore di formule non lo copre la copia non compila nessuna espressione
+     * (ADR 0031 §5).
      */
     duplicate(sourceName: string, name: string, label: string): Observable<DpeDefinitionSummary>;
     /** Cancella per nome e ricarica l'elenco. La conferma e' della schermata, non dello store. */
@@ -1220,6 +1659,215 @@ declare class DpeCatalogStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeCatalogStore>;
 }
 
+/**
+ * Le condizioni dei campi condizionali, **in un punto solo**.
+ *
+ * Un campo condizionale e' un campo del modello che ha significato solo quando un altro campo del
+ * **suo stesso nodo** — il discriminante — vale una certa cosa: `jsonOptions` solo con
+ * `target === 'Json'`, `expressionFields` solo con `kind` diverso da `Slice`, e cosi' via. Le
+ * condizioni sono usate dall'ispettore in due direzioni opposte:
+ *
+ * 1. **resa** (`frontend.md` §5-ter, normativa): il controllo si rende quando la condizione vale
+ *    **oppure** quando il campo porta un valore. Un valore fuori condizione che nessun controllo
+ *    mostra non e' cancellabile dall'editor, e per **I7** sopravvive a ogni salvataggio;
+ * 2. **ripulitura**: cambiare il discriminante e' un gesto deliberato con cui l'autore dichiara
+ *    inapplicabili i campi che il valore nuovo non governa, e quei campi escono dal documento.
+ *
+ * Fino a LS9 le stesse condizioni erano scritte **due volte in ogni ispettore**, una per direzione,
+ * a pochi metodi di distanza. E' la duplicazione piu' facile da introdurre e la piu' difficile da
+ * vedere, perche' i sintomi di una divergenza sono silenziosi e nessun test li coglie:
+ *
+ * - un campo **ripulito che resta mostrato** — la ripulitura lo toglie, la resa lo rimette, e
+ *   l'utente vede un controllo che non corrisponde a niente nel documento;
+ * - §5-ter che **smette di coprire un campo** — la resa lo nasconde mentre il documento lo porta,
+ *   cioe' il difetto che quella regola esiste per chiudere, tornato in silenzio.
+ *
+ * Con la tabella qui sotto le due direzioni leggono **la stessa riga**: `dpeFieldVisibility()`
+ * costruisce un segnale per ogni voce, `dpePruneInapplicable()` scorre le voci una per una.
+ * Aggiungere un campo condizionale domani significa scrivere **una** riga; scriverla per la resa e
+ * dimenticarla per la ripulitura non e' possibile, perche' e' la stessa riga.
+ *
+ * ## Cio' che questo file NON chiude, e va detto
+ *
+ * **La fonte autorevole di queste condizioni e' il backend**, e resta ricopiata a mano:
+ * `dpe/dpe/Validation/ModelRules.cs` e `dpe/dpe/Validation/WritebackRules.cs`. Qui resta una
+ * **regola di dominio in TypeScript**, cioe' una deroga dichiarata a un vincolo del progetto
+ * (`frontend.md` §5-ter, «duplicazione dichiarata e temporanea»). `npm run check:modelli` **non**
+ * la copre: confronta le forme dei tipi, non le condizioni.
+ *
+ * Quindi: chi tocca una condizione di la' deve toccarla anche di qua, e i due sintomi silenziosi
+ * elencati sopra valgono identici per una divergenza dal backend — con l'aggravante che li' non
+ * c'e' nemmeno il compilatore. La direzione che chiude la classe invece di sorvegliarla (la
+ * tabella come **dato** pubblicato dal contratto, letta da `ModelRules`) e' la questione aperta 32.
+ *
+ * ## Cosa non sta in tabella, e perche'
+ *
+ * Solo i campi **del nodo**: la ripulitura toglie chiavi dal nodo, quindi una voce deve essere una
+ * chiave del nodo. Una condizione che governa un campo **dentro una riga di una collezione** (il
+ * tipo dichiarato di un campo di sorgente) non e' rappresentabile qui e resta scritta nel suo
+ * ispettore, dove la meta' «porta un valore» e' un `some(...)` sulle righe.
+ */
+
+/** La condizione di applicabilita' di un campo, valutata sul nodo intero. */
+type DpeFieldCondition<TNode> = (node: TNode) => boolean;
+/**
+ * La tabella di un tipo di nodo: **chiave del nodo → condizione**.
+ *
+ * Le chiavi sono limitate a `keyof TNode` cosi' un campo rinominato nel modello non lascia qui una
+ * riga orfana che nessuno consuma, e la ripulitura non puo' togliere una chiave inventata.
+ */
+type DpeConditionalFields<TNode> = {
+    readonly [K in keyof TNode]?: DpeFieldCondition<TNode>;
+};
+/** Un segnale di visibilita' per ogni voce della tabella, con lo stesso nome del campo. */
+type DpeFieldVisibility<TConditions> = {
+    readonly [K in keyof TConditions]: Signal<boolean>;
+};
+/**
+ * «Il campo porta un valore», nel senso di `frontend.md` §5-ter.
+ *
+ * Nessuna delle equivalenze qui sotto e' un giudizio sul valore — dire che e' sbagliato tocca al
+ * backend, e la regola di resa vale **diagnostica o no**:
+ *
+ * - **stringa vuota = assente**, perche' il backend confronta con `string.IsNullOrEmpty`: un
+ *   `processingGroupFieldName: ''` arrivato da fuori non deve far comparire un campo vuoto, che
+ *   sarebbe il rumore che la regola promette di non introdurre;
+ * - **`false` = assente**, perche' i campi governati sono `bool` **non nullable** con default
+ *   `false` lato C# (`OnlyChangedRows`, `AllowsMultipleLookupValues`): dopo la deserializzazione
+ *   `false` e' indistinguibile dall'assenza;
+ * - **collezione vuota = assente**: un `criteria: []` non dichiara niente, e il backend lo conta
+ *   con `Count(...) == 0`.
+ *
+ * Un oggetto invece **e' sempre** una dichiarazione, anche `{}`: per il backend un `jsonOptions`
+ * non nullo fuori dal proprio target e' `DPE_MODEL_CONDITIONAL_FORBIDDEN` qualunque cosa contenga.
+ */
+declare function dpeDeclares(value: unknown): boolean;
+/**
+ * I segnali di resa di §5-ter: **la condizione vale oppure il campo porta un valore**.
+ *
+ * Si costruiscono dalla tabella intera e non uno per uno, cosi' il segnale di un campo nuovo esiste
+ * per il solo fatto che la sua riga esiste. Nel template il tipo fa il resto: `shows.jsonOptions()`
+ * su una voce che non c'e' non compila, quindi non si puo' nascondere un campo per distrazione.
+ */
+declare function dpeFieldVisibility<TNode extends object, TConditions extends DpeConditionalFields<TNode>>(node: Signal<TNode>, conditions: TConditions): DpeFieldVisibility<TConditions>;
+/**
+ * La modifica di un discriminante, **piu'** la rimozione dei campi che con il valore nuovo non si
+ * applicano piu'.
+ *
+ * La condizione si valuta sul nodo **come sara' dopo il gesto** (`{ ...node, ...change }`), non su
+ * quello di adesso: e' il solo modo di trattare un discriminante che ne cambia un altro nello
+ * stesso gesto — su un writeback la destinazione decide l'operazione, e l'operazione decide il
+ * campo di identificazione esterna.
+ *
+ * E si ripete **finche' non si stabilizza**, perche' una rimozione puo' invalidare la condizione
+ * di un altro campo: portando una scrittura `Upsert` da `Database` a `Json`, il primo giro toglie
+ * `operation` e solo il secondo si accorge che `externalIdFieldName` non e' piu' governato da
+ * niente. Con un giro solo quel valore restava nel documento su un artefatto, dove il backend
+ * **non lo diagnostica**: ignorato e invisibile, il caso peggiore. Trovato **eseguendo** la demo,
+ * non leggendo il codice — la versione a un giro passava tutti i test che c'erano, e il test che
+ * la coglie e' stato scritto dopo averla vista fallire a schermo.
+ *
+ * Il punto fisso esiste sempre: ogni giro puo' solo **aggiungere** rimozioni, i campi sono finiti
+ * e un campo tolto non torna. Una condizione scritta al contrario (vera **perche'** l'altro campo
+ * e' assente) renderebbe il risultato dipendente dall'ordine: in tabella non ce ne sono, e questo
+ * e' il motivo per cui non ce ne devono essere.
+ *
+ * **Si toglie cio' che non si applica, non cio' che apparteneva al valore precedente**, e la
+ * differenza non e' teorica: `Expression` → `ComputeRelative` non tocca `expressionFields`, perche'
+ * quel campo e' governato da entrambi. Un «cambiando tipo si azzera» sarebbe piu' semplice da
+ * scrivere e cancellerebbe espressioni SQL su un passaggio che non le rende inapplicabili.
+ *
+ * Togliere e' **rimuovere la chiave** (`undefined`), non scriverci `false` o `[]`: le due forme
+ * sono equivalenti per il validatore e diverse per il documento, e il documento e' cio' che si
+ * salva (**I7**).
+ *
+ * Si rimuove **solo cio' che c'e'**: un campo gia' assente non entra nel patch. Sul documento
+ * salvato non cambia niente — una chiave a `undefined` sparisce serializzando — ma il patch
+ * diventa il resoconto esatto del gesto, e «questo cambio non tocca niente» diventa una cosa
+ * osservabile invece di una cosa da credere.
+ *
+ * Non e' distruttivo perche' il patch passa da `DpeDocumentStore.updateNode` → `commit`, che mette
+ * l'istantanea precedente nella cronologia: «Annulla» rimette tutto. Verificato a schermo in
+ * LS7-quater, non dedotto — era il solo fatto che avrebbe potuto togliere la ragione a questo
+ * comportamento.
+ */
+declare function dpePruneInapplicable<TNode extends object, TConditions extends DpeConditionalFields<TNode>>(node: TNode, change: Partial<TNode>, conditions: TConditions): Partial<TNode>;
+/**
+ * Sorgente: il tipo decide da dove si legge (`ModelRules.cs`, `ApplyDataSources`).
+ *
+ * Nessuno dei tre e' diagnosticato **fuori** condizione — il backend li richiede dove servono e
+ * ignora il resto — e non cambia niente: §5-ter guarda il documento, non l'elenco dei codici.
+ */
+declare const DPE_DATA_SOURCE_CONDITIONS: {
+    tableName: (node: DataSourceNode) => boolean;
+    csvOptions: (node: DataSourceNode) => boolean;
+    externalDatasetName: (node: DataSourceNode) => boolean;
+};
+/**
+ * Filtro: `isDynamic` sceglie quale meta' del nodo vale (`ModelRules.cs`, `ApplyFilters`).
+ *
+ * Il parametro serve al filtro dinamico; criteri e condizione a quello statico.
+ */
+declare const DPE_FILTER_CONDITIONS: {
+    criteria: (node: FilterNode) => boolean;
+    condition: (node: FilterNode) => boolean;
+    filterParameterName: (node: FilterNode) => boolean;
+};
+/**
+ * Giunzione: la molteplicita' ammessa ha significato solo su una `Lookup`
+ * (`JoinRules.cs`, `DialectRules.cs`).
+ */
+declare const DPE_JOIN_CONDITIONS: {
+    allowsMultipleLookupValues: (node: JoinNode) => boolean;
+};
+/** Percorso gerarchico: le aggregazioni servono quando sono dichiarate richieste. */
+declare const DPE_HIERARCHY_PATH_CONDITIONS: {
+    aggregateFields: (node: HierarchyPathNode) => boolean;
+};
+/**
+ * Trasformazione: `kind` governa i quattro campi (`ModelRules.cs`, `ApplyTransforms`).
+ *
+ * `expressionFields` e' governato da **due** tipi, ed e' il motivo per cui la ripulitura non puo'
+ * essere un azzeramento.
+ */
+declare const DPE_TRANSFORM_CONDITIONS: {
+    expressionFields: (node: TransformNode) => boolean;
+    droppedFields: (node: TransformNode) => boolean;
+    partitionBy: (node: TransformNode) => boolean;
+    orderBy: (node: TransformNode) => boolean;
+};
+/**
+ * Scrittura: `target` governa sei campi, **`operation` ne governa un settimo**
+ * (`ModelRules.cs`, `ApplyWritebacks`; `WritebackRules.cs`, `CheckArtifactOptions`,
+ * `CheckProcessingGroupField`, `CheckFailureHandling`).
+ *
+ * `tableName` e `onlyChangedRows` sono in tabella pur **non** essendo diagnosticati fuori da
+ * `Database`: nessuna regola li vieta, quindi il valore non e' «invalido», e' **ignorato e
+ * invisibile** — che e' peggio, perche' niente lo segnala e un cambio di destinazione lo puo'
+ * rendere attivo di colpo. Far dipendere questa tabella dall'elenco dei codici diagnostici
+ * accoppierebbe l'ispettore a un'altra regola di dominio ancora.
+ *
+ * `externalIdFieldName` dipende da `operation`, **non** da `target`: e' la condizione che il
+ * backend applica (`Operation == Upsert`, richiesto li' e vietato altrove) ed e' la sola scritta
+ * qui. Fino a LS9 la ripulitura ne usava una seconda, piu' larga (`Target == Database`): era
+ * proprio la divergenza interna che questo file esiste per rendere impossibile.
+ *
+ * `failureHandling` e' vietato dal backend anche dentro un gruppo atomico, e qui non si dice: la
+ * condizione di resa piu' larga fa comparire il controllo — con il rilievo sotto — invece di
+ * nascondere un valore che l'autore dovrebbe poter togliere. Restringerla farebbe sparire il
+ * controllo proprio dove serve.
+ */
+declare const DPE_WRITEBACK_CONDITIONS: {
+    tableName: (node: WritebackNode) => boolean;
+    operation: (node: WritebackNode) => boolean;
+    externalIdFieldName: (node: WritebackNode) => boolean;
+    onlyChangedRows: (node: WritebackNode) => boolean;
+    processingGroupFieldName: (node: WritebackNode) => boolean;
+    failureHandling: (node: WritebackNode) => boolean;
+    jsonOptions: (node: WritebackNode) => boolean;
+    csvOptions: (node: WritebackNode) => boolean;
+};
+
 /**
  * Il grafo della definizione: **un solo posto** costruisce gli id di nodi, porte e archi, e
  * **un solo elenco** descrive dove vivono i riferimenti fra nodi.
@@ -1228,7 +1876,7 @@ declare class DpeCatalogStore {
  * derivazione degli archi dall'altro) fa sparire un arco **senza nessun errore**: e' il
  * difetto piu' difficile da trovare in un editor a canvas. Allo stesso modo, un riferimento
  * dimenticato nell'elenco degli slot fa restare incoerente il documento dopo una rinomina,
- * anche lì in silenzio.
+ * anche li' in silenzio.
  *
  * Cosa **non** sta qui: nessuna regola di dominio. Questo file dice *dove* stanno i nomi dei
  * nodi a monte, non se un riferimento e' valido, se il grafo ha cicli (**I2**), se un nodo e'
@@ -1285,7 +1933,16 @@ interface DpeSourceSlot<TNode> {
     read(node: TNode): readonly (string | undefined)[];
     write(node: TNode, names: readonly (string | undefined)[]): TNode;
 }
-/** Gli slot di ogni collezione. Aggiungere un nodo significa aggiungere una riga qui. */
+/**
+ * Gli slot di ogni collezione. Aggiungere un nodo significa aggiungere una riga qui.
+ *
+ * **Che ci sia una riga per ogni collezione lo garantisce il compilatore**, non un test: il tipo
+ * e' mappato sull'unione `DpeNodeCollectionName`, quindi una collezione aggiunta al modello e
+ * dimenticata qui ferma la build («Property '...' is missing»), e `DPE_NODE_COLLECTIONS`, con cui
+ * il documento si cammina, e' a sua volta controllato totale. Il test che lo verificava a runtime
+ * non poteva fallire, e per questo e' stato tolto: aggiungeva la convinzione di una copertura, non
+ * la copertura.
+ */
 declare const DPE_SOURCE_SLOTS: {
     readonly [K in DpeNodeCollectionName]: readonly DpeSourceSlot<DpeNodeCollectionMap[K]>[];
 };
@@ -1368,7 +2025,7 @@ declare function dpeWriteSourceReference<K extends DpeNodeCollectionName>(collec
  * avere.
  *
  * Cosa **non** fa, di proposito: non rinomina gli **alias di colonna** (sono un altro spazio
- * di nomi) e non decide se il nuovo nome sia lecito o già usato — l'unicita' e' **I1**, la
+ * di nomi) e non decide se il nuovo nome sia lecito o gia' usato — l'unicita' e' **I1**, la
  * verifica il backend.
  *
  * Il confronto e' **esatto**, non case-insensitive: `domain-model.md` dichiara il confronto
@@ -1402,6 +2059,19 @@ declare function dpeCountReferences(definition: DpeDefinition, nodeName: string)
 declare function dpeDiagnosticNodeName(diagnostic: Diagnostic, definition?: DpeDefinition): string | undefined;
 /** Il campo in causa, per evidenziarlo nell'ispettore. */
 declare function dpeDiagnosticField(diagnostic: Diagnostic): string | undefined;
+/**
+ * La diagnostica riguarda **quella riga** di una collezione dentro il nodo, e quel campo.
+ *
+ * Serve dove un nodo ha piu' righe con lo stesso nome di campo — il caso reale sono le colonne
+ * calcolate di una trasformazione, che hanno tutte un `expression`. Filtrare per solo nome di
+ * campo, come fa `issuesOn`, mostrerebbe l'errore della prima formula sotto la terza: il rilievo
+ * arriva accanto a un testo che non lo ha prodotto, ed e' peggio di non mostrarlo.
+ *
+ * Il confronto e' sul segmento del percorso che nomina la collezione, ovunque stia: `contracts.md`
+ * §1 pubblica il percorso in **due** forme (col nome del nodo dalla validazione, col solo indice
+ * dalla deserializzazione), e in entrambe il segmento della riga porta l'indice.
+ */
+declare function dpeDiagnosticTargetsItem(diagnostic: Diagnostic, collection: string, index: number, field: string): boolean;
 /**
  * `true` per l'unico codice che significa "hai fatto bene, siamo noi" (**I10**, ADR 0005):
  * `Forecast`, `CustomNode`, costrutto non supportato dal dialetto scelto. Non va mescolato
@@ -1695,6 +2365,326 @@ declare class DpeDocumentStore {
     static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeDocumentStore>;
 }
 
+/**
+ * La lettura dei **tre esiti** del catalogo delle formule — `contracts.md` §7, normativo.
+ *
+ * Sta in una funzione pura e non in un `if` dentro un componente per la ragione che ha reso questo
+ * lotto necessario: la versione precedente del contratto consegnava il catalogo **nudo**, quindi i
+ * tre esiti del service ne diventavano due, e *dialetto non coperto* e *backend rotto* arrivavano
+ * a schermo identici. Un degrado silenzioso non si vede rileggendo un componente; si vede
+ * scrivendo una tabella e provandola.
+ *
+ * **Il discriminante e' `diagnostics`, non `catalog`.** E' la riga che vale piu' di tutte le
+ * altre, perche' la stesura precedente diceva il contrario: con `ProvidesCatalog == false` il
+ * catalogo arriva **presente e vuoto**, con il nome del linguaggio e zero diagnostiche — quindi
+ * un editor che ramasse su `catalog == null` non entrerebbe mai in quel caso, e mostrerebbe un
+ * fallimento dove non c'e' niente da segnalare.
+ *
+ * `catalog` nullo o assente significa **una cosa sola: non e' stato prodotto**.
+ */
+
+/**
+ * I quattro stati in cui il campo formula puo' trovarsi rispetto al catalogo — tre del contratto
+ * piu' «non lo so ancora», che e' quello in cui il campo nasce.
+ *
+ * Unione discriminata e non un oggetto con quattro campi opzionali: cosi' «fallito **e** con
+ * tavolozza» non e' rappresentabile, e chi rende non deve decidere quale dei due vince.
+ */
+type DpeFormulaCatalogOutcome = 
+/** Nessuna risposta conservata: non e' stato chiesto, e' in volo, o la richiesta e' fallita. */
+{
+    readonly kind: 'Unknown';
+}
+/** Catalogo consegnato **con contenuto**: si mostra la tavolozza. */
+ | {
+    readonly kind: 'Palette';
+    readonly catalog: DpeFormulaCatalog;
+}
+/**
+ * Catalogo consegnato **vuoto** e nessuna diagnostica: il compilatore non descrive il proprio
+ * linguaggio, che non e' un errore. Niente tavolozza e **nessun rumore**; `languageName` c'e' ed
+ * e' l'unica cosa da mostrare — e l'etichetta del campo la prende comunque dall'ambiente.
+ */
+ | {
+    readonly kind: 'Silent';
+    readonly languageName?: string;
+}
+/**
+ * Diagnostiche non vuote: il catalogo non e' stato prodotto e **il perche' si mostra**.
+ *
+ * `lead` e' la riga in testa, `details` tutto il resto **nell'ordine ricevuto**. La separazione
+ * non e' estetica: il sacco strutturale riguarda l'intera definizione e puo' contenere voci che
+ * con il nodo richiesto non c'entrano, filtrarle per pertinenza non e' affidabile (l'errore che
+ * spiega lo schema puo' stare a piu' salti di distanza), quindi il rimedio dichiarato e' una
+ * riga in testa e il resto come dettaglio.
+ */
+ | {
+    readonly kind: 'Failed';
+    readonly lead: Diagnostic;
+    readonly details: readonly Diagnostic[];
+    readonly hasError: boolean;
+};
+/**
+ * Legge l'involucro e dice in quale dei quattro stati ci si trova.
+ *
+ * L'ordine dei controlli e' il contratto messo in fila, e non e' intercambiabile:
+ *
+ * 1. nessun risultato -> `Unknown`;
+ * 2. **diagnostiche non vuote** -> `Failed`, indipendentemente da `catalog`;
+ * 3. catalogo con contenuto -> `Palette`;
+ * 4. tutto il resto -> `Silent`, cioe' niente tavolozza e nessun rumore.
+ *
+ * Il quarto ramo assorbe anche il caso fuori contratto «nessun catalogo e nessuna diagnostica»:
+ * a schermo e' indistinguibile dal terzo esito — niente da mostrare e niente da segnalare — e
+ * inventare un quinto stato per rimproverare il backend darebbe all'utente un messaggio su cui non
+ * puo' agire.
+ */
+declare function dpeFormulaCatalogOutcome(result: DpeFormulaCatalogResult | undefined): DpeFormulaCatalogOutcome;
+/**
+ * L'etichetta con cui si nomina all'utente la forma pretesa dal campo.
+ *
+ * E' **traduzione**, non deduzione: la forma arriva dal backend, qui si sceglie solo come
+ * chiamarla in italiano. Dedurla dal tipo di nodo sarebbe la regola di dominio che il contratto
+ * vieta, e la differenza fra le due cose e' tutta in questa riga.
+ */
+declare function dpeExpressionFormLabel(form: DpeExpressionForm | null | undefined): string | undefined;
+/**
+ * La stessa cosa detta all'utente: «serve un valore», «serve una funzione di finestra».
+ *
+ * Esiste separata dall'etichetta nuda per una ragione banale e reale: **l'articolo dipende dal
+ * genere**, e comporre «serve un » + etichetta nel template produce «serve un funzione di
+ * finestra». Il template non puo' sapere il genere di una parola, questa funzione si'.
+ */
+declare function dpeExpressionFormPrompt(form: DpeExpressionForm | null | undefined): string | undefined;
+/**
+ * L'incrocio fra **la forma richiesta dal nodo** e **le forme che il compilatore sa compilare**.
+ *
+ * E' la meta' «disabilitare» della funzione che il contratto prescriveva: la meta' «mostrare» —
+ * la pastiglia «serve una funzione di finestra» — era implementabile da LF6, perche' il primo
+ * operando arriva con il catalogo; il secondo non stava sul filo, e senza di esso l'editor poteva
+ * solo dire cosa serve, mai che non si potra' avere.
+ *
+ * Stessa forma di `DpeCommandAvailability` (`dpe-capabilities.ts`) e per la stessa ragione: un
+ * campo spento che non dice perche' manda a cercare un guasto che non c'e'.
+ */
+interface DpeExpressionFormSupport {
+    readonly isSupported: boolean;
+    /** Presente **solo** quando la forma non e' supportata. E' il testo che il campo mostra. */
+    readonly reason?: string;
+}
+/**
+ * Decide se il campo formula si disabilita, e con quale motivo.
+ *
+ * Le tre regole, in quest'ordine e non intercambiabili:
+ *
+ * 1. **forma richiesta assente** -> supportato: il nodo non ospita formule, o la prima validazione
+ *    non e' ancora arrivata. Non c'e' niente da incrociare;
+ * 2. **forme supportate non dichiarate** (`undefined` o `null`) -> supportato. E' la politica del
+ *    contratto: assente significa **non si disabilita niente**. Un ospite che non dichiara le
+ *    capacita' del proprio compilatore non autorizza l'editor a indovinarle, e un campo spento per
+ *    ignoranza toglie all'utente l'unica cosa che avrebbe: provare e leggere la risposta del
+ *    backend;
+ * 3. **dichiarate e la forma non c'e'** -> non supportato. Un elenco **vuoto** entra qui, e ci
+ *    entra di proposito: vuoto non e' assente, e' un compilatore che dichiara di non compilare
+ *    nessuna forma.
+ *
+ * Nessuna di queste e' una regola di dominio: la forma la dice il backend, le capacita' pure.
+ * Questa funzione fa solo l'intersezione e sceglie le parole italiane.
+ */
+declare function dpeExpressionFormSupport(requiredForm: DpeExpressionForm | null | undefined, supportedForms: readonly DpeExpressionForm[] | null | undefined): DpeExpressionFormSupport;
+/** Quante voci porta un catalogo. Zero e' l'esito «il compilatore non si descrive», non un guasto. */
+declare function dpeFormulaCatalogSize(catalog: DpeFormulaCatalog): number;
+
+/**
+ * Il catalogo del linguaggio di formule, **conservato per nodo** — `frontend.md` §5-quater,
+ * normativo.
+ *
+ * `getFormulaCatalog` non e' una chiamata leggera: lato libreria costa una passata completa di
+ * grafo e di propagazione, e interroga il provider di metadati per **tutti** i datasource della
+ * definizione, non solo per il cono a monte del nodo. Chiederlo a ogni apertura di un campo formula
+ * e' il modo naturale di scriverlo e quello sbagliato, e non lascia traccia: non fallisce, si
+ * limita a far pagare al backend N volte una risposta che non e' cambiata.
+ *
+ * Quindi: **una volta per nodo**, conservato, e invalidato quando cambia cio' che puo' cambiarne il
+ * contenuto.
+ *
+ * Cosa questo store **non** fa, e non e' una dimenticanza:
+ *
+ * - **non valida niente.** Il catalogo dice cosa esiste, non se cio' che l'utente ha scritto va
+ *   bene. La grammatica e' del compilatore dell'ospite, il frontend non la conosce e non puo'
+ *   conoscerla: nessuna validazione di formula viene scritta in TypeScript, per nessun motivo
+ *   (ADR 0031/0036, `contracts.md` §7);
+ * - **non decide il nome del linguaggio.** Quello e' `DpeEnvironment.expressionLanguage`, e arriva
+ *   anche quando il catalogo non arriva — che e' il caso piu' importante dei due, perche' un
+ *   dialetto fuori da `SupportedDialects` rende il catalogo nullo (ADR 0031 §5) proprio mentre
+ *   l'utente ha ancora bisogno di sapere in che lingua sta scrivendo;
+ * - **non chiama se non deve.** Servono due cose: la primitiva **sovrascritta e non dichiarata non
+ *   servita** (`dpe-capabilities.ts`) e il compilatore che dichiara di descrivere il proprio
+ *   linguaggio (`providesFormulaCatalog`). Un compilatore laconico risponde un catalogo vuoto, che
+ *   e' legittimo (ADR 0036 §5): farsi pagare una passata di grafo per riceverlo e' spreco puro.
+ *
+ * Provider del **componente radice** come gli altri store: due editor sulla stessa pagina hanno due
+ * documenti, quindi due cache.
+ */
+
+/**
+ * L'impronta di cio' che puo' cambiare una risposta di `getFormulaCatalog`: **il nome del
+ * documento** e **gli schemi che il backend ha propagato**.
+ *
+ * Le due parti corrispondono a cio' che la risposta contiene, e nessuna e' un indovinello: i
+ * simboli `Column` *sono* le colonne che quel nodo vede, e quali siano lo decide la propagazione
+ * dello schema, che e' del backend (**I4**). Qualunque altra impronta — «e' cambiata la topologia»,
+ * «e' cambiato un alias di sorgente» — richiederebbe di sapere *quali* modifiche cambiano uno
+ * schema, cioe' di riscrivere I4 in TypeScript.
+ *
+ * Conseguenza voluta, ed e' la ragione per cui questa funzione e' pura e verificabile: scrivere
+ * nel testo di una formula **non** cambia l'impronta, quindi non invalida nulla. Rinominare un
+ * alias a monte la cambia, e il catalogo si rilegge alla prossima apertura del nodo.
+ *
+ * Il nome del documento entra perche' prima della prima validazione gli schemi sono vuoti: senza
+ * di esso due documenti diversi appena aperti avrebbero la stessa impronta, e il secondo
+ * erediterebbe il catalogo del primo.
+ *
+ * **Qui c'era una terza parte, la forma dei nodi, e non c'e' piu'.** Era entrata quando la risposta
+ * portava `requiredForm`, che dipende dal tipo del nodo mentre lo schema in uscita no: cambiare una
+ * trasformazione da `Expression` a `ComputeRelative` lasciava l'impronta identica e la pastiglia
+ * diceva la forma vecchia. Ora la forma arriva con la validazione e non con questa risposta, e
+ * l'ingresso non esiste piu': misurato sui due lati, il contratto — il compilatore riceve
+ * `DpeExpressionCatalogRequest`, cioe' **dialetto, colonne a monte e parametri**, e non il tipo del
+ * nodo — e il browser, dove lo stesso nodo prima e dopo il cambio di tipo riceve un catalogo
+ * identico (le stesse 32 voci). Toglierla non e' una semplificazione: e' non pagare una richiesta
+ * per una risposta che non puo' essere cambiata.
+ *
+ * **Due ingressi restano scoperti, e sono scoperti da sempre:** il `dialect` e i `parameters` della
+ * definizione, che pure entrano nella richiesta al compilatore. Oggi nessuno dei due si puo'
+ * modificare a documento aperto — l'editor non li scrive, e caricarne un altro azzera gli schemi,
+ * quindi l'impronta si muove lo stesso. Il giorno in cui compare un editor dei parametri, il posto
+ * da cui ripartire e' questo.
+ */
+declare function dpeFormulaCatalogSignature(definitionName: string, schemas: readonly DpeNodeSchemaInfo[]): string;
+declare class DpeFormulaCatalogStore {
+    private readonly api;
+    private readonly document;
+    /**
+     * La dichiarazione dell'ambiente si chiede **una volta all'apertura**, e chi la chiede e'
+     * `DpeValidationService`. Rileggerla da qui sarebbe un secondo `getEnvironment` per la stessa
+     * risposta — e per giunta due risposte che possono arrivare in ordine diverso.
+     */
+    private readonly validation;
+    private readonly capabilities;
+    private readonly _byNode;
+    private readonly _pending;
+    /**
+     * Il nodo di cui si vuole il catalogo — **uno**, quello aperto.
+     *
+     * Esiste per un difetto trovato nel browser e non da nessun test: la disponibilita' dipende da
+     * `getEnvironment`, che e' una chiamata di rete, e chi apre un nodo subito dopo aver aperto
+     * l'editor chiede il catalogo **prima** che l'ambiente abbia risposto. La richiesta cadeva nel
+     * vuoto e non veniva piu' ripetuta, perche' l'apertura del nodo era l'unico innesco: il campo
+     * restava senza catalogo per sempre, senza errori, e riaprire lo stesso nodo non cambiava
+     * niente. Tenere qui **l'intenzione** invece di agire subito la rende ripetibile quando la
+     * condizione che mancava si verifica.
+     */
+    private readonly _wanted;
+    /**
+     * Il catalogo si puo' chiedere: primitiva disponibile **e** compilatore che dichiara di
+     * descrivere il proprio linguaggio. Le due meta' restano separate perche' sono due fatti
+     * diversi — il trasporto e il compilatore — e un solo booleano non permetterebbe di capire
+     * quale dei due manca.
+     */
+    readonly isAvailable: Signal<boolean>;
+    /**
+     * L'impronta corrente: cambia quando cambia cio' che puo' cambiare una risposta, cioe' gli
+     * **schemi** che il backend ha propagato — sono loro a decidere i simboli.
+     *
+     * Legge il documento, e va bene: il valore prodotto e' una stringa, e a parita' di stringa un
+     * `computed` non notifica nessuno. Scrivere in una formula ricalcola l'impronta e non muove
+     * niente — cioe' nessuna richiesta a ogni battitura, che resta la regola di `frontend.md`
+     * §5-quater.
+     */
+    readonly signature: Signal<string>;
+    /**
+     * La prima validazione e' tornata, cioe' **gli schemi si conoscono**.
+     *
+     * Prima di allora il catalogo non si chiede, e non e' prudenza: i simboli `Column` sono le colonne
+     * che il nodo vede, e chiederli quando gli schemi non sono ancora arrivati significa ricevere una
+     * risposta che l'istante dopo e' scaduta — cioe' **due** chiamate per la stessa apertura, dove
+     * ogni chiamata costa al backend una passata completa di grafo e di metadati. Misurato: aprire un
+     * nodo subito dopo l'editor faceva salire il contatore di due.
+     */
+    private readonly hasValidated;
+    /**
+     * L'**involucro** noto per un nodo, se e' stato ottenuto con l'impronta corrente.
+     *
+     * Legge i signal, quindi si usa dentro un `computed` e resta reattivo — lo stesso schema di
+     * `DpeMetadataStore.stateOf`.
+     *
+     * **Scade con l'impronta**: un catalogo ottenuto quando gli schemi erano altri non si restituisce
+     * come se fosse attuale — dichiarerebbe disponibili simboli che non esistono piu'. Finche' il nodo
+     * resta quello aperto, l'effect del costruttore ne chiede subito uno nuovo, quindi la scadenza si
+     * vede al piu' come una sparizione momentanea del conteggio, non come un campo che resta muto.
+     *
+     * Scade anche l'esito d'errore, ed e' giusto: un `DPE_CATALOG_UNAVAILABLE` nasce da uno schema
+     * che non si risolve, e cambiare gli schemi e' esattamente cio' che puo' averlo risolto.
+     */
+    resultOf(nodeName: string): DpeFormulaCatalogResult | undefined;
+    /**
+     * Il catalogo consegnato, **quando e' stato prodotto**. Puo' legittimamente essere vuoto: chi
+     * rende non deve confondere «vuoto» con «assente», e per questo la decisione di cosa mostrare
+     * passa da `outcomeOf` e non da qui.
+     */
+    catalogOf(nodeName: string): DpeFormulaCatalog | undefined;
+    /**
+     * Quale dei tre esiti del contratto si sta guardando — piu' «non lo so ancora».
+     *
+     * E' cio' che i componenti consumano: la tricotomia si legge **una volta**, in una funzione
+     * pura, e non si riscrive in ogni ispettore con un `if` leggermente diverso.
+     */
+    outcomeOf(nodeName: string): DpeFormulaCatalogOutcome;
+    /** Una richiesta per questo nodo e' in volo: lo stato di attesa si mostra sempre. */
+    isLoading(nodeName: string): boolean;
+    constructor();
+    /**
+     * Chiede il catalogo per un nodo, **se serve**. Idempotente: chiamarla a ogni apertura della
+     * finestra non produce chiamate, chiamarla in un ciclo nemmeno.
+     *
+     * Fa **due** cose, e servono entrambe:
+     *
+     * 1. prova subito, sotto `untracked`, cosi' l'esito e' immediato quando le condizioni ci sono
+     *    gia'. Affidarsi al solo `_wanted` non basterebbe: riaperto lo **stesso** nodo il signal non
+     *    cambia valore e l'effect non riparte;
+     * 2. registra l'intenzione in `_wanted`, cosi' quando cambia una delle condizioni che mancavano
+     *    — la disponibilita' dell'ambiente, l'impronta degli schemi — la richiesta viene onorata
+     *    senza che l'utente debba riaprire il nodo.
+     *
+     * **Ogni lettura di signal e' in `untracked`**, e non e' prudenza: i chiamanti sono `effect` degli
+     * ispettori, e un `this.document.definition()` letto qui diventerebbe una dipendenza di
+     * quell'effect — cioe' una richiesta di catalogo **a ogni battitura**, che e' il difetto che
+     * questo store esiste per evitare. Il sintomo non sarebbe un errore: sarebbe un backend che
+     * macina grafi mentre qualcuno scrive.
+     */
+    requestFor(nodeName: string): void;
+    /**
+     * La chiamata, **se serve davvero**: non c'e' gia' una richiesta in volo per quel nodo, e cio'
+     * che e' in cache non e' stato ottenuto con l'impronta corrente.
+     *
+     * Tutte le letture stanno sotto `untracked` da parte dei chiamanti: sono signal, e legarli
+     * all'effect vorrebbe dire rileggere il catalogo a ogni modifica del documento.
+     */
+    private fetchIfNeeded;
+    /**
+     * Rilettura forzata, per chi vuole il catalogo aggiornato senza aspettare un cambio di impronta.
+     * Non ha un consumatore nell'editor di oggi ed esiste perche' una cache senza modo di essere
+     * invalidata a mano e' una cache che prima o poi si aggira con un ricaricamento della pagina.
+     */
+    refresh(nodeName: string): void;
+    private fetch;
+    private put;
+    private setPending;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeFormulaCatalogStore, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<DpeFormulaCatalogStore>;
+}
+
 interface DpeLayoutNodeInput {
     name: string;
     width: number;
@@ -1749,7 +2739,7 @@ declare class DpeMetadataStore {
     readonly isLoadingTables: _angular_core.Signal<boolean>;
     /** Idempotente: la prima chiamata carica, le successive non fanno nulla. */
     loadTables(): void;
-    /** Stato noto di una tabella, se già richiesta. */
+    /** Stato noto di una tabella, se gia' richiesta. */
     stateOf(tableName: string): DpeTableState | undefined;
     /** Chiede la descrizione di una tabella una sola volta per nome. */
     describe(tableName: string): void;
@@ -1793,6 +2783,12 @@ interface DpeNodeCategory {
      */
     isNotCompilableInV1: boolean;
 }
+/**
+ * Le categorie nell'ordine di `DPE_NODE_COLLECTIONS`, che e' l'ordine della palette. **Derivate,
+ * non riscritte**: l'ordine vive in un posto solo — il modello, dove un controllo di tipo lo tiene
+ * totale e senza ripetizioni — e la collezione di ogni categoria e' la stessa variabile con cui se
+ * ne legge la voce, quindi chiave e campo non hanno modo di divergere.
+ */
 declare const DPE_NODE_CATEGORIES: readonly DpeNodeCategory[];
 declare function dpeNodeCategory(collection: DpeNodeCollectionName): DpeNodeCategory;
 /** Nomi dei dialetti per il selettore. La libreria conosce **solo** il nome (ADR 0009). */
@@ -1843,7 +2839,7 @@ declare function dpeNodeIconPaths(collection: DpeNodeCollectionName): readonly s
  * Tutto il resto lo compila l'utente nell'ispettore, e cosa sia obbligatorio lo dice il
  * backend.
  *
- * Il nome candidato e' unico rispetto ai nomi già presenti con confronto **esatto**
+ * Il nome candidato e' unico rispetto ai nomi gia' presenti con confronto **esatto**
  * (`contracts.md` §2: unicita' verificata `OrdinalIgnoreCase`, risoluzione `Ordinal`). Qui il
  * confronto e' insensibile al caso di proposito: proporre `Filtro2` accanto a un `filtro2`
  * esistente creerebbe un `DPE_MODEL_NAME_DUPLICATE` a nome dell'editor, non dell'utente.
@@ -1893,6 +2889,30 @@ declare class DpeValidationService {
      * questo che i due si tengono separati: il confronto e' l'unica cosa che l'editor puo' dire.
      */
     private readonly _environmentDialect;
+    /**
+     * Il nome del **linguaggio di formule** dichiarato dall'ambiente (ADR 0031/0036). Serve
+     * all'etichetta del campo espressione, e arriva da qui e non dal catalogo per una ragione
+     * precisa: il catalogo puo' essere assente o nullo — compilatore che non descrive il proprio
+     * linguaggio, dialetto non coperto — mentre il nome del linguaggio si sa sempre. Letto dal
+     * catalogo, l'editor resterebbe muto proprio nei casi in cui serve.
+     */
+    private readonly _expressionLanguage;
+    /** Il compilatore descrive il proprio linguaggio: se no, `getFormulaCatalog` non si chiama. */
+    private readonly _providesFormulaCatalog;
+    /**
+     * Le forme che il compilatore registrato sa produrre (ADR 0031), dall'ambiente. E' il **secondo
+     * operando** dell'incrocio che disabilita un campo formula incompilabile; il primo,
+     * `requiredForm`, e' per nodo e arriva con la **validazione**, su `DpeNodeSchemaInfo`.
+     *
+     * I due arrivano da due chiamate diverse, ed e' la ragione per cui questo campo sta qui: le forme
+     * supportate sono dell'**installazione** e si chiedono una volta all'apertura, la forma richiesta
+     * e' del **nodo** e si aggiorna a ogni validazione.
+     *
+     * `undefined` non e' «nessuna forma», e' «non dichiarate», e non disabilita niente: la
+     * distinzione e' tutta la politica del contratto e per questo non si normalizza qui in un
+     * elenco vuoto, che direbbe l'opposto.
+     */
+    private readonly _supportedForms;
     readonly isValidating: _angular_core.Signal<boolean>;
     readonly isCompiling: _angular_core.Signal<boolean>;
     readonly error: _angular_core.Signal<DpeApiError | undefined>;
@@ -1902,6 +2922,9 @@ declare class DpeValidationService {
     readonly justSaved: _angular_core.Signal<boolean>;
     readonly saveError: _angular_core.Signal<DpeApiError | undefined>;
     readonly environmentDialect: _angular_core.Signal<SqlDialectKind | undefined>;
+    readonly expressionLanguage: _angular_core.Signal<string | undefined>;
+    readonly providesFormulaCatalog: _angular_core.Signal<boolean>;
+    readonly supportedForms: _angular_core.Signal<readonly DpeExpressionForm[] | undefined>;
     /** Vero finche' non e' arrivata la prima risposta: la UI non deve dire "nessun problema". */
     readonly hasResult: _angular_core.Signal<boolean>;
     constructor();
@@ -1983,8 +3006,9 @@ declare class DpeBuilderComponent {
     protected readonly dialect: Signal<SqlDialectKind>;
     /**
      * Disallineamento fra cio' che l'ambiente dichiara e cio' che la definizione porta. Si
-     * **segnala** e non si corregge: correggere vorrebbe dire migrare le espressioni SQL native
-     * (ADR 0006), che e' dell'host. Assente `getEnvironment`, non c'e' niente da confrontare.
+     * **segnala** e non si corregge: correggere vorrebbe dire cambiare le capacita' con cui la
+     * definizione verra' compilata, che e' dell'host. Assente `getEnvironment`, non c'e' niente da
+     * confrontare.
      */
     protected readonly dialectMismatch: Signal<SqlDialectKind | undefined>;
     /**
@@ -2138,7 +3162,18 @@ interface DpeCanvasNode {
      * colore proprio. Sono due situazioni diverse e l'utente deve capire subito quale guarda.
      */
     isNotCompilable: boolean;
-    /** Numero di colonne dello schema di uscita, quando il backend lo ha detto. */
+    /**
+     * Numero di colonne dello schema di uscita. `null` significa **nessuna pastiglia**, e ci sono
+     * due modi di arrivarci:
+     *
+     * - il backend non ha dichiarato di aver derivato lo schema (`hasSchema`, ADR 0041): un «0 col.»
+     *   sarebbe un'affermazione che nessuno ha fatto;
+     * - il nodo e' un **pozzo**: il conteggio risponde a «cosa esce di qui», e da un pozzo non esce
+     *   niente. Lo zero e' vero — e' la condizione normale di ogni writeback — ed e' la risposta a
+     *   una domanda che non si pone.
+     *
+     * Sui nodi **non** pozzo lo zero si mostra: li' significa `DPE_SCHEMA_EMPTY`, che e' un errore.
+     */
     columnCount: number | null;
 }
 interface DpeCanvasEdge {
@@ -2227,7 +3262,7 @@ declare class DpeCanvasComponent {
         sourceId: string;
         targetId?: string;
     }): void;
-    /** Riassegnazione di un arco già disegnato, da un capo o dall'altro. */
+    /** Riassegnazione di un arco gia' disegnato, da un capo o dall'altro. */
     onReassignConnection(event: {
         endpoint: string;
         previousSourceId: string;
@@ -2260,9 +3295,13 @@ declare class DpeCanvasComponent {
         nodeIds: string[];
     }): void;
     /**
-     * Rilascio di una voce trascinata dalla palette. `externalItemRect` e' già nel sistema di
+     * Rilascio di una voce trascinata dalla palette. `externalItemRect` e' gia' nel sistema di
      * coordinate del canvas: convertirlo a mano dal viewport sarebbe rifare la trasformazione
      * di zoom e panoramica della libreria.
+     *
+     * `data` e' `unknown` per @foblex/flow, e qui il dato si **controlla** invece di convertirlo con
+     * un `as`: un rilascio che non porta una collezione di nodi si ignora, come si ignorava un dato
+     * vuoto. E' il confine che permette a `dpeNodeCategory` di lanciare fuori dall'unione.
      */
     onCreateNode(event: {
         data: unknown;
@@ -2464,7 +3503,33 @@ declare class DpeNodeFactsComponent {
      */
     readonly isNotCompilable: _angular_core.Signal<boolean>;
     readonly columns: _angular_core.Signal<_esfaenza_dpe_builder.DpeColumnInfo[]>;
-    readonly diagnostics: _angular_core.Signal<_esfaenza_dpe_builder.Diagnostic[]>;
+    /**
+     * Se `columns` e' un **fatto** (ADR 0041). E' l'unica cosa che `hasSchema` dice: non dice che il
+     * nodo sta bene, non dice che ha colonne, non dice che e' compilabile.
+     *
+     * `=== true` e non un confronto lasco: assente significa `false`, perche' un ospite che non
+     * serializza i booleani falsi non manda affatto la proprieta' — e il verso prudente e' «non lo
+     * so», non «zero colonne».
+     */
+    readonly hasSchema: _angular_core.Signal<boolean>;
+    /**
+     * Il nodo e' un **pozzo**. Non si deduce da niente: si legge la collezione di appartenenza dal
+     * documento e si chiede la categoria al catalogo dei nodi — la stessa che il view model del
+     * canvas usa per decidere se disegnare la porta di uscita, e per la stessa domanda («da qui esce
+     * qualcosa?»).
+     *
+     * Serve perche' uno schema di uscita **vuoto** significa due cose diverse su un pozzo e su un
+     * nodo di mezzo, e la differenza non e' nei dati: e' nel tipo di nodo, che il backend ci ha gia'
+     * detto qual e'.
+     */
+    readonly isSink: _angular_core.Signal<boolean>;
+    readonly diagnostics: _angular_core.Signal<Diagnostic[]>;
+    /**
+     * Il campo in causa, dalla stessa funzione che gli ispettori usano per agganciare il rilievo al
+     * controllo (`contracts.md` §1). Vuoto quando la diagnostica riguarda il nodo intero, e allora
+     * la riga non mostra niente: e' un fatto sul nodo, non su un campo.
+     */
+    protected fieldOf(diagnostic: Diagnostic): string | undefined;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeNodeFactsComponent, never>;
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeNodeFactsComponent, "dpe-node-facts", never, { "nodeName": { "alias": "nodeName"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
@@ -2484,6 +3549,23 @@ declare abstract class DpeNodeInspectorBase<TNode extends DpeAnyNode = DpeAnyNod
     readonly isNotCompilable: _angular_core.Signal<boolean>;
     /** Colonne prodotte dal nodo, secondo il backend. Mai calcolate qui (**I4**). */
     readonly outputColumns: _angular_core.Signal<readonly DpeColumnInfo[]>;
+    /**
+     * La forma pretesa dai siti di espressione del nodo, **dal backend** (ADR 0031 §1).
+     *
+     * Si legge dallo **schema** e non dal catalogo delle formule, ed e' il punto della faccenda: la
+     * forma e' cio' che la libreria ha derivato su questo nodo — come le colonne e la compilabilita'
+     * qui sopra — mentre il catalogo e' cio' che il compilatore offre, e **arriva solo quando il
+     * compilatore risponde**. Finche' viaggiava col catalogo, un ospite che dichiara di non
+     * descrivere il proprio linguaggio non faceva chiamare la rotta e la forma non arrivava mai.
+     *
+     * Assente significa «questo nodo non ospita formule», ed e' uno stato normale: nessuna forma si
+     * indovina dal tipo di nodo, che sarebbe una regola di dominio in TypeScript.
+     *
+     * Sta sulla base e non sui due ispettori che la usano perche' e' un campo dello stesso record da
+     * cui gia' si leggono `outputColumns` e `isNotCompilable`: leggerlo due volte in due componenti
+     * significherebbe due letture da tenere allineate.
+     */
+    readonly requiredForm: _angular_core.Signal<DpeExpressionForm | undefined>;
     /**
      * Colonne disponibili **in ingresso**: l'unione degli schemi dei nodi a monte, nell'ordine.
      * Arrivano dal backend; se la validazione non e' ancora tornata l'elenco e' vuoto e i campi
@@ -2492,11 +3574,46 @@ declare abstract class DpeNodeInspectorBase<TNode extends DpeAnyNode = DpeAnyNod
     readonly inputColumns: _angular_core.Signal<readonly DpeColumnInfo[]>;
     /** I parametri dichiarati sulla radice: servono a filtri e mapping dei writeback. */
     readonly parameters: _angular_core.Signal<_esfaenza_dpe_builder.DpeParameter[]>;
-    /** Le diagnostiche su un campo preciso, per mostrarle **accanto** al controllo. */
+    /**
+     * Le diagnostiche su un campo preciso, per mostrarle **accanto** al controllo.
+     *
+     * Il nome del campo si chiede a `dpeDiagnosticField` invece di leggere `path.field` qui:
+     * `contracts.md` §1 nomina quella funzione come **il** punto in cui l'editor aggancia il rilievo
+     * al controllo, e una funzione sola che sappia come una diagnostica nomina il proprio campo e'
+     * la stessa ragione per cui esiste `DiagnosticArgumentKeys`. Il percorso e' gia' pubblicato in
+     * tre forme diverse: il giorno in cui succede anche al campo, il posto da cambiare e' uno.
+     */
     issuesOn(field: string): Diagnostic[];
     hasIssueOn(field: string): boolean;
+    /**
+     * Le diagnostiche su **una riga** di una collezione del nodo (`expressionFields[2].expression`).
+     *
+     * Esiste accanto a `issuesOn` perche' quella filtra per solo nome di campo, e in una collezione
+     * il nome si ripete su ogni riga: l'errore della prima formula finirebbe sotto la terza.
+     */
+    issuesOnItem(collection: string, index: number, field: string): Diagnostic[];
+    /**
+     * «Il campo porta un valore», nel senso della regola di rendering di `frontend.md` §5-ter:
+     * **un campo che porta un valore si rende anche fuori dalla propria condizione**.
+     *
+     * E' l'unica meta' della regola che serve anche **fuori** dalla tabella delle condizioni
+     * (`core/dpe-conditional-fields.ts`): un campo dentro una riga di collezione non ha una voce
+     * in tabella, perche' la ripulitura toglie chiavi del nodo, ma la sua resa segue la stessa
+     * regola. Il predicato e' quello, non una seconda copia: qui si delega e basta.
+     */
+    protected declares(value: unknown): boolean;
     /** Applica una modifica al nodo. */
     protected patch(patch: Partial<TNode>): void;
+    /**
+     * Cambia un **discriminante** e toglie in un colpo solo i campi che con il valore nuovo non si
+     * applicano piu', secondo la tabella delle condizioni del nodo.
+     *
+     * E' la seconda strada che legge quelle condizioni — la prima e' la resa di §5-ter — e legge la
+     * **stessa** tabella: una riga aggiunta domani entra qui senza che nessuno la ricopi, che e' il
+     * punto di `core/dpe-conditional-fields.ts`. La ripulitura resta una modifica come le altre e
+     * rientra nell'annullamento globale, perche' passa da `patch`.
+     */
+    protected patchPruned<TConditions extends DpeConditionalFields<TNode>>(change: Partial<TNode>, conditions: TConditions): void;
     /**
      * Campo semplice: valore vuoto → chiave **rimossa**, non stringa vuota. Il backend
      * distingue assente da vuoto (`DPE_MODEL_REQUIRED_MISSING` contro un valore non valido), e
@@ -2504,6 +3621,20 @@ declare abstract class DpeNodeInspectorBase<TNode extends DpeAnyNode = DpeAnyNod
      * semantica invece di ripulire il campo.
      */
     protected setField(field: keyof TNode & string, value: unknown): void;
+    /**
+     * Interruttore il cui **default e' `false`**: spento → chiave **rimossa**, non `false` scritto.
+     *
+     * Due conseguenze, e la seconda e' quella che serve a §5-ter. La prima e' **I7**: chi accende e
+     * rispegne per curiosita' non deve lasciare nel documento una chiave che non c'era. La seconda
+     * e' che cosi' una casella **sa dire «assente»**: il controllo che rende un campo fuori dalla
+     * propria condizione deve poterlo riportare all'assenza, e una casella che scrivesse `false`
+     * resterebbe accesa-o-spenta senza mai togliere niente — resa e inerte, che e' il difetto
+     * travestito da soluzione.
+     *
+     * **Non** si usa dove l'assenza vale `true` (`includesSelfValue`): li' `false` e' una
+     * dichiarazione vera e toglierla direbbe il contrario.
+     */
+    protected setFlag(field: keyof TNode & string, value: boolean): void;
     /** Numero da un campo di testo: vuoto o non numerico → assente, non `0`. */
     protected toNumber(value: string): number | undefined;
     /** Lettura tipizzata di un valore da un evento di input, senza `any` nei template. */
@@ -2569,10 +3700,17 @@ declare class DpeSchemaPanelComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeSchemaPanelComponent, "dpe-schema-panel", never, {}, {}, never, never, true, never>;
 }
 
+/**
+ * I tre soli fatti che un writeback compilato e un **piano di artefatto** (ADR 0029) hanno in
+ * comune, e gli unici che questo pannello mostra. Tipizzare la sezione sul minimo condiviso
+ * evita un'unione che il template dovrebbe poi discriminare per rendere le stesse tre cose: qui
+ * cambia il tipo, non il comportamento.
+ */
+type DpeSqlPreviewItem = Pick<DpeCompiledWriteback & DpeArtifactPlan, 'writebackName' | 'sequence' | 'statement'>;
 interface DpeSqlSection {
     title: string;
     hint: string;
-    writebacks: readonly DpeCompiledWriteback[];
+    writebacks: readonly DpeSqlPreviewItem[];
 }
 declare class DpeSqlPreviewComponent {
     private readonly store;
@@ -2590,20 +3728,140 @@ declare class DpeExpressionEditorComponent {
     readonly label: _angular_core.InputSignal<string>;
     readonly value: _angular_core.InputSignal<string | undefined>;
     readonly placeholder: _angular_core.InputSignal<string>;
-    readonly dialect: _angular_core.InputSignal<SqlDialectKind>;
     /**
-     * I nomi delle colonne a monte, **come suggerimento** e non come elenco chiuso: sono cio'
-     * che il backend ha propagato, ma dentro l'espressione si puo' scrivere qualunque SQL.
+     * Il nome del linguaggio di formule dichiarato dall'ambiente. Assente: l'etichetta non nomina
+     * niente. **Non** ripiega sul dialetto — sarebbe la bugia che questo lotto e' venuto a togliere.
+     */
+    readonly language: _angular_core.InputSignal<string | undefined>;
+    /**
+     * I nomi delle colonne a monte, **come suggerimento**: sono cio' che il backend ha propagato
+     * (**I4**), e l'editor non li calcola.
      */
     readonly columns: _angular_core.InputSignal<readonly string[]>;
+    /**
+     * Le diagnostiche del backend **su questo campo**, gia' filtrate da chi conosce il percorso.
+     * Si rendono e basta: il messaggio lo compone il backend, che e' l'unico posto in cui un
+     * messaggio viene composto.
+     */
+    readonly issues: _angular_core.InputSignal<readonly Diagnostic[]>;
+    /**
+     * **Quale dei tre esiti del catalogo** si sta guardando, gia' letto da `dpeFormulaCatalogOutcome`.
+     *
+     * Prende l'esito e non il catalogo perche' il catalogo da solo non basta piu' a distinguerli: un
+     * compilatore che non descrive il proprio linguaggio consegna il catalogo **presente e vuoto**,
+     * quindi «assente» e «vuoto» sono due situazioni diverse che un solo oggetto nullabile
+     * appiattiva — ed e' l'appiattimento che faceva sembrare uguali un dialetto non coperto e un
+     * backend rotto.
+     */
+    readonly outcome: _angular_core.InputSignal<DpeFormulaCatalogOutcome>;
+    /**
+     * La forma pretesa dal campo, **dal backend**. Assente: il campo non la nomina. Non si deduce
+     * dal tipo di nodo, che sarebbe una regola di dominio scritta dalla parte sbagliata del confine.
+     */
+    readonly requiredForm: _angular_core.InputSignal<DpeExpressionForm | undefined>;
+    /**
+     * L'incrocio **gia' fatto** fra la forma richiesta da questo nodo e le forme che il compilatore
+     * registrato sa produrre (`DpeEnvironment.supportedForms`), come per `outcome`: il componente
+     * riceve l'esito, non i due operandi.
+     *
+     * Il difetto predefinito e' «supportato», ed e' la politica del contratto: **capacita' non
+     * dichiarate non disabilitano niente**. Un ospite che monta questo componente senza passare
+     * nulla ottiene un campo che si scrive, non uno spento per ignoranza.
+     */
+    readonly formSupport: _angular_core.InputSignal<DpeExpressionFormSupport>;
+    /**
+     * **Una validazione e' in volo**, quindi la forma qui sopra puo' non essere ancora quella del
+     * documento che l'utente ha davanti (ADR 0042). La pastiglia si segna «in aggiornamento» e
+     * smette di asserire; il **blocco resta applicato**.
+     *
+     * E' di **documento** e **transitorio**, e per questo non e' una regola di dominio: arriva da
+     * `DpeValidationService.isValidating`, che esisteva gia'. L'editor non sa — e non deve sapere —
+     * che la forma dipende dal tipo del nodo: saperlo sarebbe riscrivere in TypeScript la regola che
+     * `requiredForm` attraversa il confine per non avere.
+     *
+     * Non e' «il documento e' cambiato dall'ultima validazione», che e' il rimedio che l'ADR 0042
+     * rifiuta: quello sarebbe vero **per tutta** la digitazione e spegnerebbe la pastiglia proprio
+     * mentre si scrive nel campo che accompagna. `isValidating` diventa vero solo dopo la pausa di
+     * digitazione, quindi mentre si scrive questa pastiglia resta ferma — e corretta, perche' la
+     * forma non e' cambiata.
+     *
+     * Difetto predefinito `false`: un ospite che monta il componente senza passare nulla ottiene una
+     * pastiglia asserita, che e' cio' che era prima.
+     */
+    readonly isFormUpdating: _angular_core.InputSignal<boolean>;
+    readonly isCatalogLoading: _angular_core.InputSignal<boolean>;
     readonly controlId: _angular_core.InputSignal<string>;
     readonly valueChange: _angular_core.OutputEmitterRef<string>;
-    readonly dialectLabel: _angular_core.Signal<string>;
+    readonly hasError: _angular_core.Signal<boolean>;
     /** Elenco troncato: dieci nomi sono un aiuto, cinquanta sono un muro di testo. */
     readonly columnHint: _angular_core.Signal<string>;
+    /**
+     * La forma pretesa, detta all'utente. Assente quando il nodo non ospita formule: il campo non
+     * nomina nessuna forma di ripiego, che sarebbe la deduzione vietata travestita da default.
+     */
+    readonly formPrompt: _angular_core.Signal<string | undefined>;
+    /**
+     * La classe della pastiglia. Binding a stringa e nessuna classe statica accanto, come per il
+     * controllo bloccato: il binding governa l'intera lista.
+     *
+     * Il modificatore non cambia il testo, cambia il **tono**: la pastiglia perde la tinta d'accento
+     * — che e' cio' che la faceva leggere come un fatto corrente — e prende il bordo tratteggiato
+     * della cosa provvisoria.
+     */
+    readonly formClass: _angular_core.Signal<"dpe-expr__form dpe-expr__form--updating" | "dpe-expr__form">;
+    /**
+     * Il titolo dice **cosa aspettarsi**, e nella finestra di aggiornamento dice anche che il blocco
+     * non si tocca: e' la meta' che l'utente non puo' dedurre dal colore, e senza la quale un campo
+     * che non accetta testo accanto a un'etichetta incerta sembra rotto.
+     */
+    readonly formTitle: _angular_core.Signal<string>;
+    /** `aria-busy` invece del solo colore: chi usa un lettore di schermo deve sentirlo. */
+    readonly ariaBusy: _angular_core.Signal<"true" | null>;
+    /** Il campo non si scrive: la forma richiesta qui non e' fra quelle che il compilatore produce. */
+    readonly isBlocked: _angular_core.Signal<boolean>;
+    /**
+     * Il motivo, **presente solo quando il campo e' bloccato**. Un campo inerte e muto fa cercare
+     * all'utente un errore nella propria formula, che e' l'unico posto in cui il problema non sta.
+     */
+    readonly blockedReason: _angular_core.Signal<string | undefined>;
+    /**
+     * La classe del controllo bloccato. Binding a stringa e nessuna classe statica accanto, come per
+     * i rilievi: il binding governa l'intera lista e una classe scritta anche nell'attributo statico
+     * sembra ridondante finche' non sparisce.
+     */
+    readonly inputClass: _angular_core.Signal<"" | "dpe-expr__input--blocked">;
+    /** L'esito di fallimento, quando e' quello: il template rende solo se c'e'. */
+    readonly failure: _angular_core.Signal<{
+        readonly kind: "Failed";
+        readonly lead: Diagnostic;
+        readonly details: readonly Diagnostic[];
+        readonly hasError: boolean;
+    } | undefined>;
+    /**
+     * Il blocco del fallimento prende il bordo dell'errore quando fra le diagnostiche c'e' un
+     * `Error`, quello dell'avviso altrimenti. Non e' decorazione: «il catalogo non c'e' perche' la
+     * definizione e' rotta a monte» e «il catalogo non c'e' e basta» si correggono in modi diversi.
+     */
+    readonly failureClass: _angular_core.Signal<"dpe-note dpe-note--danger" | "dpe-note dpe-note--warning">;
+    /**
+     * Cosa il linguaggio offre **qui**, in numeri. E' deliberatamente un conteggio: dice che il
+     * catalogo e' arrivato e che dipende dal nodo (i simboli cambiano con lo schema a monte), senza
+     * anticipare l'elenco navigabile, che e' un componente e va progettato guardandolo.
+     *
+     * Solo per l'esito `Palette`: un conteggio di zeri sotto un campo direbbe che qualcosa e'
+     * andato storto, mentre il compilatore ha soltanto scelto di non descriversi.
+     */
+    readonly catalogHint: _angular_core.Signal<string | undefined>;
+    /**
+     * `aria-describedby` porta **il suggerimento, i rilievi e il motivo per cui la tavolozza manca**:
+     * un lettore di schermo deve sentire l'errore del compilatore leggendo il campo, non cercandolo
+     * piu' in basso, e deve sapere che qui non c'e' aiuto disponibile prima di scrivere.
+     */
+    readonly describedBy: _angular_core.Signal<string>;
+    protected issueClass(issue: Diagnostic): string;
     protected text(event: Event): string;
     static ɵfac: _angular_core.ɵɵFactoryDeclaration<DpeExpressionEditorComponent, never>;
-    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeExpressionEditorComponent, "dpe-expression-editor", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "dialect": { "alias": "dialect"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeExpressionEditorComponent, "dpe-expression-editor", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "issues": { "alias": "issues"; "required": false; "isSignal": true; }; "outcome": { "alias": "outcome"; "required": false; "isSignal": true; }; "requiredForm": { "alias": "requiredForm"; "required": false; "isSignal": true; }; "formSupport": { "alias": "formSupport"; "required": false; "isSignal": true; }; "isFormUpdating": { "alias": "isFormUpdating"; "required": false; "isSignal": true; }; "isCatalogLoading": { "alias": "isCatalogLoading"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
 }
 
 declare class DpeColumnTypeEditorComponent {
@@ -2613,6 +3871,9 @@ declare class DpeColumnTypeEditorComponent {
     protected readonly types: readonly LogicalType[];
     readonly kind: _angular_core.Signal<LogicalType>;
     readonly allowedValues: _angular_core.Signal<string>;
+    readonly showsLength: _angular_core.Signal<boolean>;
+    readonly showsPrecision: _angular_core.Signal<boolean>;
+    readonly showsAllowedValues: _angular_core.Signal<boolean>;
     protected onKind(kind: string): void;
     protected onNumber(field: 'length' | 'precision' | 'scale', raw: string): void;
     protected onAllowedValues(raw: string): void;
@@ -2636,5 +3897,5 @@ declare class DpeNodeIconComponent {
     static ɵcmp: _angular_core.ɵɵComponentDeclaration<DpeNodeIconComponent, "dpe-node-icon", never, { "collection": { "alias": "collection"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
 }
 
-export { DPE_API_ERROR_FALLBACK_MESSAGE, DPE_BUILDER_HTTP_CONFIG, DPE_DIALECT_LABELS, DPE_LAYOUT_KEY, DPE_NODE_CATEGORIES, DPE_NODE_COLLECTIONS, DPE_NODE_HEIGHT, DPE_NODE_ICON_PATHS, DPE_NODE_NOT_COMPILABLE, DPE_SOURCE_SLOTS, DpeApiError, DpeBuilderApi, DpeBuilderComponent, DpeCanvasComponent, DpeCatalogComponent, DpeCatalogStore, DpeColumnTypeEditorComponent, DpeDiagnosticsPanelComponent, DpeDocumentStore, DpeExpressionEditorComponent, DpeLayoutService, DpeMetadataStore, DpeNodeDialogComponent, DpeNodeFactsComponent, DpeNodeIconComponent, DpeNodeInspectorBase, DpeNodeInspectorComponent, DpeNodePaletteComponent, DpeSchemaPanelComponent, DpeSelectValueDirective, DpeSqlPreviewComponent, DpeValidationService, HttpDpeBuilderApi, diagnosticPathToString, dpeAllNodes, dpeBuildGraph, dpeCountReferences, dpeCreateCommandAvailability, dpeCreateNode, dpeDefinitionLevelDiagnostics, dpeDiagnosticField, dpeDiagnosticLocationLabel, dpeDiagnosticNodeName, dpeEdgeId, dpeEmptyDefinition, dpeFindNode, dpeGroupDiagnosticsByNode, dpeHasCompleteLayout, dpeInputPortId, dpeInputPorts, dpeIsDialectDiagnostic, dpeIsNotCompilable, dpeIsPrimitiveAvailable, dpeIsRectFullyVisible, dpeKnownNodeNames, dpeNodeCategory, dpeNodeIconFamily, dpeNodeIconFamilyClass, dpeNodeIconPaths, dpeNodeId, dpeNodeSourceReferences, dpeNodeSubtitle, dpeNodeWidth, dpeNodeWidthClass, dpeOutputPortId, dpeParseInputPortId, dpeParseNodeId, dpeParseOutputPortId, dpeProposeNodeName, dpeProposeWritebackSequence, dpeReadCapabilities, dpeReadNodePosition, dpeRenameNode, dpeWorstSeverity, dpeWriteNodePosition, dpeWriteSourceReference, provideDpeBuilderHttpApi };
-export type { AggregateField, AggregateFunction, AggregateNode, AppendNode, AtomicWritebackNode, AtomicWritebackRelationship, ColumnType, CsvArtifactOptions, CsvDelimiter, CsvSourceOptions, CustomNode, CustomNodeParameter, DataSourceField, DataSourceKind, DataSourceNode, DatePart, DeclaredField, DefinitionRunMode, DefinitionStatus, Diagnostic, DiagnosticPath, DiagnosticPathSegment, DiagnosticSeverity, DpeAnyNode, DpeApiErrorCategory, DpeBuilderHttpConfig, DpeCanvasEdge, DpeCanvasNode, DpeCanvasPort, DpeCapabilities, DpeColumnInfo, DpeCommandAvailability, DpeCompileResult, DpeCompiledWriteback, DpeDefinition, DpeDefinitionSummary, DpeEnvironment, DpeExtensible, DpeExtensionData, DpeFieldMappingInfo, DpeGraph, DpeGraphEdge, DpeGraphNode, DpeInputPort, DpeLayoutDirection, DpeLayoutEdgeInput, DpeLayoutNodeInput, DpeLayoutOptions, DpeLayoutPosition, DpeLocatedNode, DpeNode, DpeNodeCategory, DpeNodeCollectionMap, DpeNodeCollectionName, DpeNodeDiagnostics, DpeNodeIconFamily, DpeNodePaletteGroup, DpeNodePosition, DpeNodeSchemaInfo, DpeOptionalPrimitive, DpeParameter, DpeParameterValue, DpeRect, DpeSourceReference, DpeSourceSlot, DpeTableState, DpeValidateResult, DpeWritebackStep, ExpressionField, FieldDescriptor, FieldRelationship, FilterCriterion, FilterNode, FilterOperator, ForecastAccuracy, ForecastAggregationField, ForecastGroupField, ForecastModelType, ForecastNode, ForecastPeriodType, HierarchyPathNode, JoinKey, JoinKind, JoinNode, JoinResultField, JsonArtifactOptions, LogicalType, OrderByField, ParameterRole, SortDirection, SqlDialectKind, SqlParameterValue, SqlStatement, TableDescriptor, TableLookupOutcome, TableLookupResult, TableSummary, TransformKind, TransformNode, WritebackFieldMapping, WritebackFieldRole, WritebackNode, WritebackOperation, WritebackTargetKind };
+export { DPE_API_ERROR_FALLBACK_MESSAGE, DPE_BUILDER_HTTP_CONFIG, DPE_CATALOG_UNAVAILABLE, DPE_DATA_SOURCE_CONDITIONS, DPE_DIALECT_LABELS, DPE_FILTER_CONDITIONS, DPE_HIERARCHY_PATH_CONDITIONS, DPE_JOIN_CONDITIONS, DPE_LAYOUT_KEY, DPE_NODE_CATEGORIES, DPE_NODE_COLLECTIONS, DPE_NODE_HEIGHT, DPE_NODE_ICON_PATHS, DPE_NODE_NOT_COMPILABLE, DPE_SOURCE_SLOTS, DPE_TRANSFORM_CONDITIONS, DPE_WRITEBACK_CONDITIONS, DpeApiError, DpeBuilderApi, DpeBuilderComponent, DpeCanvasComponent, DpeCatalogComponent, DpeCatalogStore, DpeColumnTypeEditorComponent, DpeDiagnosticsPanelComponent, DpeDocumentStore, DpeExpressionEditorComponent, DpeFormulaCatalogStore, DpeLayoutService, DpeMetadataStore, DpeNodeDialogComponent, DpeNodeFactsComponent, DpeNodeIconComponent, DpeNodeInspectorBase, DpeNodeInspectorComponent, DpeNodePaletteComponent, DpeSchemaPanelComponent, DpeSelectValueDirective, DpeSqlPreviewComponent, DpeValidationService, HttpDpeBuilderApi, diagnosticPathToString, dpeAllNodes, dpeBuildGraph, dpeCountReferences, dpeCreateCommandAvailability, dpeCreateNode, dpeDeclares, dpeDefinitionLevelDiagnostics, dpeDiagnosticField, dpeDiagnosticLocationLabel, dpeDiagnosticNodeName, dpeDiagnosticTargetsItem, dpeEdgeId, dpeEmptyDefinition, dpeExpressionFormLabel, dpeExpressionFormPrompt, dpeExpressionFormSupport, dpeFieldVisibility, dpeFindNode, dpeFormulaCatalogOutcome, dpeFormulaCatalogSignature, dpeFormulaCatalogSize, dpeGroupDiagnosticsByNode, dpeHasCompleteLayout, dpeInputPortId, dpeInputPorts, dpeIsDialectDiagnostic, dpeIsNotCompilable, dpeIsPrimitiveAvailable, dpeIsRectFullyVisible, dpeKnownNodeNames, dpeNodeCategory, dpeNodeIconFamily, dpeNodeIconFamilyClass, dpeNodeIconPaths, dpeNodeId, dpeNodeSourceReferences, dpeNodeSubtitle, dpeNodeWidth, dpeNodeWidthClass, dpeOutputPortId, dpeParseInputPortId, dpeParseNodeId, dpeParseOutputPortId, dpeProposeNodeName, dpeProposeWritebackSequence, dpePruneInapplicable, dpeReadCapabilities, dpeReadNodePosition, dpeRenameNode, dpeWorstSeverity, dpeWriteNodePosition, dpeWriteSourceReference, provideDpeBuilderHttpApi };
+export type { AggregateField, AggregateFunction, AggregateNode, AppendNode, ArtifactKind, AtomicWritebackNode, AtomicWritebackRelationship, ColumnType, CsvArtifactOptions, CsvDelimiter, CsvSourceOptions, CustomNode, CustomNodeParameter, DataSourceField, DataSourceKind, DataSourceNode, DatePart, DeclaredField, DefinitionRunMode, DefinitionStatus, Diagnostic, DiagnosticPath, DiagnosticPathSegment, DiagnosticSeverity, DpeAnyNode, DpeApiErrorCategory, DpeArtifactColumn, DpeArtifactPlan, DpeBuilderHttpConfig, DpeCanvasEdge, DpeCanvasNode, DpeCanvasPort, DpeCapabilities, DpeColumnInfo, DpeCommandAvailability, DpeCompileResult, DpeCompiledWriteback, DpeConditionalFields, DpeDefinition, DpeDefinitionSummary, DpeEnvironment, DpeExpressionForm, DpeExpressionFormSupport, DpeExtensible, DpeExtensionData, DpeFieldCondition, DpeFieldMappingInfo, DpeFieldVisibility, DpeFormulaCatalog, DpeFormulaCatalogOutcome, DpeFormulaCatalogResult, DpeFormulaFunction, DpeFormulaFunctionParameter, DpeFormulaOperator, DpeFormulaSymbol, DpeFormulaSymbolKind, DpeGraph, DpeGraphEdge, DpeGraphNode, DpeInputPort, DpeLayoutDirection, DpeLayoutEdgeInput, DpeLayoutNodeInput, DpeLayoutOptions, DpeLayoutPosition, DpeLocatedNode, DpeNode, DpeNodeCategory, DpeNodeCollectionMap, DpeNodeCollectionName, DpeNodeDiagnostics, DpeNodeIconFamily, DpeNodePaletteGroup, DpeNodePosition, DpeNodeSchemaInfo, DpeOptionalPrimitive, DpeParameter, DpeParameterValue, DpeRect, DpeSourceReference, DpeSourceSlot, DpeTableState, DpeValidateResult, DpeWritebackStep, ExpressionField, FieldDescriptor, FieldRelationship, FilterCriterion, FilterNode, FilterOperator, ForecastAccuracy, ForecastAggregationField, ForecastGroupField, ForecastModelType, ForecastNode, ForecastPeriodType, HierarchyPathNode, JoinKey, JoinKind, JoinNode, JoinResultField, JsonArtifactOptions, LogicalType, OrderByField, ParameterRole, SortDirection, SqlDialectKind, SqlParameterValue, SqlStatement, TableDescriptor, TableLookupOutcome, TableLookupResult, TableSummary, TransformKind, TransformNode, WritebackFailureHandling, WritebackFieldMapping, WritebackFieldRole, WritebackNode, WritebackOperation, WritebackTargetKind };