@lamemind/loom-deck 0.67.0 → 0.68.0

package/dist/overlays/sheet.js

@@ -18,10 +18,9 @@ import { scanText, topForOffset } from '../text-search.js';
 import { parseMarkdown } from '../markdown.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
-import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn.js';
+import { ACTION_HOTKEYS, DETAIL_ACTIONS, MODELS, MODEL_DEFAULT, specializeRecap, } from '../spawn-catalog.js';
 import { taskIsEpic } from '../tasks.js';
 import { fieldsKey } from '../fields.js';
-import { loadPromptCatalog, modelFor, promptFor } from '../prompt-catalog.js';
 // T117 — le righe dell'area di compilazione del detail, nell'ordine in cui si
 // leggono dall'alto. Gli indici sono nominati perché li usano insieme l'handler
 // dei tasti e la resa, e un `2` nudo in due file diversi è la coordinata che
@@ -41,7 +40,7 @@ export const DETAIL_FIELDS = [
     { kind: 'choice', count: PRIORITY_CHOICES.length },
 ];
 export function useSheetOverlay(deps) {
-    const { rows, columns, setMode, setNote, onAction } = deps;
+    const { rows, columns, setMode, setNote, defaults, onAction } = deps;
     const [sheet, setSheet] = useState(null);
     const [top, setTop] = useState(0);
     const [action, setAction] = useState(0);
@@ -68,9 +67,6 @@ export function useSheetOverlay(deps) {
      *  riparserebbe l'intero task file per un campo dell'header. */
     const [epic, setEpic] = useState(false);
     const [cursor, setCursor] = useState({ row: DROW.action, caret: 0 });
-    // Il catalogo si legge una volta per vita del deck: è un file di quattro righe
-    // accanto al codice, non un dato che cambia sotto i piedi.
-    const catalog = useMemo(() => loadPromptCatalog(), []);
     // T91 — ricerca dentro il detail. `open` distingue i due modi in cui la si
     // lascia: `esc` butta via ciò che il modale ha prodotto (`find` a null,
     // evidenziazione via), `⏎` lo congela e restituisce il controllo allo strato
@@ -130,13 +126,13 @@ export function useSheetOverlay(deps) {
         setTop(0);
         setAction(0);
         setEpic(isEpic);
-        // T152 — il modello segue l'azione iniziale, come già il prompt: su una
-        // task Epic la prima azione specializza a `recap-epic`, che nel catalogo
-        // può portare un modello diverso da `recap`. Nessun kind fuori catalogo →
-        // MODEL_DEFAULT, lo stesso fallback che vale ovunque nel deck.
-        setModel(modelFor(catalog, kind) ?? MODEL_DEFAULT);
-        setSpawnNote('');
-        setPrompt(promptFor(catalog, kind, next.id));
+        // T152/T161 — i tre campi partono dalla terna dell'azione, risolta sul
+        // catalogo e sugli override di progetto: su una task Epic la prima azione
+        // specializza a `recap-epic`, che può portare valori diversi da `recap`.
+        const d = defaults(kind, next.id);
+        setModel(d.model);
+        setSpawnNote(d.title ?? '');
+        setPrompt(d.prompt ?? '');
         setPriority(false);
         setCursor({ row: DROW.action, caret: 0 });
         setFind(null);
@@ -144,21 +140,27 @@ export function useSheetOverlay(deps) {
         setNote('');
         setMode('detail');
     }
-    /** Cambia l'azione e RISCRIVE prompt e modello col default del nuovo kind (D2).
+    /** Cambia l'azione e RISCRIVE i tre campi col default del nuovo kind (D2).
      *
-     *  Nessuna preservazione della scelta manuale di modello, per la stessa
-     *  ragione già scritta sul prompt: col fuoco per riga un cambio di azione
-     *  ACCIDENTALE non esiste — `←→` cambiano azione solo dalla riga azione —
-     *  quindi la preservazione difenderebbe da nulla e costerebbe un campo che
-     *  non torna più al default della nuova azione (T152). */
+     *  Nessuna preservazione delle scelte fatte a mano, per la stessa ragione già
+     *  scritta sul prompt: col fuoco per riga un cambio di azione ACCIDENTALE non
+     *  esiste — `←→` cambiano azione solo dalla riga azione — quindi la
+     *  preservazione difenderebbe da nulla e costerebbe campi che non tornano più
+     *  al default della nuova azione (T152).
+     *
+     *  T161 — da qui ci passa anche il TITOLO, che prima restava vuoto e veniva
+     *  riempito allo spawn da `fallbackTitle`: ora il campo mostra quello che
+     *  partirà, come già il prompt e il modello. */
     function selectAction(index) {
         setAction(index);
         const id = sheet?.id;
         if (!id)
             return;
         const kind = specializeRecap(DETAIL_ACTIONS[index].kind, epic);
-        setPrompt(promptFor(catalog, kind, id));
-        setModel(modelFor(catalog, kind) ?? MODEL_DEFAULT);
+        const d = defaults(kind, id);
+        setPrompt(d.prompt ?? '');
+        setModel(d.model);
+        setSpawnNote(d.title ?? '');
     }
     // Il ponte fra le quattro righe e i quattro stati. Le righe restano
     // TIPIZZATE dove vivono (`ModelKind`, indice dell'azione) invece di finire in
@@ -279,13 +281,12 @@ export function useSheetOverlay(deps) {
             // Il kind viaggia specializzato quanto il prompt che lo accompagna: se il
             // campo è stato svuotato a mano il testo non parte e resta lui a dire cosa
             // ricevera' la sessione, quindi i due non possono divergere.
-            const act = DETAIL_ACTIONS[action];
             const id = sheet?.id;
             const note = spawnNote.trim();
             const text = prompt.trim();
             close();
             if (id)
-                onAction(id, specializeRecap(act.kind, epic), model, note, text, priority);
+                onAction(id, model, note, text, priority);
             return;
         }
         if (key.pageUp) {

package/dist/overlays/spawn.js

@@ -0,0 +1,240 @@
+// T161 — la PAGINA DELLE AZIONI DI SPAWN: ottava schermata sostitutiva.
+//
+// Una tabella di undici righe — una per azione che il deck sa aprire — con le
+// quattro colonne funzione, titolo, modello, prompt. Le ultime tre si modificano
+// e il salvataggio scrive il blocco `spawn` di `.claude/loom-works.json`.
+//
+// Due LIVELLI, non un edit dentro la cella (P14 preflight). Al primo si scorre
+// la tabella; `⏎` apre sotto di essa l'area di compilazione della riga
+// selezionata, che è la stessa forma già in esercizio nel detail della task —
+// righe con un fuoco solo, `↑↓` fra le righe, `←→` sul valore o sul caret
+// secondo il tipo (`fields.ts`). Un editor dentro la cella avrebbe voluto un
+// caret che scorre dentro una colonna larga venti colonne, cioè una terza
+// grammatica di input su una schermata che ne ha già due.
+//
+// La bozza vive IN MEMORIA fino a `w`. Comporre una configurazione non tocca il
+// disco — stesso regime del salvataggio esplicito della vista (`w` sul deck) —
+// e il file di progetto è committato: scriverci a ogni freccia produrrebbe un
+// working tree sporco per una prova.
+import { useState } from 'react';
+import { pageStep, spawnListCapacity } from '../viewport.js';
+import { fieldsKey } from '../fields.js';
+import { cpLen } from '../layout.js';
+import { saneTemplate } from '../sane-note.js';
+import { configFilePath } from '../config.js';
+import { cut } from '../width.js';
+import { EXAMPLE_HOLES, MODELS, SPAWN_ACTIONS, editableFields, } from '../spawn-catalog.js';
+import { rawSpawn, } from '../spawn-config.js';
+/** Le tre righe dell'area di compilazione, nell'ordine in cui si leggono. Sono
+ *  posizioni di SCHERMO e non indici del cursore: le righe non editabili si
+ *  disegnano comunque (dicono perché non lo sono) ma il fuoco non ci passa. */
+export const SROW = { title: 0, model: 1, prompt: 2 };
+export function useSpawnPage(deps) {
+    const { cwd, rows, hasNote, overrides, save, catalog, setMode, setNote } = deps;
+    /** La bozza, `null` a pagina chiusa. Copia degli override all'apertura: una
+     *  bozza che sopravvive alla chiusura sarebbe uno stato invisibile che `w`
+     *  scriverebbe la volta dopo. */
+    const [draft, setDraft] = useState(null);
+    const [sel, setSel] = useState(0);
+    const [top, setTop] = useState(0);
+    const [dirty, setDirty] = useState(false);
+    /** L'area di compilazione è aperta sulla riga selezionata. */
+    const [editing, setEditing] = useState(false);
+    const [fieldTitle, setFieldTitle] = useState('');
+    const [fieldModel, setFieldModel] = useState(MODELS[0]);
+    const [fieldPrompt, setFieldPrompt] = useState('');
+    const [cursor, setCursor] = useState({ row: 0, caret: 0 });
+    const capacity = spawnListCapacity(rows, editing, hasNote);
+    const maxTop = Math.max(0, SPAWN_ACTIONS.length - capacity);
+    const open = draft !== null;
+    const action = SPAWN_ACTIONS[sel];
+    const editable = editableFields(action);
+    /** Le specifiche che `fields.ts` consuma: SOLO le celle editabili di questa
+     *  riga, nell'ordine di schermo. Il cursore indicizza qui, non le tre righe
+     *  disegnate — su `bare`, che ha il solo modello, `↑↓` non hanno dove andare e
+     *  non devono finire su una riga che non si modifica. */
+    const specs = editable.map((f) => f === 'model' ? { kind: 'choice', count: MODELS.length } : { kind: 'text' });
+    const table = SPAWN_ACTIONS.map((a) => ({
+        action: a,
+        raw: rawSpawn(a, draft ?? overrides, catalog),
+        touched: (draft ?? overrides).has(a.id),
+    }));
+    function openPage() {
+        setDraft(new Map(overrides));
+        setSel(0);
+        setTop(0);
+        setDirty(false);
+        setEditing(false);
+        setNote('');
+        setMode('spawn');
+    }
+    function close() {
+        setMode('normal');
+        setDraft(null);
+        setEditing(false);
+    }
+    function scroll(delta) {
+        const next = Math.max(0, Math.min(SPAWN_ACTIONS.length - 1, sel + delta));
+        setSel(next);
+        // La finestra INSEGUE la selezione invece di centrarla: la tabella è di
+        // undici righe e su un terminale normale ci sta intera, quindi centrare
+        // farebbe saltare la lista sotto il caret per niente.
+        setTop(Math.max(0, Math.min(next, Math.max(Math.min(top, maxTop), next - capacity + 1))));
+    }
+    /** Apre l'area sulla riga selezionata, coi valori GREZZI correnti. */
+    function openFields() {
+        const raw = rawSpawn(action, draft ?? overrides, catalog);
+        const title = raw.title ?? '';
+        const prompt = raw.prompt ?? '';
+        setFieldTitle(title);
+        setFieldModel(raw.model);
+        setFieldPrompt(prompt);
+        // Caret in coda al primo campo editabile, come `caretAtEnd`: è la posizione
+        // da cui si continua a scrivere, e l'unica che non dipende da dove stava il
+        // cursore l'ultima volta che l'area era aperta.
+        const first = editable[0];
+        setCursor({ row: 0, caret: first === 'model' ? 0 : cpLen(first === 'title' ? title : prompt) });
+        setEditing(true);
+    }
+    /**
+     * Congela l'area nella bozza, tenendo solo ciò che DIFFERISCE dal default.
+     *
+     * È ciò che rende reversibile una modifica senza un gesto apposta: un valore
+     * riportato a mano a quello di partenza smette di essere un override, invece
+     * di restare nel file come una riga che non cambia niente (AC7). Il gesto
+     * apposta — `CANC` — resta per togliere tutte e tre le celle in un colpo.
+     */
+    function commitFields() {
+        const base = rawSpawn(action, new Map(), catalog);
+        const next = {};
+        for (const f of editable) {
+            if (f === 'model') {
+                if (fieldModel !== base.model)
+                    next.model = fieldModel;
+            }
+            else if (f === 'title') {
+                // P10 — la riduzione al confine: quello che entra nella bozza è quello
+                // che comparirà nella tab, coi buchi preservati. Farla solo al
+                // salvataggio mostrerebbe per tutta la sessione un titolo che la tab non
+                // porterà mai.
+                const title = saneTemplate(fieldTitle);
+                if (title !== (base.title ?? ''))
+                    next.title = title;
+            }
+            else if (fieldPrompt !== (base.prompt ?? '')) {
+                next.prompt = fieldPrompt;
+            }
+        }
+        setDraft((d) => {
+            const m = new Map(d ?? overrides);
+            if (Object.keys(next).length > 0)
+                m.set(action.id, next);
+            else
+                m.delete(action.id);
+            return m;
+        });
+        setDirty(true);
+        setEditing(false);
+    }
+    /** `CANC` sulla riga: via l'override, la riga torna al default. */
+    function clearRow() {
+        if (!(draft ?? overrides).has(action.id)) {
+            setNote(`CANC → ${action.id}: nessun override da togliere`);
+            return;
+        }
+        setDraft((d) => {
+            const m = new Map(d ?? overrides);
+            m.delete(action.id);
+            return m;
+        });
+        setDirty(true);
+        setNote(`CANC → ${action.id}: override rimosso, torna al default`);
+    }
+    function write() {
+        const entries = draft ?? overrides;
+        try {
+            save(entries);
+        }
+        catch (e) {
+            // Il file non è del deck: se non si parsa il saver rifiuta invece di
+            // rigenerarlo, e qui si dice perché. La bozza resta viva — chi ripara il
+            // file a mano può ripremere `w` senza rifare le modifiche.
+            setNote(`⚠ ${cut(e.message, 70)}`);
+            return;
+        }
+        setDirty(false);
+        const n = entries.size;
+        setNote(`w → ${n === 0 ? 'nessun override' : `${n} azione${n > 1 ? 'i' : ''} configurate`} · ${configFilePath(cwd)}`);
+    }
+    const fieldsIO = {
+        text: (row) => (editable[row] === 'title' ? fieldTitle : fieldPrompt),
+        setText: (row, next) => editable[row] === 'title' ? setFieldTitle(next) : setFieldPrompt(next),
+        choice: () => Math.max(0, MODELS.indexOf(fieldModel)),
+        setChoice: (_row, index) => setFieldModel(MODELS[index]),
+    };
+    function onFieldsKey(input, key) {
+        if (key.escape) {
+            setEditing(false);
+            return;
+        }
+        if (key.return) {
+            commitFields();
+            return;
+        }
+        fieldsKey(input, key, specs, cursor, setCursor, fieldsIO);
+    }
+    function onKey(input, key) {
+        if (!open)
+            return;
+        if (editing) {
+            onFieldsKey(input, key);
+            return;
+        }
+        if (key.escape) {
+            // Una bozza non salvata si perde: dirlo è l'unico modo di non perderla per
+            // sbaglio, e un modale di conferma su una pagina di configurazione
+            // costerebbe una domanda a ogni uscita.
+            if (dirty)
+                setNote('modifiche non salvate perse · w salva prima di uscire');
+            close();
+            return;
+        }
+        if (key.return) {
+            openFields();
+            return;
+        }
+        if (key.delete) {
+            clearRow();
+            return;
+        }
+        if (key.upArrow)
+            scroll(-1);
+        else if (key.downArrow)
+            scroll(1);
+        else if (key.pageUp)
+            scroll(-pageStep(capacity));
+        else if (key.pageDown)
+            scroll(pageStep(capacity));
+        else if (input === 'w' && !key.ctrl)
+            write();
+    }
+    return {
+        open,
+        table,
+        sel,
+        top,
+        capacity,
+        maxTop,
+        dirty,
+        editing,
+        editable,
+        fieldTitle,
+        fieldModel,
+        fieldPrompt,
+        cursor,
+        /** L'anteprima resa della riga aperta: i buchi riempiti coi valori finti. */
+        example: EXAMPLE_HOLES,
+        openPage,
+        onKey,
+    };
+}

package/dist/overlays/status.js

@@ -17,7 +17,7 @@ import { parseMarkdown } from '../markdown.js';
 import { CLAUDE_CMD, notifyDone, spawnProjectStatus } from '../spawn.js';
 import { readStatusCache, statusFilePath, statusLabel, writeStatusCache, } from '../project-status.js';
 export function useProjectStatus(deps) {
-    const { cwd, name, rows, columns, setMode, setNote } = deps;
+    const { cwd, name, rows, columns, model, prompt, setMode, setNote } = deps;
     const path = useMemo(() => statusFilePath(cwd), [cwd]);
     // Letta al mount e basta: è ciò che fa ripartire un deck riaperto dall'ora di
     // prima invece che da `missing`.
@@ -78,7 +78,7 @@ export function useProjectStatus(deps) {
         setFailed(false);
         setStartedAt(Date.now());
         setNote(`⏳ project status di ${name}… (sid ${sid.slice(0, 8)})`);
-        const child = spawnProjectStatus(cwd, sid, finish);
+        const child = spawnProjectStatus(cwd, sid, finish, model, prompt);
         child.on('error', () => {
             setStartedAt(null);
             setFailed(true);

package/dist/overlays/wrap.js

@@ -14,7 +14,7 @@ import { useWrapScan } from '../hooks.js';
 import { pageStep, wrapListCapacity } from '../viewport.js';
 import { cpLen, insertAt, removeAt } from '../layout.js';
 import { sanitizeTyped } from '../glyphs.js';
-import { WRAP_DEFAULT_PATH, wrapPrompt } from '../wrap-scan.js';
+import { WRAP_DEFAULT_PATH } from '../wrap-scan.js';
 export function useWrapOverlay(deps) {
     const { cwd, rows, setMode, setNote, onApply } = deps;
     // Lo stato dello scan vive QUI e non nel modello, sul precedente di
@@ -69,7 +69,7 @@ export function useWrapOverlay(deps) {
         if (key.return) {
             const target = path.trim() || WRAP_DEFAULT_PATH;
             close();
-            onApply(target, wrapPrompt(target));
+            onApply(target);
             return;
         }
         if (key.upArrow) {

package/dist/prompt-catalog.js

@@ -16,7 +16,7 @@
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
-import { MODELS } from './spawn.js';
+import { MODELS } from './spawn-catalog.js';
 /** Stessa risalita di `DECK_RUN`: src/ (dev) e dist/ (build) sono entrambi
  *  figli della package root, quindi il sibling è un livello sopra. */
 export const PROMPT_CATALOG = join(dirname(fileURLToPath(import.meta.url)), '..', 'scripts', 'prompt-catalog');

package/dist/sane-note.js

@@ -0,0 +1,115 @@
+// T161 — il gemello TypeScript di `_sane_note`, la riduzione che `deck-run`
+// applica a ogni nota del titolo.
+//
+// Perché serve un gemello. La nota del titolo è l'UNICO ingresso di testo libero
+// nel titolo di una tab, quindi `deck-run` non la quota: la RIDUCE a una
+// whitelist chiusa di code point, e tutto ciò che non ci rientra sparisce senza
+// errore. Finché la nota nasceva da un campo scritto al volo, la divergenza fra
+// quello che si legge nel deck e quello che compare nella tab durava il tempo di
+// uno spawn. Da quando un TEMPLATE del titolo si scrive in una pagina e si salva
+// su disco, quella divergenza diventa permanente: il file direbbe una cosa e la
+// tab ne mostrerebbe un'altra, per sempre e senza un errore da nessuna parte.
+//
+// La riduzione si applica quindi QUI, al confine — al salvataggio e alla
+// lettura del blocco `spawn` — così quello che sta nel file è quello che la tab
+// mostrerà.
+//
+// L'ALLINEAMENTO fra i due lati non è assunto: `test/sane-note.test.ts` passa la
+// stessa batteria di input a questa funzione e a `deck-run` vero (via lo shim
+// `ptyxis` di `deck-run.test.ts`) e pretende l'uguaglianza. La whitelist non si
+// allarga — e se un giorno lo facesse, sono tre le sedi da toccare insieme
+// (`deck-run`, questo file, le emoji dei titoli in `spawn-catalog.ts`), col test
+// che fallisce se una resta indietro.
+/**
+ * L'alfabeto ammesso, negato: lettere, cifre, spazio, `_`, `-`, le accentate
+ * italiane e sei emoji.
+ *
+ * Whitelist e non blacklist, come in bash: il titolo finisce dentro apici
+ * singoli in `bash -lc "claude --name '…'"`, ed enumerare i caratteri pericolosi
+ * significa sbagliarne uno.
+ *
+ * Le sei emoji sono nominate una per una e NON come intervallo di code point,
+ * per due ragioni che valgono su entrambi i lati: un'emoji arriva nella tab solo
+ * se il deck la mostra identica in lista, cioè se `sanitize` (`src/width.ts`) la
+ * lascia passare invece di renderla `·`, e quel verdetto si verifica un glifo
+ * alla volta; e l'ordine di un intervallo dentro un bracket expression segue la
+ * collazione della locale, non i code point.
+ *
+ * Il flag `u` non è cosmetico: senza, le quattro emoji astrali entrerebbero
+ * nella classe come coppie di surrogati sciolti, e la riduzione lascerebbe
+ * passare mezzo carattere di qualunque altra emoji che ne condivida il primo.
+ */
+const OUT_OF_ALPHABET = /[^A-Za-z0-9 _àèéìòùÀÈÉÌÒÙ📐🚀📊🏁🧹📏-]/gu;
+/** Cap in CARATTERI (code point), non in byte: a byte un taglio a metà di una
+ *  `à` lascerebbe UTF-8 rotto nel titolo. Largo di proposito — una tab che sfora
+ *  tronca a destra da sola, e il limite serve solo a non spingere fuori vista la
+ *  parte del titolo che compass matcha. */
+export const SANE_CAP = 60;
+/** Un buco di template: `{TASK}`, `{slug}`, `{file}`, `{path}`. La cattura nel
+ *  gruppo è ciò che fa comparire i buchi nei dispari di `split`. */
+const HOLE = /(\{[A-Za-z]+\})/;
+/** Spazi collassati, estremi potati, cap: i tre passi che in bash sono `tr -s`,
+ *  i due `${s#/%}` e `${s:0:60}`. */
+function tidy(s) {
+    const squeezed = s.replace(/ +/g, ' ');
+    const trimmed = squeezed.replace(/^ /, '').replace(/ $/, '');
+    return [...trimmed].slice(0, SANE_CAP).join('');
+}
+/**
+ * La nota ridotta, esattamente come la ridurrebbe `deck-run`.
+ *
+ * Si applica al titolo GIÀ interpolato, cioè al testo che finisce nel sidecar e
+ * in `--title-note`: le due superfici che mostrano quel nome — la riga di lista
+ * del deck, che legge la nota grezza dal sidecar, e la tab Ptyxis — devono
+ * vedere la stessa stringa.
+ */
+export function saneNote(raw) {
+    return tidy(raw.replace(OUT_OF_ALPHABET, ''));
+}
+/**
+ * La stessa riduzione, coi BUCHI preservati.
+ *
+ * Le graffe non sono nell'alfabeto: passare un template da `saneNote` lo
+ * ridurrebbe a `📐 slug`, cioè a un titolo che nomina la parola «slug» invece di
+ * interpolare il nome della task. Il template si riduce comunque — è testo
+ * scritto a mano, e il resto della riga deve sopravvivere alla tab — ma i buchi
+ * attraversano intatti e vengono riempiti dopo.
+ *
+ * Fuori dai buchi il comportamento è identico a `saneNote`, compresi collasso
+ * degli spazi, potatura e cap: un template senza buchi passa dalle stesse regole
+ * di una nota qualunque.
+ */
+export function saneTemplate(raw) {
+    return tidy(raw
+        .split(HOLE)
+        .map((part, i) => (i % 2 === 1 ? part : part.replace(OUT_OF_ALPHABET, '')))
+        .join(''));
+}
+/**
+ * Riempie i buchi di un template. `null` quando un buco nominato non ha un
+ * valore da mettere.
+ *
+ * Il `null` non è difensivo, è il comportamento: un titolo `📐 {slug}` su una
+ * task il cui file non si trova diventerebbe `📐` — un prefisso solo, uguale per
+ * ogni task, che è peggio di nessun titolo. Chi chiama riceve `null` e apre la
+ * conversazione senza nota, che è ciò che faceva il vecchio `fallbackTitle`
+ * quando il task file mancava.
+ *
+ * I buchi non dichiarati dall'azione restano LETTERALI e non fanno fallire
+ * l'interpolazione: non sono un valore mancante, sono testo che l'utente ha
+ * scritto — e il giro di riduzione dopo l'interpolazione toglierà le graffe.
+ */
+export function interpolate(template, values) {
+    let missing = false;
+    const filled = template.replace(/\{([A-Za-z]+)\}/g, (whole, name) => {
+        if (!(name in values))
+            return whole;
+        const v = values[name];
+        if (!v) {
+            missing = true;
+            return '';
+        }
+        return v;
+    });
+    return missing ? null : filled;
+}