\n DESK MERCATI / ${\n esc(meta.crumb ?? titolo.toUpperCase())\n }\n ${indici}\n

\n\n

${contenuto}

\n`;\n}\n\n/* --------------------------- componenti --------------------------- */\n\nexport const pannello = (et: string, cnt: string, destra = \"\") =>\n `

${esc(et)}${\n destra ? `${destra}` : \"\"\n }

${cnt}

`;\n\nexport const pannelloNudo = (et: string, cnt: string, destra = \"\") =>\n `

${esc(et)}${\n destra ? `${destra}` : \"\"\n }

${cnt}

`;\n\nexport const cifra = (et: string, vl: string, dl = \"\", colore = \"\") =>\n `

${esc(et)}

${vl}

\n ${dl ? `

${dl}

` : \"\"}

`;\n\nexport const barra = (perc: number, classe = \"b-medio\") =>\n ``;\n\n/** Colore di una barra secondo la scala 0-100 usata dai punteggi. */\nexport const classePunteggio = (v: number | null) =>\n v === null || v === undefined\n ? \"b-basso\"\n : v >= 70\n ? \"b-alto\"\n : v >= 45\n ? \"b-medio\"\n : \"b-basso\";",[194],"05e5c706-a0db-499d-b583-7454aa0605b9","scheda.ts","b2d8c382-ade2-11f1-a338-1607ee4eb77e",133,["D",1789132465877],"/* =====================================================================\n * SCHEDA TITOLO — la vista densa\n * ---------------------------------------------------------------\n * Le schede del design sono realizzate come link con ?vista=, non con\n * JavaScript: le pagine sono generate dal server e servite statiche.\n * Costa un carico in più per cambio scheda, ma tiene il vincolo.\n *\n * La distinzione fatto / stima / assunzione / giudizio IA è resa con\n * quattro colori diversi: era il punto 9 della specifica, e andava\n * risolto nell'interfaccia oltre che nel motore.\n * ===================================================================== */\n\nimport {\n barra,\n cifra,\n classePunteggio,\n esc,\n guscio,\n type Meta,\n num,\n pannello,\n pannelloNudo,\n pct,\n segno,\n} from \"./stile.ts\";\n\nconst VISTE = [\n [\"panoramica\", \"PANORAMICA\"],\n [\"punteggi\", \"PUNTEGGI\"],\n [\"valutazione\", \"VALUTAZIONE\"],\n [\"attese\", \"ATTESE\"],\n [\"criteri\", \"CRITERI\"],\n [\"rischi\", \"RISCHI\"],\n];\n\nconst STRATO: Record = {\n FACT: [\"t-fatto\", \"FATTO\"],\n DERIVED: [\"t-fatto\", \"DERIVATO\"],\n ESTIMATE: [\"t-stima\", \"STIMA\"],\n JUDGMENT: [\"t-ia\", \"GIUDIZIO IA\"],\n};\n\nconst ETICHETTE: Record = {\n valuation: \"Valutazione\",\n businessQuality: \"Qualità del business\",\n growth: \"Crescita\",\n cashFlow: \"Cassa e capitale\",\n financialStrength: \"Solidità finanziaria\",\n moat: \"Vantaggio competitivo\",\n management: \"Management\",\n risk: \"Rischi\",\n};\n\n/* ------------------------------ blocchi --------------------------- */\n\nfunction testa(r: any, f: any, vista: string) {\n const url = (v: string) =>\n `/titolo?symbol=${encodeURIComponent(r.ticker)}&vista=${v}`;\n return `\n

${esc(f?.nome ?? r.ticker)}

\n ${\n esc(r.ticker)\n }${f?.settore ? ` · ${esc(f.settore)}` : \"\"}\n

\n ${num(r.prezzo, 2)}\n \n ${f?.dataPrezzo ? `AL ${esc(f.dataPrezzo)}` : \"\"}\n

\n\n

\n ${\n cifra(\n \"COMPANY SCORE\",\n `${r.companyScore ?? \"—\"}/100`,\n barra(r.companyScore ?? 0, classePunteggio(r.companyScore)),\n \"var(--verde)\",\n )\n }\n ${\n cifra(\n \"INVESTMENT SCORE\",\n `${r.investmentScore ?? \"—\"}/100`,\n barra(r.investmentScore ?? 0, classePunteggio(r.investmentScore)),\n \"var(--blu)\",\n )\n }\n ${\n cifra(\n \"CONFIDENZA\",\n `${r.confidence ?? \"—\"}%`,\n barra(r.confidence ?? 0, \"b-medio\"),\n \"var(--t1)\",\n )\n }\n

\n\n

\n ${\n VISTE.map(([v, et]) =>\n `${et}`\n ).join(\"\")\n }\n

`;\n}\n\nconst verdetto = (r: any) =>\n pannello(\n \"VERDETTO\",\n `\n

\n ${\n esc(r.verdetto)\n }\n = 0 ? \"su\" : \"giu\"\n }\" style=\"font-size:17px;font-weight:600\">\n ${\n r.marginOfSafety === null || r.marginOfSafety === undefined\n ? \"—\"\n : (r.marginOfSafety >= 0 ? \"+\" : \"\") + num(r.marginOfSafety, 1) + \"%\"\n }\n

\n PREZZO ${num(r.prezzo, 2)}\n FAIR VALUE ${\n num(r.fairValue, 2)\n } · MARGINE DI SICUREZZA

`,\n );\n\nconst attese = (r: any) => {\n const a = r.aspettativeMercato ?? {};\n return pannello(\n \"COSA SCONTA IL MERCATO\",\n `\n

Al prezzo di oggi il mercato incorpora una crescita dei ricavi del\n ${\n pct(a.crescitaRicaviImplicita)\n }, contro il\n ${\n pct(a.crescitaRiferimento)\n } effettivamente\n realizzato${a.anniMisurati ? ` su ${esc(a.anniMisurati)} anni` : \"\"}.

Expectation risk ${\n a.expectationRisk === null || a.expectationRisk === undefined\n ? \"—\"\n : Math.round(a.expectationRisk)\n }/100. Questo numero non dipende dalle ipotesi\n di valutazione: esce dal DCF risolto al contrario partendo dal prezzo.

`,\n `DERIVATO`,\n );\n};\n\nfunction criterio(c: any) {\n const [cl, et] = STRATO[c.strato] ?? [\"t-ass\", \"?\"];\n return `\n ${c.score ?? \"—\"}\n ${esc(c.etichetta)}\n ${esc(c.spiega).slice(0, 150)}${\n c.spiega?.length > 150 ? \"…\" : \"\"\n }\n ${et}\n ${esc(c.valoreFormattato ?? \"n/d\")}\n ${\n c.soglie\n ? `0 a ${esc(c.soglie.zeroPunti)} · 100 a ${esc(c.soglie.centoPunti)}`\n : \"\"\n }\n `;\n}\n\n/* ------------------------------ viste ----------------------------- */\n\nfunction vistaPanoramica(r: any, e: any) {\n const gate = (r.gateApplicati ?? []).map((g: any) =>\n `

\n ×${\n esc(g.fattore)\n }\n ${esc(g.nome)}\n

${esc(g.motivo)}

`\n ).join(\"\");\n\n const gruppi = Object.entries(r.sottoPunteggi ?? {}).map(([k, v]: any) =>\n `\n ${esc(ETICHETTE[k] ?? k)}\n ${barra(v ?? 0, classePunteggio(v))}\n ${v === null ? \"—\" : Math.round(v)}`\n ).join(\"\");\n\n return `

\n ${verdetto(r)}\n ${attese(r)}\n ${\n gate\n ? pannello(\n \"PENALIZZAZIONI APPLICATE\",\n `

${gate}

I gate sono\n moltiplicativi sul punteggio base ${\n esc(r.investmentScoreBase ?? \"\")\n }: non si\n compensano con un buon punteggio altrove.

`,\n )\n : \"\"\n }\n

\n ${\n pannelloNudo(\"I SETTE GRUPPI\", `${gruppi}

`)\n }\n ${\n e?.giudizi?.moat?.fonteDelVantaggio\n ? pannello(\n \"DOVE STA IL FOSSATO\",\n `

${esc(e.giudizi.moat.fonteDelVantaggio)}

`,\n `GIUDIZIO IA`,\n )\n : \"\"\n }\n

`;\n}\n\nfunction vistaPunteggi(r: any) {\n const d = r.dettaglio ?? {};\n return Object.keys(ETICHETTE).filter((k) => d[k]).map((k) => {\n const g = d[k];\n return pannelloNudo(\n ETICHETTE[k].toUpperCase(),\n `${\n (g.criteri ?? []).map(criterio).join(\"\")\n }

`,\n `${\n g.score === null ? \"—\" : Math.round(g.score)\n }`,\n );\n }).join(\"\");\n}\n\nfunction vistaValutazione(r: any, e: any) {\n const v = e?.valutazioni;\n const metodi = v\n ? [\n [\"DCF a due stadi\", r.dcf?.valorePerAzione, \"40%\"],\n [\"Multipli storici\", v.storica?.fairValue, \"20%\"],\n [\"Multipli comparabili\", v.relativa?.fairValue, \"30%\"],\n [\"Crescita (Graham)\", v.crescita?.fairValue, \"10%\"],\n ].filter(([, x]) => x !== null && x !== undefined)\n : [];\n\n return `\n

\n ${cifra(\"PREZZO ATTUALE\", num(r.prezzo, 2))}\n ${cifra(\"FAIR VALUE PONDERATO\", num(r.fairValue, 2), \"\", \"var(--blu)\")}\n ${\n cifra(\n \"MARGINE DI SICUREZZA\",\n (r.marginOfSafety >= 0 ? \"+\" : \"\") + num(r.marginOfSafety, 1) + \"%\",\n \"\",\n r.marginOfSafety >= 0 ? \"var(--verde)\" : \"var(--rosso)\",\n )\n }\n

\n ${\n metodi.length\n ? pannelloNudo(\n \"METODOLOGIE E CONTRIBUTO\",\n `\n \n ${\n metodi.map(([n, val, peso]: any) =>\n `\n \n \n `\n ).join(\"\")\n }\n

METODO	VALORE		PESO
${esc(n)}	${\n num(val, 2)\n }	${barra(parseInt(peso), \"b-medio\")}	${esc(peso)}

`,\n )\n : \"\"\n }\n ${\n pannello(\n \"SULLE IPOTESI\",\n `

Il fair value è una stima e dipende dalle\n ipotesi usate: WACC ${pct(r.ipotesiUsate?.wacc ?? 0.09)}, crescita terminale\n ${\n pct(r.ipotesiUsate?.terminalGrowth ?? 0.025)\n }. Si cambiano dall'indirizzo con\n ?wacc= e ?g=

`,\n `STIMA`,\n )\n }\n ${\n v?.note?.length\n ? pannello(\n \"LIMITI\",\n `

${esc(v.note.join(\" · \"))}

`,\n )\n : \"\"\n }`;\n}\n\nfunction vistaAttese(r: any, e: any) {\n const s = e?.scenari;\n if (!s?.scenari?.length) {\n return attese(r) +\n pannello(\n \"SCENARI\",\n `

Non generati: servono i giudizi qualitativi.

`,\n );\n }\n\n const col: Record = {\n bear: \"var(--rosso)\",\n base: \"var(--blu)\",\n bull: \"var(--verde)\",\n };\n return attese(r) + `

${\n s.scenari.map((x: any) => `\n

${\n esc(x.caso).toUpperCase()\n }P ${(x.probabilita * 100).toFixed(0)}%

\n \n \n \n \n

Crescita ricavi	${\n pct(x.crescitaRicavi)\n }
Fair value	${\n num(x.fairValue, 2)\n }
Rendimento	= 0 ? \"su\" : \"giu\"\n }\">${pct(x.upside, 1, true)}

\n ${\n x.condizioni?.length\n ? `

${\n esc(x.condizioni.join(\" · \"))\n }

`\n : \"\"\n }\n

`).join(\"\")\n }

\n ${\n pannello(\n \"VALORE ATTESO\",\n `\n = 0 ? \"su\" : \"giu\"}\"\n style=\"font-size:24px;font-weight:600\">${\n pct(s.rendimentoAtteso, 1, true)\n }\n

Le ipotesi di crescita vengono dal modello,\n il fair value di ogni scenario dal DCF.

\n ${s.avvertenza ? `

${esc(s.avvertenza)}

` : \"\"}`,\n )\n }`;\n}\n\nfunction vistaRischi(r: any, e: any) {\n const g = e?.giudizi;\n if (!g?.rischi?.length) {\n return pannello(\n \"RISCHI\",\n `

Non generati: lo strato dei giudizi\n qualitativi non ha prodotto risultati per questo titolo.

`,\n );\n }\n return pannelloNudo(\n \"RISCHI PRINCIPALI\",\n `\n \n ${\n g.rischi.map((x: any) => {\n const imp = (x.gravita / 10) * x.probabilita;\n return `\n \n \n `;\n }).join(\"\")\n }

RISCHIO	GRAVITÀ	PROBAB.	IMPATTO
${esc(x.nome)}\n ${x.descrizione ? `${esc(x.descrizione)}` : \"\"}\n ${\n x.evidenza\n ? `${\n esc(x.evidenza)\n }`\n : \"\"\n }	= 7\n ? \"var(--rosso)\"\n : x.gravita >= 4\n ? \"var(--giallo)\"\n : \"var(--verde)\"\n }\">${x.gravita}/10	${(x.probabilita * 100).toFixed(0)}%	${\n barra(imp * 100, imp > 0.35 ? \"b-neg\" : \"b-medio\")\n }

`,\n `GIUDIZIO IA`,\n ) +\n (g.scartati?.length\n ? pannello(\n \"GIUDIZI SCARTATI IN VALIDAZIONE\",\n `

${esc(s)}

`,\n )\n : \"\");\n}\n\nfunction vistaCriteri(r: any, e: any) {\n const tutti = Object.values(r.dettaglio ?? {})\n .flatMap((g: any) => g.criteri ?? []) as any[];\n const senzaDato = tutti.filter((c) => c.score === null);\n return `\n ${\n pannello(\n \"COME LEGGERE\",\n `

Ogni criterio porta il valore misurato, le due\n soglie che generano 0 e 100 punti, e l'etichetta di provenienza. Un fair value e un ROIC\n non hanno lo stesso statuto: il primo dipende da ipotesi, il secondo è calcolato su un\n bilancio pubblicato.

\n DERIVATOcalcolato dal codice sui bilanci\n STIMAdipende da ipotesi di modello\n GIUDIZIO IAqualitativo, con evidenza\n

`,\n )\n }\n ${vistaPunteggi(r)}\n ${\n senzaDato.length\n ? pannello(\n \"CRITERI SENZA DATO\",\n `

${esc(c.etichetta)}\n — ${esc(c.nota ?? \"non disponibile\")}

`,\n )\n : \"\"\n }`;\n}\n\n/* ----------------------------- pagina ----------------------------- */\n\nexport function paginaTitolo(\n r: any,\n extra: any = {},\n meta: Meta = {},\n vista = \"panoramica\",\n) {\n const f = extra.facts;\n const corpo = vista === \"punteggi\"\n ? vistaPunteggi(r)\n : vista === \"valutazione\"\n ? vistaValutazione(r, extra)\n : vista === \"attese\"\n ? vistaAttese(r, extra)\n : vista === \"rischi\"\n ? vistaRischi(r, extra)\n : vista === \"criteri\"\n ? vistaCriteri(r, extra)\n : vistaPanoramica(r, extra);\n\n const notizie = vista === \"panoramica\" && extra.notizie?.length\n ? pannelloNudo(\n \"NOTIZIE RECENTI\",\n extra.notizie.slice(0, 5).map((x: any) => `\n

\n ${\n esc(x.titolo)\n }\n

${esc(x.fonte)} · ${esc(x.quando)}

`)\n .join(\"\"),\n )\n : \"\";\n\n return guscio(\n r.ticker ?? \"Titolo\",\n \"ricerca\",\n testa(r, f, vista) + corpo + notizie + `\n

\n ${esc(r.provenienza?.fonte ?? \"\")}${\n r.copertura\n ? ` · COPERTURA ${(r.copertura.quota * 100).toFixed(0)}% SU ${\n esc(r.copertura.esercizi)\n } ESERCIZI`\n : \"\"\n }\n ${\n extra.giudizi?.modelli?.length\n ? ` · GIUDIZI DA ${esc(extra.giudizi.modelli.join(\", \"))}`\n : \"\"\n }\n
NESSUN PUNTEGGIO VIENE DAL MODELLO: L'IA COMPILA SOLO LE VOCI MARCATE GIUDIZIO IA.\n

`,\n { ...meta, crumb: \"RICERCA TITOLI\" },\n );\n}",[201],"d18da447-b84d-4db1-9166-e2aec63f3364","pagine.ts","aabb5d40-ade2-11f1-b374-1607ee4eb77e",130,["D",1789132452917],"/* =====================================================================\n * PAGINE — tutte le viste, sul sistema visivo di stile.ts\n * ---------------------------------------------------------------\n * Sostituisce le funzioni di pagina che stavano sparse in radar.ts,\n * titolo.ts, brief.ts e notizie.ts. Quei moduli restano per la loro\n * logica (generazione del brief, normalizzazione delle notizie); qui\n * c'è solo la resa.\n * ===================================================================== */\n\nimport {\n barra,\n cifra,\n classePunteggio,\n esc,\n guscio,\n type Meta,\n num,\n pannello,\n pannelloNudo,\n pct,\n segno,\n} from \"./stile.ts\";\n\n/* ------------------------------ home ------------------------------ */\n\nexport function paginaHome(s: any = {}, meta: Meta = {}) {\n const cerca = pannello(\n \"ANALIZZA UN TITOLO\",\n `\n \n

Due punteggi separati, cosa sconta\n il mercato, e ogni criterio con le sue soglie.

`,\n );\n\n const brief = s.unaRiga\n ? pannello(\n \"BRIEF DI OGGI\",\n `

${esc(s.unaRiga)}

\n ${\n s.tema\n ? `

${esc(s.tema)}

`\n : \"\"\n }\n

Apri il brief completo →

`,\n )\n : pannello(\n \"BRIEF DI OGGI\",\n `

Non ancora generato.\n Generalo ora →

`,\n );\n\n const radar = s.migliore\n ? pannello(\n \"IN CIMA AL RADAR\",\n `\n

\n ${\n esc(s.migliore.symbol)\n }\n ${\n esc(s.migliore.investmentScore)\n }\n INV. SCORE\n

Apri il radar →

`,\n )\n : pannello(\n \"RADAR\",\n `

Watchlist vuota.\n Aggiungi titoli →

`,\n );\n\n return guscio(\n \"Desk Mercati\",\n \"ricerca\",\n `\n

Desk Mercati

${\n new Date().toLocaleDateString(\"it-IT\", {\n weekday: \"long\",\n day: \"numeric\",\n month: \"long\",\n year: \"numeric\",\n })\n }

\n ${cerca}\n

${brief}${radar}

\n I numeri vengono dal motore, mai dal modello linguistico.

`,\n meta,\n );\n}\n\n/* ------------------------------ brief ----------------------------- */\n\nexport function paginaBrief(brief: any, macro: any, meta: Meta = {}) {\n const ora = brief?.generato\n ? new Date(brief.generato).toLocaleTimeString(\"it-IT\", {\n hour: \"2-digit\",\n minute: \"2-digit\",\n })\n : \"—\";\n\n const celle = Object.values(macro?.voci ?? {}).map((v: any) => {\n const d = v.variazione;\n return `${esc(v.etichetta)}\n ${\n num(v.valore, 2)\n }${v.unita === \"%\" ? \"%\" : \"\"}\n ${\n d === null || d === undefined ? \"—\" : (d >= 0 ? \"+\" : \"\") + num(d, 3)\n }\n ${\n esc(v.data ?? \"\")\n }`;\n }).join(\"\");\n\n const curva = macro?.curva\n ? `\n

\n CURVA 10 MENO 2\n ${\n macro.curva.spread10meno2 >= 0 ? \"+\" : \"\"\n }${num(macro.curva.spread10meno2, 3)}\n ${\n macro.curva.invertita\n ? `INVERTITA`\n : \"\"\n }\n

`\n : \"\";\n\n const lista = (arr: any[], f: (x: any) => string) =>\n `

${f(x)}

`;\n\n return guscio(\n \"Panoramica\",\n \"panoramica\",\n `\n

Panoramica — Caffè & Mercati

${\n new Date().toLocaleDateString(\"it-IT\", {\n weekday: \"long\",\n day: \"numeric\",\n month: \"long\",\n })\n } · brief pronto dalle ${esc(ora)}

\n\n

${\n esc(brief?.unaRiga)\n }

\n\n

\n ${\n pannello(\n \"IL TEMA DI OGGI\",\n `\n

${\n esc(brief?.tema?.titolo)\n }

${esc(brief?.tema?.spiegazione)}

`,\n `GIUDIZIO IA`,\n )\n }\n\n ${\n brief?.successo?.length\n ? pannello(\n \"COSA È SUCCESSO\",\n lista(brief.successo, (x) => `\n

${esc(x.cosa)}

${esc(x.perche)}

\n ${\n x.fonte\n ? `

${esc(x.fonte)}

`\n : \"\"\n }`),\n )\n : \"\"\n }\n\n ${\n brief?.letturaMacro\n ? pannello(\"LETTURA\", `

${esc(brief.letturaMacro)}

`)\n : \"\"\n }\n

\n\n

\n ${\n pannelloNudo(\"I NUMERI\", `${celle}

${curva}`)\n }\n\n ${\n brief?.daGuardare?.length\n ? pannello(\n \"DA GUARDARE\",\n lista(brief.daGuardare, (x) => `\n

${\n esc(x.quando)\n }\n ${esc(x.evento)}

${esc(x.perche)}

`),\n )\n : \"\"\n }\n

\n\n

\n ${esc(brief?.modello ?? \"\")}${\n brief?.fontiConsultate?.length\n ? ` · FONTI: ${esc(brief.fontiConsultate.join(\", \"))}`\n : \"\"\n }
\n I NUMERI MACRO VENGONO DAL MOTORE, NON DAL MODELLO.\n

`,\n { ...meta, crumb: \"PANORAMICA\" },\n );\n}\n\n/* ------------------------------ radar ----------------------------- */\n\nexport function paginaRadar(righe: any[], m: any = {}, meta: Meta = {}) {\n const corpo = righe.length\n ? righe.map((r, i) => {\n if (r.errore) {\n return `${\n String(i + 1).padStart(2, \"0\")\n }${esc(r.symbol)}\n ${\n esc(r.errore)\n }`;\n }\n const mos = r.marginOfSafety;\n return `\n ${\n String(i + 1).padStart(2, \"0\")\n }\n ${esc(r.symbol)}\n ${\n r.investmentScore ?? \"—\"\n }\n ${\n barra(r.investmentScore ?? 0, classePunteggio(r.investmentScore))\n }\n ${r.companyScore ?? \"—\"}\n = 0 ? \"su\" : \"giu\"}\">${\n mos === null || mos === undefined\n ? \"—\"\n : (mos >= 0 ? \"+\" : \"\") + num(mos, 0) + \"%\"\n }\n ${r.confidence ?? \"—\"}\n ${\n esc(r.verdetto)\n }\n `;\n }).join(\"\")\n : `\n Watchlist vuota. Aggiungi un titolo qui sotto.`;\n\n const gestione = pannello(\n \"WATCHLIST\",\n `\n \n ${\n righe.length\n ? `

RIMUOVI:\n ${\n righe.map((r) =>\n `${\n esc(r.symbol)\n }`\n ).join(\" · \")\n }

`\n : \"\"\n }`,\n );\n\n return guscio(\n \"Opportunità\",\n \"opportunita\",\n `\n

Opportunity Radar

${righe.length} titoli ordinati per Investment Score${\n m.aggiornato ? ` · rigenerato alle ${esc(m.aggiornato)}` : \"\"\n }

\n\n ${\n m.avviso\n ? `

${esc(m.avviso)}

`\n : \"\"\n }\n\n ${\n pannelloNudo(\n \"CLASSIFICA\",\n `\n \n \n ${corpo}

#	TITOLO	INV.		SOC.	MARGINE	CONF.	STATO

`,\n )\n }\n\n

\n ${gestione}\n ${\n pannello(\n \"COME NASCE L'ORDINE\",\n `

Ordinato per Investment Score,\n cioè per quanto è interessante comprare al prezzo di oggi — non per quanto è buona\n l'azienda. Le società migliori stanno spesso in fondo: il mercato lo sa già e le\n prezza di conseguenza.

`,\n )\n }\n

`,\n { ...meta, crumb: \"OPPORTUNITÀ\" },\n );\n}\n\n/* ----------------------------- notizie ---------------------------- */\n\nexport function paginaNotizie(notizie: any[], m: any = {}, meta: Meta = {}) {\n const col = (\n s: number,\n ) => (s > 0.15 ? \"var(--verde)\" : s < -0.15 ? \"var(--rosso)\" : \"var(--t3)\");\n\n const corpo = notizie?.length\n ? notizie.slice(0, 20).map((x) => `\n

\n RILEVANZA ${(x.rilevanza * 100).toFixed(0)}%\n ${esc(x.etichetta ?? \"\")}\n

\n ${\n esc(x.titolo)\n }

\n ${esc(x.fonte)} · ${esc(x.quando)}${\n Array.isArray(x.ticker) && x.ticker.length\n ? ` · ${esc(x.ticker.join(\" \"))}`\n : \"\"\n }\n

`).join(\"\")\n : `

${\n esc(\n m.vuoto ?? \"Nessuna notizia. Aggiungi titoli alla watchlist dal radar.\",\n )\n }

`;\n\n return guscio(\n \"Notizie\",\n \"notizie\",\n `\n

Notizie

Filtrate per rilevanza sui titoli che segui${\n m.ticker?.length ? ` · ${esc(m.ticker.join(\" \"))}` : \"\"\n }

\n ${pannelloNudo(\"FLUSSO\", corpo, m.daCache ? \"DALLA CACHE\" : \"\")}\n

Solo titoli e link: il testo\n degli articoli resta sulle fonti.

`,\n { ...meta, crumb: \"NOTIZIE\" },\n );\n}\n\n/* ------------------------------ macro ----------------------------- */\n\nexport function paginaMacro(macro: any, meta: Meta = {}) {\n const righe = Object.values(macro?.voci ?? {}).map((v: any) => `\n

${esc(v.etichetta)}

${num(v.valore, 2)}${\n v.unita === \"%\" ? \"%\" : \"\"\n }

${\n v.variazione === null || v.variazione === undefined\n ? \"—\"\n : (v.variazione >= 0 ? \"+\" : \"\") + num(v.variazione, 3)\n }\n · ${esc(v.data ?? \"\")}

`).join(\"\");\n\n return guscio(\n \"Macro\",\n \"macro\",\n `\n

Macro Desk

Il contesto in cui ogni tesi deve funzionare

${righe}

\n ${\n macro?.curva\n ? pannello(\n \"CURVA DEI TASSI\",\n `\n

\n ${\n macro.curva.spread10meno2 >= 0 ? \"+\" : \"\"\n }${num(macro.curva.spread10meno2, 3)}\n ${\n macro.curva.invertita\n ? `INVERTITA`\n : `NORMALE`\n }\n

Quando i due anni rendono più dei dieci,\n il mercato sta scontando un rallentamento.

`,\n )\n : \"\"\n }\n ${\n macro?.errori?.length\n ? pannello(\n \"NON RECUPERATE\",\n `

${esc(macro.errori.join(\" · \"))}

`,\n )\n : \"\"\n }`,\n { ...meta, crumb: \"MACRO\" },\n );\n}",[208],"a9c8b220-7bea-4eb8-b14d-dc91b6a06fa0","notizie.ts","cceec80a-abc8-11f1-885e-1607ee4eb77e",57,["D",1788901455880],"/* =====================================================================\n * NOTIZIE — flusso per i titoli seguiti\n * ---------------------------------------------------------------\n * NEWS_SENTIMENT accetta più ticker in una sola chiamata: l'intera\n * watchlist costa una richiesta, non una per titolo. È l'unica ragione\n * per cui questa funzione sta dentro un budget da 25 al giorno.\n *\n * Scelta deliberata: si mostrano titolo, fonte, link e i punteggi.\n * Il campo \"summary\" che Alpha Vantage restituisce NON viene\n * riprodotto: è testo dell'editore, e ripubblicarlo per intero sarebbe\n * appropriarsene. Il link porta all'originale, che è dove va letto.\n * ===================================================================== */\n\nconst esc = (s: unknown) =>\n String(s ?? \"\")\n .replace(/&/g, \"&\").replace(//g, \">\");\n\n/** Alpha Vantage marca il tempo come 20260904T133000 */\nfunction quando(t: string) {\n if (!t || t.length < 15) return null;\n const d = new Date(\n `${t.slice(0, 4)}-${t.slice(4, 6)}-${t.slice(6, 8)}T${t.slice(9, 11)}:${\n t.slice(11, 13)\n }:${t.slice(13, 15)}Z`,\n );\n return isNaN(+d) ? null : d;\n}\n\nfunction fa(d: Date | null) {\n if (!d) return \"\";\n const min = Math.round((Date.now() - +d) / 60000);\n if (min < 60) return `${min} min fa`;\n if (min < 1440) return `${Math.round(min / 60)} ore fa`;\n return `${Math.round(min / 1440)} giorni fa`;\n}\n\nexport function normalizzaNotizie(raw: any, soloTicker: string | null = null) {\n const feed = raw?.feed ?? [];\n const out = feed.map((a: any) => {\n const perTicker = (a.ticker_sentiment ?? []).map((t: any) => ({\n ticker: t.ticker,\n rilevanza: Number(t.relevance_score),\n sentiment: Number(t.ticker_sentiment_score),\n etichetta: t.ticker_sentiment_label,\n })).filter((t: any) => isFinite(t.rilevanza));\n\n const mio = soloTicker\n ? perTicker.find((t: any) => t.ticker === soloTicker)\n : null;\n if (soloTicker && !mio) return null;\n\n const d = quando(a.time_published);\n return {\n titolo: a.title,\n url: a.url,\n fonte: a.source,\n data: d ? d.toISOString() : null,\n quando: fa(d),\n sentimentGenerale: Number(a.overall_sentiment_score),\n etichetta: a.overall_sentiment_label,\n // rilevanza 0-1: quanto l'articolo parla davvero di quel titolo\n // invece di nominarlo di sfuggita in una lista\n rilevanza: mio?.rilevanza ??\n Math.max(0, ...perTicker.map((t: any) => t.rilevanza), 0),\n ticker: soloTicker ?? perTicker.slice(0, 4).map((t: any) => t.ticker),\n sentimentTicker: mio?.sentiment ?? null,\n };\n }).filter(Boolean);\n\n out.sort((a: any, b: any) =>\n (b.rilevanza - a.rilevanza) || ((b.data ?? \"\") > (a.data ?? \"\") ? 1 : -1)\n );\n return out;\n}\n\n/** Media del sentiment pesata per rilevanza: le citazioni di sfuggita contano poco. */\nexport function umore(notizie: any[]) {\n const v = notizie.filter((x) =>\n isFinite(x.sentimentTicker ?? x.sentimentGenerale)\n );\n if (!v.length) return null;\n let num = 0, den = 0;\n for (const x of v) {\n const p = Math.max(0.05, x.rilevanza || 0.05);\n num += (x.sentimentTicker ?? x.sentimentGenerale) * p;\n den += p;\n }\n const s = num / den;\n return {\n punteggio: +s.toFixed(3),\n etichetta: s > 0.15 ? \"positivo\" : s < -0.15 ? \"negativo\" : \"neutro\",\n articoli: v.length,\n };\n}\n\n/* ------------------------------ blocchi ---------------------------- */\n\nconst colore = (s: number) => (s > 0.15 ? \"up\" : s < -0.15 ? \"dn\" : \"\");\n\nexport function bloccoNotizie(notizie: any[], titolo = \"Notizie\") {\n if (!notizie?.length) return \"\";\n const u = umore(notizie);\n return `

${esc(titolo)}${u ? ` · umore ${esc(u.etichetta)}` : \"\"}

\n ${\n notizie.slice(0, 8).map((x) =>\n `

${\n esc(x.titolo)\n }

\n ${esc(x.fonte)} · ${esc(x.quando)}\n ${\n Array.isArray(x.ticker) && x.ticker.length\n ? ` · ${esc(x.ticker.join(\" \"))}`\n : \"\"\n }\n · rilevanza ${(x.rilevanza * 100).toFixed(0)}%\n ${\n esc(x.etichetta ?? \"\")\n }\n

`\n ).join(\"\")\n }\n

Solo titoli e link: il testo degli articoli resta sulle fonti.

`;\n}\n\nexport function paginaNotizie(notizie: any[], meta: any = {}) {\n const oggi = new Date().toLocaleDateString(\"it-IT\", {\n day: \"numeric\",\n month: \"long\",\n });\n return `\n\n\n\n\n\nNotizie · ${esc(oggi)}\n\n\n

NOTIZIE

\n ${esc(oggi)}\n \n

\n${\n notizie?.length\n ? bloccoNotizie(notizie, \"Sui titoli che segui\")\n : `

Nessuna notizia. ${\n meta.vuoto ?? \"Aggiungi titoli alla watchlist dal radar.\"\n }

`\n }\n

${esc(meta.ticker?.join(\" \") ?? \"\")}${\n meta.daCache ? \" · dalla cache\" : \"\"\n } · fonte Alpha Vantage

`;\n}",[215],"a39c893a-d2f1-4730-838a-c2ae8ad04e00","main.ts",["D",1789132642565],26,"http","/* =====================================================================\n * desk-api — servizio FACTS su Val Town\n * ---------------------------------------------------------------\n * Val di tipo HTTP. Espone i bilanci normalizzati al desk.\n *\n * INSTALLAZIONE (due incolla, nessuna modifica al codice)\n * 1. Crea UN val con questi file:\n * facts.ts normalizzazione dei bilanci\n * engine.js calcoli e punteggi\n * criteri.js registro dei criteri\n * judgments.js prompt e validazione dei giudizi\n * valutazione.ts metodi di valutazione non-DCF\n * giudizi.ts strato qualitativo su Gemini\n * brief.ts generazione del brief\n * notizie.ts normalizzazione notizie e sentiment\n * stile.ts token e guscio visivo\n * pagine.ts home, brief, radar, notizie, macro\n * scheda.ts scheda titolo\n * main.ts questo file, di tipo HTTP\n * cron.ts di tipo Cron, alle 5:00 UTC\n * 2. Environment Variables -> aggiungi:\n * ALPHAVANTAGE_KEY (alphavantage.co/support/#api-key)\n * TWELVEDATA_KEY (twelvedata.com, per il motore prezzi)\n * GEMINI_API_KEY (aistudio.google.com, senza carta)\n * 3. Una modifica qualsiasi al codice forza il redeploy: senza, la\n * chiave appena salvata non raggiunge gli isolate già avviati.\n *\n * ROTTE\n * GET / home\n * GET /radar watchlist ordinata per Investment Score\n * GET /notizie notizie sui titoli seguiti, con sentiment\n *\n * CAMPIONE A LOTTI: i parametri si passano UNA VOLTA sola, al primo\n * lancio. Vengono memorizzati, e le chiamate successive senza parametri\n * riprendono la stessa configurazione fino a completarla. Per passare a\n * una configurazione diversa basta rilanciare con i nuovi parametri.\n * GET /titolo?symbol=AAPL scheda completa, pagina da leggere\n * GET /brief quadro mattutino, pagina da leggere\n * GET /brief.json lo stesso in JSON\n * GET /macro quadro macro: tassi, curva, inflazione, petrolio\n * GET /analizza?symbol=AAPL analisi completa: due punteggi e criteri\n * GET /facts?symbol=AAPL bilanci normalizzati + copertura\n * GET /quote?symbol=AAPL solo il prezzo, cache breve\n * GET /budget quante richieste restano oggi\n *\n * Il piano gratuito Alpha Vantage dà 25 richieste al giorno e una\n * scheda completa ne consuma 5. Senza un contatore le bruci in dieci\n * minuti di prove e passi il resto della giornata a leggere errori\n * che sembrano bug del codice. Per questo il budget è qui dentro.\n * ===================================================================== */\n\n// Entrambe le righe servono. Non modificarne nessuna: il file facts.ts\n// sta nello stesso val, quindi l'import è relativo e non serve username.\nimport { sqlite } from \"https://esm.town/v/std/sqlite\";\nimport {\n controllaRisposta,\n copertura,\n normalizzaAlphaVantage,\n} from \"./facts.ts\";\nimport { valuta } from \"./engine.js\";\nimport { generaBrief } from \"./brief.ts\";\nimport {\n paginaBrief,\n paginaHome,\n paginaMacro,\n paginaNotizie,\n paginaRadar,\n} from \"./pagine.ts\";\nimport { paginaTitolo } from \"./scheda.ts\";\nimport { generaGiudizi, scenariCalcolati, TTL_GIUDIZI } from \"./giudizi.ts\";\n\nimport {\n PROMPT_PEERS,\n valutazioneCrescita,\n valutazioneRelativa,\n valutazioneStorica,\n} from \"./valutazione.ts\";\nimport { chiamaGemini, diagnostica } from \"./brief.ts\";\nimport { normalizzaNotizie, umore } from \"./notizie.ts\";\n\nconst AV = \"https://www.alphavantage.co/query\";\nconst BUDGET_GIORNALIERO = 25; // piano gratuito Alpha Vantage\nconst PAUSA_MS = 1200; // AV free: max 1 richiesta al secondo\nconst TENTATIVI = 2;\nconst GIORNO = 864e5;\n\nconst TTL = {\n OVERVIEW: 7 * GIORNO,\n INCOME_STATEMENT: 45 * GIORNO, // i bilanci cambiano 4 volte l'anno\n BALANCE_SHEET: 45 * GIORNO,\n CASH_FLOW: 45 * GIORNO,\n GLOBAL_QUOTE: 1 * GIORNO,\n TIME_SERIES_MONTHLY_ADJUSTED: 20 * GIORNO, // serve solo lo storico\n};\n\n// Le serie macro hanno frequenze diverse e vanno messe in cache di\n// conseguenza: chiedere il CPI ogni mattina significa spendere budget per\n// riottenere lo stesso numero per tre settimane.\nconst MACRO = [\n {\n id: \"treasury10\",\n fn: \"TREASURY_YIELD\",\n args: { interval: \"daily\", maturity: \"10year\" },\n ttl: 0.5 * GIORNO,\n etichetta: \"Treasury 10 anni\",\n unita: \"%\",\n },\n {\n id: \"treasury2\",\n fn: \"TREASURY_YIELD\",\n args: { interval: \"daily\", maturity: \"2year\" },\n ttl: 0.5 * GIORNO,\n etichetta: \"Treasury 2 anni\",\n unita: \"%\",\n },\n {\n id: \"fedFunds\",\n fn: \"FEDERAL_FUNDS_RATE\",\n args: { interval: \"monthly\" },\n ttl: 10 * GIORNO,\n etichetta: \"Tasso Fed\",\n unita: \"%\",\n },\n {\n id: \"cpi\",\n fn: \"CPI\",\n args: { interval: \"monthly\" },\n ttl: 15 * GIORNO,\n etichetta: \"Indice prezzi al consumo\",\n unita: \"indice\",\n },\n {\n id: \"disoccupazione\",\n fn: \"UNEMPLOYMENT\",\n args: {},\n ttl: 15 * GIORNO,\n etichetta: \"Disoccupazione USA\",\n unita: \"%\",\n },\n {\n id: \"wti\",\n fn: \"WTI\",\n args: { interval: \"daily\" },\n ttl: 0.5 * GIORNO,\n etichetta: \"Petrolio WTI\",\n unita: \"$\",\n },\n];\n\n/* ------------------------------ schema ---------------------------- */\n\nlet pronto = false;\nasync function init() {\n if (pronto) return;\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS cache (\n chiave TEXT PRIMARY KEY, payload TEXT NOT NULL, t INTEGER NOT NULL)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS consumo (\n giorno TEXT PRIMARY KEY, richieste INTEGER NOT NULL DEFAULT 0)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS watchlist (\n symbol TEXT PRIMARY KEY, aggiunto INTEGER NOT NULL)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS brief (\n giorno TEXT PRIMARY KEY, brief TEXT NOT NULL, macro TEXT NOT NULL, t INTEGER NOT NULL)`);\n pronto = true;\n}\n\nconst oggi = () => new Date().toISOString().slice(0, 10);\nconst pausa = (ms: number) => new Promise((r) => setTimeout(r, ms));\n\nasync function usateOggi() {\n const r = await sqlite.execute({\n sql: \"SELECT richieste FROM consumo WHERE giorno = ?\",\n args: [oggi()],\n });\n return r.rows.length ? Number(r.rows[0][0]) : 0;\n}\n\nasync function segnaRichiesta() {\n await sqlite.execute({\n sql: `INSERT INTO consumo (giorno, richieste) VALUES (?, 1)\n ON CONFLICT(giorno) DO UPDATE SET richieste = richieste + 1`,\n args: [oggi()],\n });\n}\n\n/* ------------------------------ cache ----------------------------- */\n\nasync function leggiCache(chiave, ttl) {\n const r = await sqlite.execute({\n sql: \"SELECT payload, t FROM cache WHERE chiave = ?\",\n args: [chiave],\n });\n if (!r.rows.length) return null;\n const [payload, t] = r.rows[0];\n if (Date.now() - Number(t) > ttl) return null;\n try {\n return JSON.parse(String(payload));\n } catch {\n return null;\n }\n}\n\nasync function scriviCache(chiave, valore) {\n await sqlite.execute({\n sql: `INSERT INTO cache (chiave, payload, t) VALUES (?, ?, ?)\n ON CONFLICT(chiave) DO UPDATE SET payload = excluded.payload, t = excluded.t`,\n args: [chiave, JSON.stringify(valore), Date.now()],\n });\n}\n\n/* --------------------------- Alpha Vantage ------------------------ */\n\n/* ----------------------------- notizie ---------------------------- */\n\n/**\n * Una sola chiamata per tutti i ticker richiesti. Sei ore di cache:\n * più corta e si brucia budget, più lunga e il flusso invecchia.\n */\nasync function notiziePer(tickers: string[], topics: string | null = null) {\n if (!tickers.length && !topics) return { notizie: [], daCache: false };\n const lista = [...new Set(tickers.map((t) => t.toUpperCase()))].sort();\n const chiave = topics ? `news:topics:${topics}` : `news:${lista.join(\",\")}`;\n\n const cached = await leggiCache(chiave, 6 * 3600e3);\n if (cached) return { grezzo: cached, daCache: true };\n\n const usate = await usateOggi();\n if (usate >= BUDGET_GIORNALIERO) {\n throw new Error(`BUDGET_ESAURITO: ${usate}/${BUDGET_GIORNALIERO}`);\n }\n\n const key = Deno.env.get(\"ALPHAVANTAGE_KEY\");\n if (!key) throw new Error(\"ALPHAVANTAGE_KEY non configurata\");\n\n const q = new URLSearchParams({\n function: \"NEWS_SENTIMENT\",\n sort: \"LATEST\",\n limit: \"50\",\n apikey: key,\n ...(topics ? { topics } : { tickers: lista.join(\",\"), sort: \"RELEVANCE\" }),\n });\n const res = await fetch(`${AV}?${q}`);\n if (!res.ok) throw new Error(`NEWS_SENTIMENT: HTTP ${res.status}`);\n const grezzo = controllaRisposta(await res.json(), \"NEWS_SENTIMENT\");\n await segnaRichiesta();\n await scriviCache(chiave, grezzo);\n return { grezzo, daCache: false };\n}\n\n/* ------------------------------ radar ----------------------------- */\n\nasync function watchlist(): Promise {\n const r = await sqlite.execute(\n \"SELECT symbol FROM watchlist ORDER BY aggiunto\",\n );\n return r.rows.map((x: any) => String(x[0]));\n}\n\n/**\n * Un titolo che fallisce non fa cadere il radar: finisce in lista con il\n * suo errore. Con un budget da 25 richieste è normale che l'ultimo della\n * watchlist resti fuori, e vederlo scritto è meglio di una pagina vuota.\n */\nasync function rottaRadar() {\n const simboli = await watchlist();\n const righe: any[] = [];\n let avviso: string | null = null;\n\n for (const symbol of simboli) {\n try {\n const base = await rottaFacts(symbol);\n const rep = valuta(base.facts, {}, { wacc: 0.09, terminalGrowth: 0.025 });\n righe.push({\n symbol,\n companyScore: rep.companyScore,\n investmentScore: rep.investmentScore,\n confidence: rep.confidence,\n verdetto: rep.verdetto,\n marginOfSafety: rep.marginOfSafety,\n crescitaImplicita: rep.aspettativeMercato?.crescitaRicaviImplicita ??\n null,\n crescitaRiferimento: rep.aspettativeMercato?.crescitaRiferimento ??\n null,\n });\n } catch (e) {\n const msg = String((e as Error)?.message ?? e);\n righe.push({ symbol, errore: msg.slice(0, 120) });\n if (msg.startsWith(\"BUDGET_ESAURITO\")) {\n avviso =\n \"Budget Alpha Vantage esaurito: i titoli rimasti verranno valutati domani. Quelli già in cache restano aggiornati.\";\n break;\n }\n }\n }\n\n righe.sort((a, b) => (b.investmentScore ?? -1) - (a.investmentScore ?? -1));\n return {\n righe,\n meta: {\n avviso,\n aggiornato: new Date().toLocaleTimeString(\"it-IT\", {\n hour: \"2-digit\",\n minute: \"2-digit\",\n }),\n budgetUsato: await usateOggi(),\n budgetTotale: BUDGET_GIORNALIERO,\n },\n };\n}\n\n/* ------------------------------ brief ----------------------------- */\n\nasync function leggiBrief(giorno = oggi()) {\n const r = await sqlite.execute({\n sql: \"SELECT brief, macro FROM brief WHERE giorno = ?\",\n args: [giorno],\n });\n if (!r.rows.length) return null;\n try {\n return {\n brief: JSON.parse(String(r.rows[0][0])),\n macro: JSON.parse(String(r.rows[0][1])),\n };\n } catch {\n return null;\n }\n}\n\n/**\n * Genera il brief e lo salva. Lo chiama il cron alle 5:00 UTC; se per\n * qualche motivo non è girato, /brief lo genera al volo alla prima\n * apertura. Esportata perché cron.ts la richiama.\n */\nexport async function aggiornaBrief() {\n await init();\n const macro = await rottaMacro();\n\n // I titoli macro sostituiscono il grounding: una richiesta, fonti\n // tracciabili, nessuna dipendenza dalla quota di Google Search.\n let notizie: any[] = [];\n try {\n const { grezzo } = await notiziePer(\n [],\n \"financial_markets,economy_macro,economy_monetary\",\n );\n notizie = grezzo ? normalizzaNotizie(grezzo).slice(0, 25) : [];\n } catch { /* il brief resta valido sui soli numeri */ }\n\n const brief = await generaBrief(macro, notizie);\n await sqlite.execute({\n sql: `INSERT INTO brief (giorno, brief, macro, t) VALUES (?, ?, ?, ?)\n ON CONFLICT(giorno) DO UPDATE SET brief = excluded.brief,\n macro = excluded.macro, t = excluded.t`,\n args: [oggi(), JSON.stringify(brief), JSON.stringify(macro), Date.now()],\n });\n return { brief, macro };\n}\n\n/**\n * Una chiamata AV con cache e contabilità del budget.\n * Se la cache è valida non consuma nulla: è l'unica ragione per cui\n * un piano da 25 richieste al giorno può reggere una watchlist vera.\n */\nasync function chiamaAV(funzione: string, symbol: string) {\n const chiave = `${funzione}:${symbol.toUpperCase()}`;\n const cached = await leggiCache(chiave, TTL[funzione] ?? GIORNO);\n if (cached) return { dati: cached, daCache: true };\n\n const usate = await usateOggi();\n if (usate >= BUDGET_GIORNALIERO) {\n throw new Error(\n `BUDGET_ESAURITO: ${usate}/${BUDGET_GIORNALIERO} richieste usate oggi. ` +\n `I dati già in cache restano disponibili; il budget si azzera a mezzanotte UTC.`,\n );\n }\n\n const key = Deno.env.get(\"ALPHAVANTAGE_KEY\");\n if (!key) {\n throw new Error(\n \"ALPHAVANTAGE_KEY non configurata nelle variabili d'ambiente\",\n );\n }\n\n const q = new URLSearchParams({ function: funzione, symbol, apikey: key });\n let ultimoErrore: unknown = null;\n\n for (let tentativo = 1; tentativo <= TENTATIVI; tentativo++) {\n const res = await fetch(`${AV}?${q}`);\n if (!res.ok) throw new Error(`${funzione}: HTTP ${res.status}`);\n try {\n // il conteggio avviene solo qui: una risposta di rate limit non\n // consuma quota reale e non deve consumare nemmeno il nostro budget\n const dati = controllaRisposta(await res.json(), funzione);\n await segnaRichiesta();\n await scriviCache(chiave, dati);\n return { dati, daCache: false };\n } catch (e) {\n ultimoErrore = e;\n const msg = String((e as Error)?.message ?? e);\n if (!msg.startsWith(\"RATE_LIMIT\") || tentativo === TENTATIVI) throw e;\n await pausa(PAUSA_MS * 2 * tentativo); // attesa crescente\n }\n }\n throw ultimoErrore;\n}\n\n/** Le funzioni macro non accettano symbol: prendono interval e maturity. */\nasync function chiamaMacro(voce: typeof MACRO[number]) {\n const chiave = `macro:${voce.id}`;\n const cached = await leggiCache(chiave, voce.ttl);\n if (cached) return { dati: cached, daCache: true };\n\n const usate = await usateOggi();\n if (usate >= BUDGET_GIORNALIERO) {\n throw new Error(`BUDGET_ESAURITO: ${usate}/${BUDGET_GIORNALIERO}`);\n }\n\n const key = Deno.env.get(\"ALPHAVANTAGE_KEY\");\n if (!key) throw new Error(\"ALPHAVANTAGE_KEY non configurata\");\n\n const q = new URLSearchParams({\n function: voce.fn,\n apikey: key,\n ...voce.args,\n });\n const res = await fetch(`${AV}?${q}`);\n if (!res.ok) throw new Error(`${voce.fn}: HTTP ${res.status}`);\n const dati = controllaRisposta(await res.json(), voce.fn);\n await segnaRichiesta();\n await scriviCache(chiave, dati);\n return { dati, daCache: false };\n}\n\n/**\n * Quadro macro. Ogni voce riporta l'ultimo valore, il precedente e la\n * variazione: un numero senza il suo movimento non dice niente.\n * Le voci che falliscono non fanno cadere l'intera risposta.\n */\nasync function rottaMacro() {\n const voci: Record = {};\n const errori: string[] = [];\n let scaricate = 0;\n\n for (let i = 0; i < MACRO.length; i++) {\n const v = MACRO[i];\n try {\n const { dati, daCache } = await chiamaMacro(v);\n if (!daCache) {\n scaricate++;\n if (i < MACRO.length - 1) await pausa(PAUSA_MS);\n }\n\n const serie = (dati as any).data ?? [];\n const validi = serie.filter((r: any) =>\n r.value !== \".\" && r.value !== undefined\n );\n const ultimo = validi[0], precedente = validi[1];\n const nUlt = ultimo ? Number(ultimo.value) : null;\n const nPre = precedente ? Number(precedente.value) : null;\n\n voci[v.id] = {\n etichetta: v.etichetta,\n unita: v.unita,\n valore: nUlt,\n data: ultimo?.date ?? null,\n precedente: nPre,\n variazione: nUlt !== null && nPre !== null\n ? +(nUlt - nPre).toFixed(3)\n : null,\n daCache,\n };\n } catch (e) {\n errori.push(\n `${v.id}: ${String((e as Error)?.message ?? e).slice(0, 80)}`,\n );\n }\n }\n\n // L'inclinazione della curva è il numero macro più guardato: quando i\n // due anni rendono più dei dieci, il mercato sconta un rallentamento.\n const t10 = (voci.treasury10 as any)?.valore,\n t2 = (voci.treasury2 as any)?.valore;\n const curva =\n t10 !== null && t10 !== undefined && t2 !== null && t2 !== undefined\n ? { spread10meno2: +(t10 - t2).toFixed(3), invertita: t10 < t2 }\n : null;\n\n return {\n generato: new Date().toISOString(),\n voci,\n curva,\n errori,\n provenienza: {\n fonte: \"Alpha Vantage\",\n scaricate,\n budgetUsatoOggi: await usateOggi(),\n budgetGiornaliero: BUDGET_GIORNALIERO,\n },\n };\n}\n\nasync function rottaFacts(symbol: string) {\n const funzioni = [\n \"OVERVIEW\",\n \"INCOME_STATEMENT\",\n \"BALANCE_SHEET\",\n \"CASH_FLOW\",\n \"GLOBAL_QUOTE\",\n ];\n const esiti: Array<{ dati: any; daCache: boolean }> = [];\n\n // In sequenza, non in parallelo: il piano gratuito accetta una\n // richiesta al secondo e cinque chiamate simultanee lo violano sempre.\n // La pausa si salta quando il dato arriva dalla cache.\n for (let i = 0; i < funzioni.length; i++) {\n const esito = await chiamaAV(funzioni[i], symbol);\n esiti.push(esito);\n if (!esito.daCache && i < funzioni.length - 1) await pausa(PAUSA_MS);\n }\n\n const [overview, income, balance, cashflow, quote] = esiti.map((e) => e.dati);\n const facts = normalizzaAlphaVantage({\n overview,\n income,\n balance,\n cashflow,\n quote,\n });\n const cov = copertura(facts);\n\n return {\n facts,\n copertura: cov,\n provenienza: {\n fonte: \"Alpha Vantage\",\n daCache: esiti.filter((e) => e.daCache).length,\n scaricate: esiti.filter((e) => !e.daCache).length,\n budgetUsatoOggi: await usateOggi(),\n budgetGiornaliero: BUDGET_GIORNALIERO,\n limiteStorico: cov.esercizi >= 11\n ? `${cov.esercizi} esercizi disponibili: i CAGR fino a 10 anni sono calcolabili`\n : `${cov.esercizi} esercizi disponibili: i CAGR oltre ${\n Math.max(0, cov.esercizi - 1)\n } anni non sono calcolabili`,\n },\n };\n}\n\n/** I giudizi cambiano lentamente: un mese di cache, due chiamate a Gemini. */\nasync function giudiziPerTicker(report: any, facts: any, forza = false) {\n const chiave = `giudizi:${report.ticker}`;\n if (!forza) {\n const c = await leggiCache(chiave, TTL_GIUDIZI);\n if (c) return { ...c, daCache: true };\n }\n const g = await generaGiudizi(report, facts);\n await scriviCache(chiave, g);\n return { ...g, daCache: false };\n}\n\n/** Comparabili proposti dal modello, in cache tre mesi: cambiano di rado. */\nasync function comparabili(ticker: string, nome: string, settore: string) {\n const chiave = `peers:${ticker}`;\n const c = await leggiCache(chiave, 90 * GIORNO);\n if (c) return c;\n const r = await chiamaGemini(PROMPT_PEERS(ticker, nome, settore));\n const lista = (r.brief?.peers ?? []).filter((x: any) => typeof x === \"string\")\n .slice(0, 6);\n const v = { peers: lista, criterio: r.brief?.criterio ?? null };\n await scriviCache(chiave, v);\n return v;\n}\n\n/**\n * I tre metodi non-DCF. Ognuno può fallire da solo senza compromettere\n * gli altri: blendedFairValue ripesa su quelli disponibili, quindi\n * un metodo assente non falsa il risultato, lo rende solo meno robusto.\n */\nasync function altreValutazioni(\n facts: any,\n metricheProvvisorie: any,\n conPeers: boolean,\n) {\n const out: any = { storica: null, relativa: null, crescita: null, note: [] };\n\n try {\n const serie =\n (await chiamaAV(\"TIME_SERIES_MONTHLY_ADJUSTED\", facts.ticker)).dati;\n out.storica = valutazioneStorica(facts, metricheProvvisorie, serie);\n if (!out.storica) {\n out.note.push(\n \"valutazione storica: meno di quattro esercizi accoppiabili con un prezzo\",\n );\n }\n } catch (e) {\n out.note.push(\n `valutazione storica non disponibile: ${\n String((e as Error)?.message ?? e).slice(0, 90)\n }`,\n );\n }\n\n if (conPeers) {\n try {\n const { peers, criterio } = await comparabili(\n facts.ticker,\n facts.nome,\n facts.settore,\n );\n const overview: any[] = [];\n for (const p of peers) {\n try {\n overview.push((await chiamaAV(\"OVERVIEW\", p)).dati);\n await pausa(PAUSA_MS);\n } catch { /* salta */ }\n }\n out.relativa = valutazioneRelativa(metricheProvvisorie, overview);\n out.criterioPeers = criterio;\n if (!out.relativa) {\n out.note.push(\n \"valutazione relativa: comparabili insufficienti o senza multipli validi\",\n );\n }\n } catch (e) {\n out.note.push(\n `comparabili non recuperati: ${\n String((e as Error)?.message ?? e).slice(0, 90)\n }`,\n );\n }\n }\n\n out.crescita = valutazioneCrescita(\n metricheProvvisorie,\n metricheProvvisorie.crescitaRiferimento,\n );\n return out;\n}\n\nasync function rottaAnalizza(symbol: string, url: URL, conGiudizi = false) {\n const base = await rottaFacts(symbol);\n const numero = (k: string, d: number) => {\n const v = Number(url.searchParams.get(k));\n return Number.isFinite(v) && v > 0 ? v : d;\n };\n const ipotesi = {\n wacc: numero(\"wacc\", 0.09),\n terminalGrowth: numero(\"g\", 0.025),\n settoreCiclico: url.searchParams.get(\"ciclico\") === \"true\",\n };\n\n // Primo passaggio: serve per avere le metriche derivate, che gli altri\n // metodi di valutazione usano come input.\n let report = valuta(base.facts, {}, ipotesi);\n\n const altre = await altreValutazioni(\n base.facts,\n report.metriche,\n url.searchParams.get(\"peers\") !== \"false\",\n );\n Object.assign(ipotesi, {\n fairValueStorico: altre.storica?.fairValue ?? null,\n fairValueRelativo: altre.relativa?.fairValue ?? null,\n fairValueGrowthAdj: altre.crescita?.fairValue ?? null,\n percentileRelativo: altre.relativa?.percentilePe ??\n altre.storica?.percentilePe ?? null,\n });\n report = valuta(base.facts, {}, ipotesi);\n let giudizi: any = null, scenari: any = null;\n\n if (conGiudizi) {\n try {\n giudizi = await giudiziPerTicker(\n report,\n base.facts,\n url.searchParams.get(\"rigenera\") === \"true\",\n );\n report = valuta(base.facts, {\n moat: giudizi.moat,\n management: giudizi.management,\n rischi: giudizi.rischi,\n }, {\n ...ipotesi,\n settoreCiclico: ipotesi.settoreCiclico || giudizi.settoreCiclico,\n });\n scenari = scenariCalcolati(\n base.facts,\n report.metriche,\n giudizi.scenariIpotesi,\n ipotesi,\n );\n } catch (e) {\n giudizi = {\n errore: String((e as Error)?.message ?? e).slice(0, 200),\n scartati: [],\n };\n }\n }\n\n let notizie: any[] = [];\n if (url.searchParams.get(\"notizie\") !== \"false\") {\n try {\n const { grezzo } = await notiziePer([symbol]);\n notizie = grezzo\n ? normalizzaNotizie(grezzo, symbol.toUpperCase()).slice(0, 8)\n : [];\n } catch { /* la scheda vale anche senza notizie */ }\n }\n\n return {\n giudizi,\n scenari,\n valutazioni: altre,\n notizie,\n umore: umore(notizie),\n ticker: report.ticker,\n companyScore: report.companyScore,\n investmentScore: report.investmentScore,\n confidence: report.confidence,\n verdetto: report.verdetto,\n prezzo: report.prezzo,\n fairValue: report.fairValue,\n marginOfSafety: report.marginOfSafety,\n aspettativeMercato: report.aspettativeMercato,\n gateApplicati: report.gateApplicati,\n sottoPunteggi: report.sottoPunteggi,\n dettaglio: report.dettaglio,\n ipotesiUsate: {\n ...ipotesi,\n nota: \"modificabili via querystring: ?wacc=0.08&g=0.02\",\n },\n gruppiSenzaDato: [\"moat\", \"management\", \"risk\"].filter(\n (k) => report.sottoPunteggi[k] === null,\n ),\n copertura: base.copertura,\n provenienza: base.provenienza,\n facts: base.facts,\n };\n}\n\n/** Dati che la barra laterale e quella superiore mostrano su ogni pagina. */\nasync function metaGuscio() {\n const usate = await usateOggi();\n const m = await leggiCache(\"macro:treasury10\", 30 * GIORNO).catch(() => null);\n return {\n quota: {\n usati: usate,\n totale: BUDGET_GIORNALIERO,\n etichetta: \"ALPHA VANTAGE\",\n },\n aggiornato:\n new Date().toLocaleTimeString(\"it-IT\", {\n hour: \"2-digit\",\n minute: \"2-digit\",\n }) + \" CET\",\n indici: [] as any[],\n _t10: m,\n };\n}\n\nconst CORS = {\n \"Access-Control-Allow-Origin\": \"*\",\n \"Access-Control-Allow-Methods\": \"GET, OPTIONS\",\n \"Access-Control-Allow-Headers\": \"Content-Type\",\n};\n\nconst json = (body: unknown, status = 200) =>\n new Response(JSON.stringify(body, null, 2), {\n status,\n headers: { \"Content-Type\": \"application/json; charset=utf-8\", ...CORS },\n });\n\nconst html = (corpo: string) =>\n new Response(corpo, {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n });\n\nexport default async function (req: Request): Promise {\n if (req.method === \"OPTIONS\") return new Response(null, { headers: CORS });\n await init();\n\n const url = new URL(req.url);\n const symbol = (url.searchParams.get(\"symbol\") || \"\").trim().toUpperCase();\n\n try {\n switch (url.pathname) {\n case \"/budget\": {\n const usate = await usateOggi();\n return json({\n usate,\n budget: BUDGET_GIORNALIERO,\n residue: BUDGET_GIORNALIERO - usate,\n schedeComplete: Math.floor((BUDGET_GIORNALIERO - usate) / 5),\n });\n }\n case \"/quote\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n const { dati, daCache } = await chiamaAV(\"GLOBAL_QUOTE\", symbol);\n return json({ quote: dati[\"Global Quote\"] ?? null, daCache });\n }\n case \"/brief\": {\n const forza = url.searchParams.get(\"rigenera\") === \"true\";\n const salvato = forza ? null : await leggiBrief();\n const { brief, macro } = salvato ?? await aggiornaBrief();\n return html(paginaBrief(brief, macro, await metaGuscio()));\n }\n case \"/brief.json\": {\n const salvato = await leggiBrief();\n return json(salvato ?? await aggiornaBrief());\n }\n case \"/gemini\":\n return json({\n scopo: \"quali modelli accetta davvero la tua chiave\",\n esiti: await diagnostica(),\n comeLeggere:\n \"FUNZIONA = usabile. quotaValore 0 = il modello esiste ma è fuori dal piano gratuito. 404 = non disponibile per questa chiave. Metti il primo che funziona come MODELLO in brief.ts.\",\n });\n case \"/macro\":\n return url.searchParams.get(\"json\") === \"true\"\n ? json(await rottaMacro())\n : html(paginaMacro(await rottaMacro(), await metaGuscio()));\n case \"/\": {\n const b = await leggiBrief();\n const w = await watchlist();\n let migliore = null;\n if (w.length) {\n try {\n const r = await rottaRadar();\n migliore = r.righe.find((x: any) => !x.errore) ?? null;\n } catch { /* la home resta utile anche senza radar */ }\n }\n return html(\n paginaHome({\n unaRiga: b?.brief?.unaRiga,\n tema: b?.brief?.tema?.titolo,\n migliore,\n }, await metaGuscio()),\n );\n }\n\n case \"/notizie\": {\n const richiesti = symbol ? [symbol] : await watchlist();\n const g = await metaGuscio();\n try {\n const { grezzo, daCache } = await notiziePer(richiesti);\n const n = grezzo ? normalizzaNotizie(grezzo, symbol || null) : [];\n return html(paginaNotizie(n, { ticker: richiesti, daCache }, g));\n } catch (e) {\n return html(\n paginaNotizie([], {\n ticker: richiesti,\n vuoto: String((e as Error)?.message ?? e).slice(0, 160),\n }, g),\n );\n }\n }\n case \"/radar\": {\n const { righe, meta } = await rottaRadar();\n return html(paginaRadar(righe, meta, await metaGuscio()));\n }\n case \"/radar/aggiungi\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n await sqlite.execute({\n sql:\n \"INSERT INTO watchlist (symbol, aggiunto) VALUES (?, ?) ON CONFLICT(symbol) DO NOTHING\",\n args: [symbol, Date.now()],\n });\n return Response.redirect(new URL(\"/radar\", url).toString(), 303);\n }\n case \"/radar/rimuovi\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n await sqlite.execute({\n sql: \"DELETE FROM watchlist WHERE symbol = ?\",\n args: [symbol],\n });\n return Response.redirect(new URL(\"/radar\", url).toString(), 303);\n }\n case \"/titolo\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n const r = await rottaAnalizza(\n symbol,\n url,\n url.searchParams.get(\"giudizi\") !== \"false\",\n );\n return html(paginaTitolo(\n r,\n {\n facts: r.facts,\n giudizi: r.giudizi,\n scenari: r.scenari,\n valutazioni: r.valutazioni,\n notizie: r.notizie,\n },\n await metaGuscio(),\n url.searchParams.get(\"vista\") ?? \"panoramica\",\n ));\n }\n case \"/analizza\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n const r = await rottaAnalizza(\n symbol,\n url,\n url.searchParams.get(\"giudizi\") === \"true\",\n );\n const { facts: _, ...pulito } = r; // i bilanci grezzi stanno su /facts\n return json(pulito);\n }\n case \"/facts\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n return json(await rottaFacts(symbol));\n }\n case \"/rotte\":\n default:\n return json({\n rotte: [\n \"/\",\n \"/radar\",\n \"/notizie\",\n \"/gemini\",\n \"/titolo?symbol=\",\n \"/brief\",\n \"/macro\",\n \"/analizza?symbol=\",\n \"/facts?symbol=\",\n \"/quote?symbol=\",\n \"/budget\",\n ],\n });\n }\n } catch (e) {\n const msg = String(e?.message ?? e);\n const status = msg.startsWith(\"BUDGET_ESAURITO\")\n ? 429\n : msg.startsWith(\"RATE_LIMIT\")\n ? 429\n : 500;\n return json({ errore: msg }, status);\n }\n}",[222],"7e75aeed-a812-4a1d-8af3-17599245048c","judgments.js","6204d386-abb9-11f1-8c9a-1607ee4eb77e",48,["D",1788900908496],5,"/* =====================================================================\n * STRATO JUDGMENT — la parte che l'AI ha il permesso di decidere\n * ---------------------------------------------------------------\n * Tre principi, in ordine di importanza:\n *\n * 1. L'AI non produce mai un numero che il codice possa calcolare.\n * Riceve le metriche già derivate e le commenta. Per gli scenari\n * fornisce le IPOTESI (crescita, margine); il fair value lo calcola\n * dcf() qui sotto. Se l'AI restituisce un fair value viene scartato.\n *\n * 2. Ogni giudizio richiede un'evidenza. Senza evidenza il punteggio\n * è null, non una stima. Un null abbassa la copertura e quindi la\n * confidence: l'ignoranza costa, l'invenzione no. Va evitato che\n * convenga inventare.\n *\n * 3. Le ancore della rubrica sono descritte in termini osservabili,\n * non in aggettivi. \"7 = documentabile nei numeri\" si può contestare\n * guardando i dati; \"7 = buono\" no.\n * ===================================================================== */\n\nimport { dcf } from \"./engine.js\";\nimport { MANAGEMENT_VOCI, MOAT_FATTORI } from \"./criteri.js\";\n\n/* ------------------------------ rubrica ---------------------------- */\n\nexport const ANCORE = `0 = nessuna evidenza del fattore, o evidenza contraria\n3 = presente ma debole: un concorrente con capitale lo aggira in pochi anni\n5 = reale ma non decisivo: rallenta i concorrenti, non li ferma\n7 = solido e visibile nei numeri (potere di prezzo, ritenzione, quote stabili)\n10 = dominante e confermato da più anni di dati; replicarlo richiederebbe\n anni e capitale enorme`;\n\nexport const REGOLE_COMUNI = `REGOLE VINCOLANTI\n- Rispondi SOLO con JSON valido. Nessun testo prima o dopo, niente backtick.\n- Ogni punteggio richiede il campo \"evidenza\": un fatto verificabile, max 15 parole.\n- Se non hai evidenza, metti punteggio null ed evidenza null. Non stimare.\n Un null è un esito accettabile e previsto; un numero inventato no.\n- Non calcolare né riportare prezzi, fair value, multipli o CAGR: quei numeri\n ti vengono forniti già calcolati e ricalcolarli introduce solo errori.\n- Italiano, asciutto, niente entusiasmo commerciale.`;\n\n/* -------------------------- digest numerico ------------------------ *\n * All'AI si passa questo, non i bilanci grezzi. Meno token, e soprattutto\n * nessuna tentazione di riderivare numeri che il codice ha già. */\n\nexport function costruisciDigest(report) {\n const m = report.metriche,\n p = (\n x,\n d = 1,\n ) => (x === null || x === undefined ? \"n/d\" : (x * 100).toFixed(d) + \"%\");\n const q = (\n x,\n d = 2,\n ) => (x === null || x === undefined ? \"n/d\" : x.toFixed(d));\n return `AZIENDA: ${report.ticker}\nCompany Score ${report.companyScore}/100 (calcolato dal motore, non da te)\n\nREDDITIVITA\n ROIC medio pluriennale ${\n p(m.roicMedio5 ?? m.roicMedio3)\n } | persistenza sopra il costo del capitale ${p(m.roicPersistenza)}\n margine lordo ${p(m.margineLordo[0])} | operativo ${\n p(m.margineOper[0])\n } | cassa libera ${p(m.margineFcf[0])}\n stabilita del margine operativo (dev.std 5 anni) ${p(m.stabilitaMargini)}\nCRESCITA\n ricavi periodo lungo ${\n p(m.crescitaRiferimento)\n } su ${m.ricaviCagrAnni} anni | ricavi 3 anni ${p(m.ricaviCagr3)}\n utile per azione ${\n p(m.epsCagr5 ?? m.epsCagr3)\n } | variazione azioni in circolazione ${p(m.azioniCagr3)}\n variazione margine operativo su 5 anni ${p(m.deltaMargineOper5)}\nSOLIDITA\n Altman Z'' ${q(m.altmanZBook)} | Piotroski ${\n m.piotroskiF ?? \"n/d\"\n }/9 | Beneish M ${q(m.beneishM)}\n debito netto/EBITDA ${q(m.netDebtEbitda)} | copertura interessi ${\n q(m.interestCoverage)\n }\n conversione utili in cassa ${q(m.conversioneUtili)}\nASPETTATIVE GIA NEL PREZZO\n crescita ricavi implicita ${\n p(report.aspettativeMercato.crescitaRicaviImplicita)\n }\n crescita realizzata di riferimento ${\n p(report.aspettativeMercato.crescitaRiferimento)\n }\nDATI\n ${m.esercizi} esercizi disponibili`;\n}\n\n/* ------------------------------ prompt 1 --------------------------- */\n\nexport function promptQualita(report, nome, settore) {\n const fattori = Object.entries(MOAT_FATTORI).map(([k, v]) => ` ${k}: ${v}`)\n .join(\"\\n\");\n const voci = Object.entries(MANAGEMENT_VOCI).map(([k, v]) => ` ${k}: ${v}`)\n .join(\"\\n\");\n return `${costruisciDigest(report)}\n\nValuta il vantaggio competitivo e il management di ${nome ?? report.ticker}${\n settore ? ` (${settore})` : \"\"\n }.\nCerca sul web fatti recenti e verificabili. I numeri qui sopra sono gia calcolati: usali come contesto.\n\nSCALA 0-10 PER OGNI VOCE\n${ANCORE}\n\nFATTORI DI VANTAGGIO COMPETITIVO\n${fattori}\n\nVOCI SUL MANAGEMENT\n${voci}\n\n${REGOLE_COMUNI}\n\nJSON richiesto:\n{\n \"moat\": {\n \"fattori\": { \"\": 0 },\n \"evidenze\": { \"\": \"fatto verificabile, max 15 parole\" },\n \"trend\": \"UP\" | \"FLAT\" | \"DOWN\",\n \"trendPerche\": \"max 20 parole\",\n \"durabilita\": \"Low\" | \"Medium\" | \"High\" | \"Exceptional\",\n \"fonteDelVantaggio\": \"max 30 parole: da cosa nasce davvero\"\n },\n \"management\": {\n \"trackRecord\": 0, \"capitalAllocation\": 0, \"guidanceRispettate\": 0,\n \"insiderAllineamento\": 0, \"sbcRagionevole\": 0,\n \"evidenze\": { \"\": \"fatto verificabile, max 15 parole\" }\n }\n}\nIncludi solo i fattori per cui hai evidenza. Omettere un fattore e preferibile a inventarlo.`;\n}\n\n/* ------------------------------ prompt 2 --------------------------- */\n\nexport function promptRischiScenari(report, nome) {\n return `${costruisciDigest(report)}\n\nPer ${nome ?? report.ticker} produci i rischi e le IPOTESI dei tre scenari.\n\nSUI RISCHI\nNon elencare categorie generiche. Ogni rischio deve essere specifico di questa\nazienda e deve dichiarare quanto comprometterebbe la tesi.\n gravita 0-10 = danno alla tesi se si materializza\n probabilita 0-1 = quanto e verosimile nei prossimi 3 anni\n\nSUGLI SCENARI\nFornisci solo le ipotesi. Il fair value di ogni scenario lo calcola il motore\ncon un DCF: se lo scrivi tu viene scartato.\nLe probabilita devono sommare a 1. Il caso base deve essere il piu probabile.\nLe condizioni sono cio che deve accadere perche lo scenario si realizzi.\n\n${REGOLE_COMUNI}\n\nJSON richiesto:\n{\n \"rischi\": [\n { \"nome\": \"max 6 parole\", \"descrizione\": \"max 25 parole, specifico\",\n \"gravita\": 0, \"probabilita\": 0.0, \"evidenza\": \"max 15 parole\" }\n ],\n \"scenari\": [\n { \"caso\": \"bear\" | \"base\" | \"bull\",\n \"crescitaRicavi\": 0.0,\n \"margineFcfTarget\": 0.0,\n \"probabilita\": 0.0,\n \"condizioni\": [\"cosa deve accadere, max 12 parole\"] }\n ],\n \"settoreCiclico\": true | false\n}\nDa 3 a 5 rischi. Esattamente 3 scenari.`;\n}\n\n/* ------------------------------ prompt 3 --------------------------- *\n * Va lanciato DOPO che il motore ha prodotto i punteggi definitivi:\n * la narrativa spiega numeri esistenti, non li anticipa. */\n\nexport function promptNarrativa(report, scenari) {\n const gate = report.gateApplicati.length\n ? report.gateApplicati.map((g) =>\n ` ${g.nome} (x${g.fattore}): ${g.motivo}`\n ).join(\"\\n\")\n : \" nessuno\";\n const sc = scenari.scenari.map((s) =>\n ` ${s.caso}: fair value ${s.fairValue?.toFixed(2) ?? \"n/d\"}, probabilita ${\n (s.probabilita * 100).toFixed(0)\n }%`\n ).join(\"\\n\");\n return `Risultati gia calcolati per ${report.ticker}. Il tuo compito e spiegarli,\nnon ricalcolarli. Ogni numero che citi deve comparire qui sotto.\n\nCompany Score ${report.companyScore}/100 | Investment Score ${report.investmentScore}/100 (base ${report.investmentScoreBase})\nConfidence ${report.confidence}/100 | Verdetto ${report.verdetto}\nPrezzo ${report.prezzo} | Fair value ${\n report.fairValue?.toFixed(2) ?? \"n/d\"\n } | Margine di sicurezza ${report.marginOfSafety?.toFixed(1) ?? \"n/d\"}%\nCrescita implicita nel prezzo ${\n (report.aspettativeMercato.crescitaRicaviImplicita * 100)?.toFixed(1)\n }% contro ${\n (report.aspettativeMercato.crescitaRiferimento * 100)?.toFixed(1)\n }% realizzato\nPenalizzazioni applicate:\n${gate}\nScenari:\n${sc}\n\n${REGOLE_COMUNI}\n\nJSON richiesto:\n{\n \"perche\": [\"3-5 ragioni del rating, ognuna max 25 parole, ancorate ai numeri sopra\"],\n \"rischiChiave\": [\"3-5 rischi, max 20 parole ciascuno\"],\n \"aspettativeMercato\": \"max 60 parole: cosa deve accadere perche il prezzo di oggi sia giustificato\",\n \"tesi\": \"max 80 parole: la tesi d'investimento, con il rendimento atteso rispetto al rischio\",\n \"cosaCiFarebbeCambiareIdea\": [\"3-4 eventi o metriche osservabili, max 20 parole ciascuno\"]\n}`;\n}\n\n/* --------------------------- validazione --------------------------- */\n\nconst clamp10 = (\n x,\n) => (typeof x === \"number\" && isFinite(x)\n ? Math.min(10, Math.max(0, x))\n : null);\nconst parolaValida = (s) => typeof s === \"string\" && s.trim().length > 3;\n\n/**\n * Applica la regola \"niente evidenza, niente punteggio\" e scarta i campi\n * che l'AI non ha il diritto di riempire.\n */\nexport function validaQualita(raw) {\n const scartati = [];\n const moatIn = raw?.moat ?? {};\n const ev = moatIn.evidenze ?? {};\n const fattori = {}, evidenze = {};\n\n for (const [k, v] of Object.entries(moatIn.fattori ?? {})) {\n if (!(k in MOAT_FATTORI)) {\n scartati.push(`moat.${k}: fattore non previsto`);\n continue;\n }\n const s = clamp10(v);\n if (s === null) {\n scartati.push(`moat.${k}: punteggio non numerico`);\n continue;\n }\n if (!parolaValida(ev[k])) {\n scartati.push(`moat.${k}: punteggio ${s} senza evidenza`);\n continue;\n }\n fattori[k] = s;\n evidenze[k] = String(ev[k]).trim();\n }\n\n const trend =\n { UP: \"\\u2191\", FLAT: \"\\u2192\", DOWN: \"\\u2193\" }[moatIn.trend] ?? \"\\u2192\";\n const durabilita =\n [\"Low\", \"Medium\", \"High\", \"Exceptional\"].includes(moatIn.durabilita)\n ? moatIn.durabilita\n : \"Medium\";\n\n const mgIn = raw?.management ?? {};\n const mgEv = mgIn.evidenze ?? {};\n const management = {};\n for (const k of Object.keys(MANAGEMENT_VOCI)) {\n const s = clamp10(mgIn[k]);\n if (s === null) continue;\n if (!parolaValida(mgEv[k])) {\n scartati.push(`management.${k}: punteggio ${s} senza evidenza`);\n continue;\n }\n management[k] = s;\n }\n\n return {\n moat: {\n fattori,\n evidenze,\n trend,\n durabilita,\n trendPerche: moatIn.trendPerche ?? null,\n fonteDelVantaggio: moatIn.fonteDelVantaggio ?? null,\n },\n management: { ...management, evidenze: mgEv },\n scartati,\n };\n}\n\nexport function validaRischiScenari(raw) {\n const scartati = [];\n\n const rischi = (raw?.rischi ?? []).filter((r) => {\n const ok = typeof r?.gravita === \"number\" &&\n typeof r?.probabilita === \"number\";\n if (!ok) {\n scartati.push(\n `rischio \"${r?.nome ?? \"?\"}\": gravita o probabilita mancanti`,\n );\n }\n return ok;\n }).map((r) => ({\n nome: r.nome,\n descrizione: r.descrizione ?? null,\n gravita: Math.min(10, Math.max(0, r.gravita)),\n probabilita: Math.min(1, Math.max(0, r.probabilita)),\n evidenza: parolaValida(r.evidenza) ? r.evidenza : null,\n }));\n\n const scenari = (raw?.scenari ?? []).filter((s) => {\n const ok = typeof s?.crescitaRicavi === \"number\" &&\n typeof s?.probabilita === \"number\";\n if (!ok) scartati.push(`scenario \"${s?.caso ?? \"?\"}\": ipotesi incomplete`);\n return ok;\n }).map((s) => {\n // il fair value non è di competenza dell'AI: se c'è, sparisce\n if (s.fairValue !== undefined || s.valore !== undefined) {\n scartati.push(\n `scenario \"${s.caso}\": fair value fornito dall'AI, scartato`,\n );\n }\n return {\n caso: s.caso,\n crescitaRicavi: s.crescitaRicavi,\n margineFcfTarget: typeof s.margineFcfTarget === \"number\"\n ? s.margineFcfTarget\n : null,\n probabilita: Math.min(1, Math.max(0, s.probabilita)),\n condizioni: Array.isArray(s.condizioni) ? s.condizioni : [],\n };\n });\n\n return {\n rischi,\n scenari,\n settoreCiclico: raw?.settoreCiclico === true,\n scartati,\n };\n}\n\n/* ------------------------- scenari, calcolati ---------------------- */\n\n/**\n * Il DCF gira una volta per scenario con le ipotesi dell'AI.\n * Il fair value atteso è la media pesata per probabilità: è il numero\n * che risponde a \"quanto mi aspetto di guadagnare tenendo conto del rischio\".\n */\nexport function calcolaScenari(facts, m, scenari, ipotesi = {}) {\n const y0 = facts.anni?.[0] ?? {};\n const base = {\n ricavi: y0.ricavi,\n margineFcf: m.margineFcf[0],\n wacc: ipotesi.wacc ?? 0.09,\n terminalGrowth: ipotesi.terminalGrowth ?? 0.025,\n debitoNetto: m.debitoNetto,\n azioni: y0.azioni,\n };\n\n const calcolati = scenari.map((s) => {\n const r = dcf({\n ...base,\n crescita: s.crescitaRicavi,\n margineTarget: s.margineFcfTarget,\n });\n const fv = r?.valorePerAzione ?? null;\n return {\n ...s,\n fairValue: fv,\n upside: fv !== null && facts.prezzo\n ? (fv - facts.prezzo) / facts.prezzo\n : null,\n quotaTerminal: r?.quotaTerminal ?? null,\n };\n });\n\n const somma = calcolati.reduce((a, s) => a + s.probabilita, 0);\n const rinormalizzata = Math.abs(somma - 1) > 0.01;\n const norm = calcolati.map((s) => ({\n ...s,\n probabilita: somma > 0 ? s.probabilita / somma : 0,\n }));\n\n const conFv = norm.filter((s) => s.fairValue !== null);\n const fairValueAtteso = conFv.length\n ? conFv.reduce((a, s) => a + s.fairValue * s.probabilita, 0) /\n conFv.reduce((a, s) => a + s.probabilita, 0)\n : null;\n\n return {\n scenari: norm,\n fairValueAtteso,\n rendimentoAtteso: fairValueAtteso !== null && facts.prezzo\n ? (fairValueAtteso - facts.prezzo) / facts.prezzo\n : null,\n probabilitaRinormalizzata: rinormalizzata,\n avvertenza: rinormalizzata\n ? `le probabilità fornite sommavano a ${\n somma.toFixed(2)\n }, sono state rinormalizzate`\n : null,\n };\n}\n\n/* --------------------------- stabilità ----------------------------- *\n * Anche con temperature 0 due esecuzioni possono divergere. Per i\n * giudizi che contano conviene la mediana di più passaggi: costa tre\n * chiamate ma rende il punteggio difendibile. */\n\nexport function medianaGiudizi(esiti) {\n const mediana = (arr) => {\n const v = arr.filter((x) => typeof x === \"number\").sort((a, b) => a - b);\n if (!v.length) return null;\n const i = Math.floor(v.length / 2);\n return v.length % 2 ? v[i] : (v[i - 1] + v[i]) / 2;\n };\n const chiavi = new Set(\n esiti.flatMap((e) => Object.keys(e.moat?.fattori ?? {})),\n );\n const fattori = {}, dispersione = {};\n for (const k of chiavi) {\n const valori = esiti.map((e) => e.moat?.fattori?.[k]).filter((x) =>\n typeof x === \"number\"\n );\n fattori[k] = mediana(valori);\n dispersione[k] = valori.length > 1\n ? Math.max(...valori) - Math.min(...valori)\n : 0;\n }\n return { fattori, dispersione, passaggi: esiti.length };\n}",[229],"2eb896c9-4ad5-4a3c-ac71-e0a186f6506a","giudizi.ts","ce85bfe0-abc6-11f1-9e35-1607ee4eb77e",45,["D",1788900591280],"/* =====================================================================\n * GIUDIZI — lo strato qualitativo, eseguito su Gemini\n * ---------------------------------------------------------------\n * Riempie i tre gruppi che il motore non può calcolare: moat,\n * management e rischi. Le regole restano quelle di judgments.js:\n * niente evidenza, niente punteggio; e il fair value degli scenari\n * lo calcola il DCF, non il modello.\n *\n * I giudizi cambiano lentamente — un vantaggio competitivo non si\n * sposta in una settimana — quindi restano in cache un mese. È anche\n * ciò che li rende sostenibili: due chiamate a Gemini per titolo.\n * ===================================================================== */\n\nimport { chiamaGemini } from \"./brief.ts\";\nimport {\n calcolaScenari,\n promptQualita,\n promptRischiScenari,\n validaQualita,\n validaRischiScenari,\n} from \"./judgments.js\";\n\nexport const TTL_GIUDIZI = 30 * 864e5;\n\n/**\n * @param report l'esito di valuta() senza giudizi: serve il digest numerico\n * @returns giudizi validati, scarti dichiarati, scenari con fair value calcolato\n */\nexport async function generaGiudizi(report: any, facts: any) {\n const nome = facts?.nome ?? report.ticker;\n const settore = facts?.settore ?? null;\n const scartati: string[] = [];\n const modelliUsati: string[] = [];\n\n // 1. moat e management\n let qualita: any = { moat: { fattori: {} }, management: {} };\n try {\n const r = await chiamaGemini(promptQualita(report, nome, settore));\n modelliUsati.push(r.modello);\n const v = validaQualita(r.brief);\n qualita = v;\n scartati.push(...v.scartati);\n } catch (e) {\n scartati.push(\n `qualita non generata: ${\n String((e as Error)?.message ?? e).slice(0, 120)\n }`,\n );\n }\n\n // 2. rischi e ipotesi degli scenari\n let rischi: any[] = [], scenariIpotesi: any[] = [], ciclico = false;\n try {\n const r = await chiamaGemini(promptRischiScenari(report, nome));\n modelliUsati.push(r.modello);\n const v = validaRischiScenari(r.brief);\n rischi = v.rischi;\n scenariIpotesi = v.scenari;\n ciclico = v.settoreCiclico;\n scartati.push(...v.scartati);\n } catch (e) {\n scartati.push(\n `rischi e scenari non generati: ${\n String((e as Error)?.message ?? e).slice(0, 120)\n }`,\n );\n }\n\n return {\n generato: new Date().toISOString(),\n modelli: [...new Set(modelliUsati)],\n moat: qualita.moat,\n management: qualita.management,\n rischi,\n scenariIpotesi,\n settoreCiclico: ciclico,\n scartati,\n };\n}\n\n/** Gli scenari passano dal DCF: il modello dà le ipotesi, il codice il valore. */\nexport function scenariCalcolati(\n facts: any,\n metriche: any,\n ipotesi: any[],\n opzioni: any,\n) {\n if (!ipotesi?.length) return null;\n return calcolaScenari(facts, metriche, ipotesi, opzioni);\n}",[237],"82bb2ff6-9c9e-40b3-ac01-8d1783be5644","facts.ts","5ead4cd6-ab91-11f1-8805-1607ee4eb77e",11,["D",1788879199392],3,"/* =====================================================================\n * STRATO FACTS — adattatore dati grezzi\n * ---------------------------------------------------------------\n * Trasforma le risposte Alpha Vantage nello schema che engine.js\n * si aspetta. Nessun numero viene inventato o stimato qui: se un\n * campo manca resta null e la copertura scende.\n *\n * Host-agnostico: non usa window, fetch globale o storage globale.\n * Riceve `fetch` e `store` come dipendenze, così gira identico in\n * Val Town, in un Cloudflare Worker, in Node o nel browser.\n * ===================================================================== */\n\nconst AV = \"https://www.alphavantage.co/query\";\n\n/* --------------------------------------------------------------------\n * Mappatura esplicita dei campi. Sta qui in chiaro apposta: se un\n * punteggio sembra sbagliato, questo è il primo posto da guardare.\n * ------------------------------------------------------------------ */\nexport const MAPPA = {\n income: {\n ricavi: \"totalRevenue\",\n utileLordo: \"grossProfit\",\n ebit: \"ebit\", // fallback: operatingIncome\n ebitda: \"ebitda\",\n utileNetto: \"netIncome\",\n sga: \"sellingGeneralAndAdministrative\",\n oneriFinanziari: \"interestExpense\",\n tasse: \"incomeTaxExpense\",\n },\n balance: {\n attivoTot: \"totalAssets\",\n attivoCorrente: \"totalCurrentAssets\",\n passivoTot: \"totalLiabilities\",\n passivoCorrente: \"totalCurrentLiabilities\",\n crediti: \"currentNetReceivables\",\n immobilizzazioni: \"propertyPlantEquipment\",\n utiliRiportati: \"retainedEarnings\",\n debitoLordo: \"shortLongTermDebtTotal\", // fallback: currentDebt+longTermDebt\n debitoLungo: \"longTermDebt\",\n cassa: \"cashAndCashEquivalentsAtCarryingValue\",\n patrimonioNetto: \"totalShareholderEquity\",\n azioni: \"commonStockSharesOutstanding\",\n },\n cashflow: {\n cfo: \"operatingCashflow\",\n capex: \"capitalExpenditures\",\n ammortamenti: \"depreciationDepletionAndAmortization\",\n dividendi: \"dividendPayout\",\n buyback: \"paymentsForRepurchaseOfCommonStock\",\n },\n};\n\n/* --------------------------------------------------------------------\n * Alpha Vantage restituisce tutto come stringa e usa \"None\" per i\n * valori mancanti. Senza questa conversione Number(\"None\") = NaN\n * si propaga silenziosamente in tutto il motore.\n * ------------------------------------------------------------------ */\nexport function num(v) {\n if (v === null || v === undefined) return null;\n if (typeof v === \"number\") return isFinite(v) ? v : null;\n const s = String(v).trim();\n if (s === \"\" || s === \"None\" || s === \"-\" || s === \"N/A\" || s === \"null\") {\n return null;\n }\n const x = Number(s.replace(/,/g, \"\"));\n return isFinite(x) ? x : null;\n}\n\n/** Alpha Vantage segnala i limiti con Note/Information invece di un HTTP 429. */\nexport function controllaRisposta(j, endpoint) {\n if (!j || typeof j !== \"object\") {\n throw new Error(`${endpoint}: risposta non valida`);\n }\n if (j.Note) {\n throw new Error(`RATE_LIMIT: ${endpoint} — quota giornaliera esaurita`);\n }\n if (j.Information) {\n throw new Error(\n `RATE_LIMIT: ${endpoint} — ${String(j.Information).slice(0, 220)}`,\n );\n }\n if (j[\"Error Message\"]) {\n throw new Error(`${endpoint}: simbolo non riconosciuto`);\n }\n return j;\n}\n\nfunction estrai(riga, mappa) {\n const out = {};\n for (const [nostro, loro] of Object.entries(mappa)) {\n out[nostro] = num(riga?.[loro]);\n }\n return out;\n}\n\n/* --------------------------------------------------------------------\n * I tre prospetti hanno array separati e non sempre lo stesso numero\n * di esercizi. Vanno uniti su fiscalDateEnding, mai per indice.\n * ------------------------------------------------------------------ */\nexport function normalizzaAlphaVantage(\n { overview, income, balance, cashflow, quote },\n) {\n const perData = new Map();\n\n const assorbi = (reports, mappa) => {\n for (const r of reports || []) {\n const d = r.fiscalDateEnding;\n if (!d) continue;\n if (!perData.has(d)) perData.set(d, { esercizio: d });\n Object.assign(perData.get(d), estrai(r, mappa));\n }\n };\n\n assorbi(income?.annualReports, MAPPA.income);\n assorbi(balance?.annualReports, MAPPA.balance);\n assorbi(cashflow?.annualReports, MAPPA.cashflow);\n\n // fallback e correzioni di segno, per esercizio\n const perIncome = new Map(\n (income?.annualReports || []).map((r) => [r.fiscalDateEnding, r]),\n );\n const perBalance = new Map(\n (balance?.annualReports || []).map((r) => [r.fiscalDateEnding, r]),\n );\n\n for (const [d, a] of perData) {\n const ri = perIncome.get(d), rb = perBalance.get(d);\n\n if (a.ebit === null) a.ebit = num(ri?.operatingIncome);\n if (a.ebitda === null && a.ebit !== null && a.ammortamenti !== null) {\n a.ebitda = a.ebit + a.ammortamenti;\n }\n if (a.utileLordo === null && a.ricavi !== null) {\n const cogs = num(ri?.costOfRevenue) ??\n num(ri?.costofGoodsAndServicesSold);\n if (cogs !== null) a.utileLordo = a.ricavi - cogs;\n }\n if (a.debitoLordo === null) {\n const bt = num(rb?.currentDebt), lt = num(rb?.longTermDebt);\n if (bt !== null || lt !== null) a.debitoLordo = (bt || 0) + (lt || 0);\n }\n if (a.debitoLungo === null) a.debitoLungo = num(rb?.longTermDebtNoncurrent);\n if (a.cassa === null) a.cassa = num(rb?.cashAndShortTermInvestments);\n\n // capex e oneri finanziari: il motore li vuole in valore assoluto\n if (a.capex !== null) a.capex = Math.abs(a.capex);\n if (a.oneriFinanziari !== null) {\n a.oneriFinanziari = Math.abs(a.oneriFinanziari);\n }\n if (a.buyback !== null) a.buyback = Math.abs(a.buyback);\n }\n\n // dal più recente al più vecchio: è l'ordine che engine.js assume\n const anni = [...perData.values()].sort((a, b) =>\n b.esercizio.localeCompare(a.esercizio)\n );\n\n // le azioni in circolazione mancano spesso negli esercizi vecchi:\n // per l'anno corrente si può ripiegare sull'overview\n if (anni[0] && anni[0].azioni === null) {\n anni[0].azioni = num(overview?.SharesOutstanding);\n }\n\n const prezzo = num(quote?.[\"Global Quote\"]?.[\"05. price\"]) ?? null;\n const capitalizzazione = num(overview?.MarketCapitalization) ??\n (prezzo !== null && anni[0]?.azioni ? prezzo * anni[0].azioni : null);\n\n return {\n ticker: overview?.Symbol ?? null,\n nome: overview?.Name ?? null,\n settore: overview?.Sector ?? null,\n industria: overview?.Industry ?? null,\n valuta: overview?.Currency ?? null,\n prezzo,\n capitalizzazione,\n dataPrezzo: quote?.[\"Global Quote\"]?.[\"07. latest trading day\"] ?? null,\n beta: num(overview?.Beta),\n anni,\n // multipli dichiarati da AV: utili come controprova, non come input\n riscontro: {\n pe: num(overview?.PERatio),\n evEbitda: num(overview?.EVToEBITDA),\n priceToBook: num(overview?.PriceToBookRatio),\n targetAnalisti: num(overview?.AnalystTargetPrice),\n },\n };\n}\n\n/* --------------------------------------------------------------------\n * Copertura: quanti campi necessari al motore sono davvero arrivati.\n * Alimenta il Confidence Score invece di lasciarlo a una stima.\n * ------------------------------------------------------------------ */\nconst CAMPI_CRITICI = [\n \"ricavi\",\n \"ebit\",\n \"utileNetto\",\n \"cfo\",\n \"capex\",\n \"attivoTot\",\n \"passivoTot\",\n \"patrimonioNetto\",\n \"azioni\",\n \"debitoLordo\",\n \"cassa\",\n];\n\nexport function copertura(facts) {\n const anni = facts.anni || [];\n if (!anni.length) return { quota: 0, esercizi: 0, mancanti: CAMPI_CRITICI };\n const finestra = anni.slice(0, 5);\n let presenti = 0, totali = 0;\n const mancanti = new Set();\n for (const a of finestra) {\n for (const c of CAMPI_CRITICI) {\n totali++;\n if (a[c] !== null && a[c] !== undefined) presenti++;\n else mancanti.add(c);\n }\n }\n return {\n quota: totali ? presenti / totali : 0,\n esercizi: anni.length,\n mancanti: [...mancanti],\n };\n}\n\n/* --------------------------------------------------------------------\n * Recupero con cache. I bilanci cambiano quattro volte l'anno: non ha\n * senso riscaricarli. Il prezzo sì. Questa asimmetria è ciò che rende\n * sostenibile un piano dati gratuito.\n * ------------------------------------------------------------------ */\nexport const TTL = {\n overview: 7 * 864e5,\n bilanci: 45 * 864e5,\n quote: 1 * 864e5,\n};\n\nexport function storeMemoria() {\n const m = new Map();\n return {\n async get(k) {\n return m.get(k) ?? null;\n },\n async set(k, v) {\n m.set(k, v);\n },\n };\n}\n\nasync function conCache(store, chiave, ttl, now, produci) {\n if (store) {\n const c = await store.get(chiave);\n if (c && now - c.t < ttl) return c.v;\n }\n const v = await produci();\n if (store) await store.set(chiave, { t: now, v });\n return v;\n}\n\n/**\n * @param {string} symbol\n * @param {Object} deps { apiKey, fetch, store, now }\n * @returns { facts, copertura, richiesteFatte }\n */\nexport async function recuperaFacts(\n symbol,\n { apiKey, fetch: f, store = null, now = Date.now() },\n) {\n if (!apiKey) throw new Error(\"manca la chiave Alpha Vantage\");\n let richieste = 0;\n\n const chiama = async (fn, extra = {}) => {\n richieste++;\n const q = new URLSearchParams({\n function: fn,\n symbol,\n apikey: apiKey,\n ...extra,\n });\n const r = await f(`${AV}?${q}`);\n if (!r.ok) throw new Error(`${fn}: HTTP ${r.status}`);\n return controllaRisposta(await r.json(), fn);\n };\n\n const [overview, income, balance, cashflow, quote] = await Promise.all([\n conCache(\n store,\n `av:overview:${symbol}`,\n TTL.overview,\n now,\n () => chiama(\"OVERVIEW\"),\n ),\n conCache(\n store,\n `av:income:${symbol}`,\n TTL.bilanci,\n now,\n () => chiama(\"INCOME_STATEMENT\"),\n ),\n conCache(\n store,\n `av:balance:${symbol}`,\n TTL.bilanci,\n now,\n () => chiama(\"BALANCE_SHEET\"),\n ),\n conCache(\n store,\n `av:cashflow:${symbol}`,\n TTL.bilanci,\n now,\n () => chiama(\"CASH_FLOW\"),\n ),\n conCache(\n store,\n `av:quote:${symbol}`,\n TTL.quote,\n now,\n () => chiama(\"GLOBAL_QUOTE\"),\n ),\n ]);\n\n const facts = normalizzaAlphaVantage({\n overview,\n income,\n balance,\n cashflow,\n quote,\n });\n return { facts, copertura: copertura(facts), richiesteFatte: richieste };\n}",[244],"278a41f1-2b15-4bda-82a4-fad83f14ec64","engine.js","4d3752ee-abb9-11f1-badf-1607ee4eb77e",54,["D",1788901174031],"/* =====================================================================\n * MOTORE DI VALUTAZIONE FONDAMENTALE — strato deterministico\n * ---------------------------------------------------------------\n * Zero chiamate AI. Stessi input -> stesso output, sempre.\n *\n * Strati:\n * FACTS dati grezzi dalle API (input, mai generati qui)\n * DERIVED metriche calcolate <- questo file\n * JUDGMENTS moat, management, rischi (input dall'AI, 0-10)\n * SCORING aggregazione e gate <- questo file\n *\n * Ogni costante marcata [PROPOSTA] è una mia scelta da rivedere.\n * Ogni costante marcata [SPEC] viene dal documento dei criteri.\n * ===================================================================== */\n\nimport {\n BUSINESS_QUALITY,\n CASH_FLOW,\n FINANCIAL_STRENGTH,\n FMT,\n GROWTH,\n MANAGEMENT_VOCI,\n MOAT_FATTORI,\n VALUATION,\n} from \"./criteri.js\";\n\nexport const CONFIG = {\n /* --- Company Score -------------------------------------------------\n * I pesi dello spec sommano a 80%, non a 100%.\n * Qui sono normalizzati mantenendo i rapporti relativi (peso / 0.80).\n * Se preferisci ridistribuire diversamente, cambia solo questi valori:\n * il resto del motore legge da qui. [SPEC/80] */\n companyWeights: {\n businessQuality: 20 / 80, // 25.00%\n growth: 15 / 80, // 18.75%\n cashFlow: 15 / 80, // 18.75%\n financialStrength: 10 / 80, // 12.50%\n moat: 10 / 80, // 12.50%\n management: 5 / 80, // 6.25%\n risk: 5 / 80, // 6.25%\n },\n\n /* --- Investment Score ----------------------------------------------\n * Niente media aritmetica. Base + gate moltiplicativi.\n * Non riuso qui growth/financial strength: sono già dentro\n * companyScore, sommarli di nuovo sarebbe doppio conteggio. [PROPOSTA] */\n investmentWeights: {\n valuation: 0.40, // \"peso molto importante\" [SPEC]\n company: 0.40,\n expectationSafety: 0.20, // 100 - expectationRisk\n },\n\n /* --- Gate moltiplicativi -------------------------------------------\n * Applicati in cascata sul punteggio base. Un gate non si può\n * \"mediare via\": è il modo corretto di implementare le\n * \"penalizzazioni significative\" dello spec. [SPEC] */\n gates: {\n valuationEstrema: { soglia: -30, fattore: 0.60 }, // margin of safety %\n rischioFinanziario: { altmanZ: 1.81, netDebtEbitda: 4.0, fattore: 0.70 },\n aspettativeIrreali: { rapporto: 1.5, fattore: 0.75 }, // implied CAGR / storico 5Y\n crescitaInCalo: { deltaCagr: -0.40, fattore: 0.85 }, // 3Y vs 5Y\n redFlag: { beneishM: -1.78, fattore: 0.65 },\n diluizione: { sharesCagr3Y: 0.03, fattore: 0.90 },\n },\n\n /* --- DCF -------------------------------------------------------- */\n dcf: {\n anni: 10,\n waccDefault: 0.09, // [PROPOSTA]\n terminalGrowth: 0.025, // ~ crescita nominale di lungo [PROPOSTA]\n fadeVersoTerminal: true, // la crescita decade linearmente verso g_t\n tassoTasse: 0.21,\n },\n\n /* --- Blended fair value --------------------------------------------\n * I pesi si ricalcolano se un metodo non è disponibile. [SPEC] */\n fairValueWeights: {\n dcf: 0.40,\n relative: 0.30,\n historical: 0.20,\n growthAdj: 0.10,\n },\n\n /* --- Confidence: deduzioni da 100 ----------------------- [PROPOSTA] */\n confidence: {\n datiMancanti: 0.6, // punti persi per ogni % di copertura mancante\n divergenzaModelli: 20, // se CV tra fair value > 30%\n terminalValueDominante: 15, // se TV > 75% del valore DCF\n settoreCiclico: 10,\n storicoBreve: 15, // < 5 esercizi disponibili\n crescitaPocoMisurata: 12, // CAGR su meno di 5 periodi: una fonte a 5 anni\n // non permette di dire nulla sul lungo periodo\n },\n\n /* --- Verdetto --------------------------------------------- [SPEC] */\n verdetti: [\n { nome: \"Strong Buy Candidate\", is: 80, mos: 25, conf: 60 },\n { nome: \"Buy Candidate\", is: 65, mos: 10, conf: 45 },\n { nome: \"Hold\", is: 45, mos: -10, conf: 0 },\n { nome: \"Overvalued\", is: 30, mos: -999, conf: 0 },\n { nome: \"Avoid\", is: -999, mos: -999, conf: 0 },\n ],\n};\n\n/* ===================== utilità numeriche ============================ */\n\nconst n = (x) => (typeof x === \"number\" && isFinite(x) ? x : null);\nconst div = (\n a,\n b,\n) => (n(a) !== null && n(b) !== null && b !== 0 ? a / b : null);\nconst clamp = (x, lo = 0, hi = 100) => Math.min(hi, Math.max(lo, x));\n\n/** CAGR su `anni` periodi. Restituisce null se i segni non lo permettono. */\nexport function cagr(fine, inizio, anni) {\n if (n(fine) === null || n(inizio) === null || anni <= 0) return null;\n if (inizio <= 0 || fine <= 0) return null; // CAGR su valori negativi non ha senso\n return Math.pow(fine / inizio, 1 / anni) - 1;\n}\n\n/**\n * CAGR sul periodo più lungo effettivamente disponibile.\n * Serve perché le fonti gratuite danno 5 esercizi, non 10: senza questo\n * i CAGR a 5 e 10 anni restano null e i gate che li usano non scattano mai.\n * @returns { valore, anni } anni = periodi realmente misurati\n */\nexport function cagrDisponibile(serie, maxAnni = 10) {\n const idx = [];\n for (let i = 0; i < serie.length && i <= maxAnni; i++) {\n if (n(serie[i]) !== null) idx.push(i);\n }\n if (idx.length < 2) return { valore: null, anni: 0 };\n const primo = idx[0], ultimo = idx[idx.length - 1];\n return {\n valore: cagr(serie[primo], serie[ultimo], ultimo - primo),\n anni: ultimo - primo,\n };\n}\n\nexport function media(arr) {\n const v = arr.filter((x) => n(x) !== null);\n return v.length ? v.reduce((a, b) => a + b, 0) / v.length : null;\n}\n\nexport function devStd(arr) {\n const v = arr.filter((x) => n(x) !== null);\n if (v.length < 2) return null;\n const m = media(v);\n return Math.sqrt(v.reduce((a, b) => a + (b - m) ** 2, 0) / (v.length - 1));\n}\n\n/** Percentile di `x` dentro `arr`. Serve per la valutazione storica. */\nexport function percentile(x, arr) {\n const v = arr.filter((y) => n(y) !== null).sort((a, b) => a - b);\n if (!v.length || n(x) === null) return null;\n return v.filter((y) => y <= x).length / v.length;\n}\n\n/**\n * Curva di punteggio lineare fra una soglia minima e una di eccellenza.\n * band(0.15, 0.05, 0.25) -> 50. Con invert=true valori bassi valgono di più.\n */\nexport function band(x, floor, target, { invert = false } = {}) {\n if (n(x) === null) return null;\n const t = (x - floor) / (target - floor);\n return clamp((invert ? 1 - t : t) * 100);\n}\n\n/** Media dei sotto-punteggi disponibili, ignorando i null e ripesando. */\nfunction pesata(voci) {\n let num = 0, den = 0;\n for (const [valore, peso] of voci) {\n if (n(valore) === null) continue;\n num += valore * peso;\n den += peso;\n }\n return den > 0\n ? { score: num / den, copertura: den }\n : { score: null, copertura: 0 };\n}\n\n/* ===================== DERIVED: metriche ============================ */\n\n/**\n * @param {Object} f FACTS normalizzati. Array ordinati dal più recente:\n * f.anni[i] = { ricavi, ebit, ebitda, utileNetto, utileLordo, sga,\n * cfo, capex, ammortamenti, attivoTot, attivoCorrente,\n * passivoCorrente, passivoTot, crediti, immobilizzazioni,\n * utiliRiportati, debitoLordo, debitoLungo, cassa,\n * patrimonioNetto, azioni, oneriFinanziari, tasse }\n * f.prezzo, f.capitalizzazione, f.settore\n */\nexport function derivaMetriche(f) {\n const A = f.anni || [];\n const y0 = A[0] || {};\n const m = {};\n\n m.esercizi = A.length;\n\n // --- redditività\n m.fcf = A.map((\n a,\n ) => (n(a.cfo) !== null && n(a.capex) !== null ? a.cfo - a.capex : null));\n m.margineLordo = A.map((a) => div(a.utileLordo, a.ricavi));\n m.margineOper = A.map((a) => div(a.ebit, a.ricavi));\n m.margineNetto = A.map((a) => div(a.utileNetto, a.ricavi));\n m.margineFcf = A.map((a, i) => div(m.fcf[i], a.ricavi));\n\n m.roe = A.map((a) => div(a.utileNetto, a.patrimonioNetto));\n m.roa = A.map((a) => div(a.utileNetto, a.attivoTot));\n m.roic = A.map((a) => {\n const nopat = n(a.ebit) !== null\n ? a.ebit * (1 - CONFIG.dcf.tassoTasse)\n : null;\n const investito = n(a.patrimonioNetto) !== null && n(a.debitoLordo) !== null\n ? a.patrimonioNetto + a.debitoLordo - (a.cassa || 0)\n : null;\n return div(nopat, investito);\n });\n\n m.roicMedio3 = media(m.roic.slice(0, 3));\n m.roicMedio5 = media(m.roic.slice(0, 5));\n m.roicMedio10 = media(m.roic.slice(0, 10));\n // persistenza: quanti esercizi su N il ROIC resta sopra il costo del capitale\n m.roicPersistenza =\n m.roic.filter((x) => n(x) !== null && x > CONFIG.dcf.waccDefault).length /\n Math.max(1, m.roic.filter((x) => n(x) !== null).length);\n m.stabilitaMargini = devStd(m.margineOper.slice(0, 5)); // più basso = meglio\n\n // --- per azione\n m.eps = A.map((a) => div(a.utileNetto, a.azioni));\n m.fcfPerAzione = A.map((a, i) => div(m.fcf[i], a.azioni));\n m.azioni = A.map((a) => a.azioni);\n\n // --- crescita\n const last = (arr, k) => (arr.length > k ? arr[k] : null);\n m.ricaviCagr3 = cagr(y0.ricavi, last(A, 3)?.ricavi, 3);\n m.ricaviCagr5 = cagr(y0.ricavi, last(A, 5)?.ricavi, 5);\n m.ricaviCagr10 = cagr(y0.ricavi, last(A, 10)?.ricavi, 10);\n m.epsCagr3 = cagr(m.eps[0], last(m.eps, 3), 3);\n m.epsCagr5 = cagr(m.eps[0], last(m.eps, 5), 5);\n m.fcfCagr5 = cagr(m.fcf[0], last(m.fcf, 5), 5);\n m.azioniCagr3 = cagr(y0.azioni, last(A, 3)?.azioni, 3); // positivo = diluizione\n m.deltaMargineOper5 =\n n(m.margineOper[0]) !== null && n(m.margineOper[4]) !== null\n ? m.margineOper[0] - m.margineOper[4]\n : null;\n m.ruleOf40 = n(m.ricaviCagr3) !== null && n(m.margineFcf[0]) !== null\n ? m.ricaviCagr3 * 100 + m.margineFcf[0] * 100\n : null;\n\n // Riferimento unico di crescita realizzata, usato dai gate e\n // dall'Expectation Risk. Preferisce il periodo più lungo misurabile.\n const cr = cagrDisponibile(A.map((a) => a.ricavi));\n m.ricaviCagrDisponibile = cr.valore;\n m.ricaviCagrAnni = cr.anni;\n m.crescitaRiferimento = m.ricaviCagr10 ?? m.ricaviCagr5 ?? cr.valore ??\n m.ricaviCagr3;\n\n // --- solidità\n const debitoNetto = n(y0.debitoLordo) !== null\n ? y0.debitoLordo - (y0.cassa || 0)\n : null;\n m.debitoNetto = debitoNetto;\n m.debtEquity = div(y0.debitoLordo, y0.patrimonioNetto);\n m.netDebtEbitda = div(debitoNetto, y0.ebitda);\n m.debtFcf = div(y0.debitoLordo, m.fcf[0]);\n m.currentRatio = div(y0.attivoCorrente, y0.passivoCorrente);\n\n m.conversioneUtili = div(m.fcf[0], y0.utileNetto);\n m.intensitaCapex = div(y0.capex, y0.cfo);\n m.fcfPerAzioneCagrDisp = cagrDisponibile(m.fcfPerAzione).valore;\n\n // Utili riportati negativi da riacquisti non sono dissesto: l'azienda ha\n // distribuito più di quanto trattenuto. Altman assume il contrario, quindi\n // in questa situazione l'indice non è diagnostico e il criterio si astiene.\n const fcfPositivo = m.fcf.slice(0, 3).every((x) => n(x) !== null && x > 0);\n m.riacquistiSpiegano = n(y0.utiliRiportati) !== null &&\n y0.utiliRiportati < 0 &&\n fcfPositivo && n(m.netDebtEbitda) !== null && m.netDebtEbitda < 2;\n\n // Oneri finanziari nulli o assenti nell'ultimo esercizio: si ripiega\n // sull'esercizio più recente che li riporta. Zero significa copertura\n // eccellente, non dato mancante.\n const oneri = A.map((a) => a.oneriFinanziari).find((x) => n(x) !== null);\n m.oneriFinanziariUsati = oneri ?? null;\n m.interestCoverage = oneri === 0 ? 50 : div(y0.ebit, oneri);\n\n m.altmanZ = altmanZ(y0, f.capitalizzazione); // usa il prezzo: solo per i gate\n m.altmanZBook = altmanZBook(y0); // a valori di libro: Company Score\n m.piotroskiF = piotroskiF(A, m);\n m.beneishM = beneishM(A);\n\n // --- multipli correnti\n const ev = n(f.capitalizzazione) !== null && n(debitoNetto) !== null\n ? f.capitalizzazione + debitoNetto\n : null;\n m.ev = ev;\n m.pe = div(f.prezzo, m.eps[0]);\n m.pfcf = div(f.capitalizzazione, m.fcf[0]);\n m.fcfYield = div(m.fcf[0], f.capitalizzazione);\n m.evEbitda = div(ev, y0.ebitda);\n m.evEbit = div(ev, y0.ebit);\n m.evSales = div(ev, y0.ricavi);\n m.ebitdaCorrente = y0.ebitda ?? null;\n m.azioniCorrenti = y0.azioni ?? null;\n m.peg = n(m.pe) !== null && n(m.epsCagr5) !== null && m.epsCagr5 > 0\n ? m.pe / (m.epsCagr5 * 100)\n : null;\n\n return m;\n}\n\n/* ------------------ formule note, implementate a mano ---------------- */\n\nexport function altmanZ(y, capitalizzazione) {\n const ta = n(y.attivoTot);\n if (ta === null || ta === 0) return null;\n const wc = n(y.attivoCorrente) !== null && n(y.passivoCorrente) !== null\n ? y.attivoCorrente - y.passivoCorrente\n : null;\n const A = div(wc, ta), B = div(y.utiliRiportati, ta), C = div(y.ebit, ta);\n const D = div(capitalizzazione, y.passivoTot), E = div(y.ricavi, ta);\n if ([A, B, C, D, E].some((x) => x === null)) return null;\n return 1.2 * A + 1.4 * B + 3.3 * C + 0.6 * D + 1.0 * E;\n}\n\n/**\n * Variante Z'' di Altman: sostituisce la capitalizzazione col patrimonio\n * netto contabile. Serve al Company Score, che per definizione non deve\n * muoversi quando si muove il prezzo. Soglie: <1,1 allarme, >2,6 sicuro.\n */\nexport function altmanZBook(y) {\n const ta = n(y.attivoTot);\n if (ta === null || ta === 0) return null;\n const wc = n(y.attivoCorrente) !== null && n(y.passivoCorrente) !== null\n ? y.attivoCorrente - y.passivoCorrente\n : null;\n const X1 = div(wc, ta), X2 = div(y.utiliRiportati, ta);\n const X3 = div(y.ebit, ta), X4 = div(y.patrimonioNetto, y.passivoTot);\n if ([X1, X2, X3, X4].some((x) => x === null)) return null;\n return 6.56 * X1 + 3.26 * X2 + 6.72 * X3 + 1.05 * X4;\n}\n\n/** Piotroski F-Score, 0-9. Richiede almeno 2 esercizi. */\nexport function piotroskiF(A, m) {\n if (A.length < 2) return null;\n const [t, p] = A;\n let s = 0;\n const roaT = div(t.utileNetto, t.attivoTot),\n roaP = div(p.utileNetto, p.attivoTot);\n const cfoT = n(t.cfo);\n if (roaT > 0) s++; // 1 redditività\n if (cfoT > 0) s++; // 2 cassa operativa\n if (roaT !== null && roaP !== null && roaT > roaP) s++; // 3 ROA in crescita\n if (cfoT !== null && n(t.utileNetto) !== null && cfoT > t.utileNetto) s++; // 4 accrual\n const ltT = div(t.debitoLungo, t.attivoTot),\n ltP = div(p.debitoLungo, p.attivoTot);\n if (ltT !== null && ltP !== null && ltT < ltP) s++; // 5 leva in calo\n const crT = div(t.attivoCorrente, t.passivoCorrente),\n crP = div(p.attivoCorrente, p.passivoCorrente);\n if (crT !== null && crP !== null && crT > crP) s++; // 6 liquidità\n if (n(t.azioni) !== null && n(p.azioni) !== null && t.azioni <= p.azioni) s++; // 7 no diluizione\n const gmT = div(t.utileLordo, t.ricavi), gmP = div(p.utileLordo, p.ricavi);\n if (gmT !== null && gmP !== null && gmT > gmP) s++; // 8 margine lordo\n const atT = div(t.ricavi, t.attivoTot), atP = div(p.ricavi, p.attivoTot);\n if (atT !== null && atP !== null && atT > atP) s++; // 9 rotazione attivo\n return s;\n}\n\n/** Beneish M-Score. Sopra -1.78 = possibile manipolazione contabile. */\nexport function beneishM(A) {\n if (A.length < 2) return null;\n const [t, p] = A;\n const r = (\n a,\n b,\n ) => (n(a) !== null && n(b) !== null && b !== 0 ? a / b : null);\n\n const DSRI = r(div(t.crediti, t.ricavi), div(p.crediti, p.ricavi));\n const GMI = r(div(p.utileLordo, p.ricavi), div(t.utileLordo, t.ricavi));\n const aq = (y) => {\n const q =\n n(y.attivoCorrente) !== null && n(y.immobilizzazioni) !== null &&\n n(y.attivoTot) !== null\n ? 1 - (y.attivoCorrente + y.immobilizzazioni) / y.attivoTot\n : null;\n return q;\n };\n const AQI = r(aq(t), aq(p));\n const SGI = r(t.ricavi, p.ricavi);\n const dep = (y) =>\n div(y.ammortamenti, (y.ammortamenti || 0) + (y.immobilizzazioni || 0));\n const DEPI = r(dep(p), dep(t));\n const SGAI = r(div(t.sga, t.ricavi), div(p.sga, p.ricavi));\n const TATA = n(t.utileNetto) !== null && n(t.cfo) !== null\n ? div(t.utileNetto - t.cfo, t.attivoTot)\n : null;\n const lev = (y) =>\n div((y.passivoCorrente || 0) + (y.debitoLungo || 0), y.attivoTot);\n const LVGI = r(lev(t), lev(p));\n\n const v = { DSRI, GMI, AQI, SGI, DEPI, SGAI, TATA, LVGI };\n // Un rapporto anno su anno fuori da questa forbice segnala quasi sempre un\n // campo incoerente nella fonte, non un'anomalia contabile reale. Meglio\n // astenersi che produrre un M-Score su un input rotto.\n for (\n const [k, x] of Object.entries({ DSRI, GMI, AQI, SGI, DEPI, SGAI, LVGI })\n ) {\n if (x !== null && (x < 0.33 || x > 3)) return null;\n }\n // se manca più di una variabile il punteggio non è affidabile\n if (Object.values(v).filter((x) => x === null).length > 1) return null;\n const g = (x, d) => (x === null ? d : x); // default neutro = 1 (0 per TATA)\n return -4.84 +\n 0.920 * g(DSRI, 1) + 0.528 * g(GMI, 1) + 0.404 * g(AQI, 1) +\n 0.892 * g(SGI, 1) + 0.115 * g(DEPI, 1) - 0.172 * g(SGAI, 1) +\n 4.679 * g(TATA, 0) - 0.327 * g(LVGI, 1);\n}\n\n/* ===================== DCF e reverse DCF ============================ */\n\n/**\n * DCF a due stadi su ricavi + margine FCF.\n * @returns { valorePerAzione, valoreImpresa, quotaTerminal }\n */\nexport function dcf(\n {\n ricavi,\n margineFcf,\n crescita,\n wacc,\n terminalGrowth,\n debitoNetto,\n azioni,\n anni = CONFIG.dcf.anni,\n margineTarget = null,\n },\n) {\n if ([ricavi, margineFcf, crescita, wacc, azioni].some((x) => n(x) === null)) {\n return null;\n }\n if (wacc <= terminalGrowth) return null;\n\n let rev = ricavi, pv = 0, fcfUltimo = 0;\n for (let i = 1; i <= anni; i++) {\n // la crescita decade linearmente dal valore iniziale al terminal growth\n const g = CONFIG.dcf.fadeVersoTerminal\n ? crescita + (terminalGrowth - crescita) * ((i - 1) / (anni - 1))\n : crescita;\n rev *= 1 + g;\n const mg = margineTarget === null\n ? margineFcf\n : margineFcf + (margineTarget - margineFcf) * (i / anni);\n const fcf = rev * mg;\n pv += fcf / Math.pow(1 + wacc, i);\n fcfUltimo = fcf;\n }\n const tv = (fcfUltimo * (1 + terminalGrowth)) / (wacc - terminalGrowth);\n const pvTv = tv / Math.pow(1 + wacc, anni);\n const ev = pv + pvTv;\n const equity = ev - (debitoNetto || 0);\n return {\n valorePerAzione: equity / azioni,\n valoreImpresa: ev,\n quotaTerminal: pvTv / ev, // se > 0.75 la confidence scende\n };\n}\n\n/**\n * Reverse DCF: quale crescita dei ricavi è già incorporata nel prezzo?\n * Bisezione su `crescita` finché il DCF non eguaglia il prezzo di mercato.\n * Questo è il cuore di \"WHAT DOES THE MARKET EXPECT?\".\n */\nexport function reverseDCF(\n base,\n prezzoTarget,\n { lo = -0.20, hi = 0.80, iter = 60 } = {},\n) {\n const f = (g) => {\n const r = dcf({ ...base, crescita: g });\n return r ? r.valorePerAzione - prezzoTarget : null;\n };\n if (f(lo) === null || f(hi) === null) return null;\n if (f(lo) > 0) return lo; // il prezzo è sotto anche allo scenario peggiore\n if (f(hi) < 0) return hi; // nemmeno l'ipotesi estrema giustifica il prezzo\n let a = lo, b = hi;\n for (let i = 0; i < iter; i++) {\n const mid = (a + b) / 2;\n if (f(mid) < 0) a = mid;\n else b = mid;\n }\n return (a + b) / 2;\n}\n\n/* ===================== valutazione ================================== */\n\n/**\n * Fair value composito. I pesi si ridistribuiscono sui metodi disponibili,\n * così nessun modello domina per il solo fatto che gli altri mancano.\n */\nexport function blendedFairValue(\n { dcfVal, relativeVal, historicalVal, growthAdjVal },\n) {\n const w = CONFIG.fairValueWeights;\n const voci = [[dcfVal, w.dcf], [relativeVal, w.relative], [\n historicalVal,\n w.historical,\n ], [growthAdjVal, w.growthAdj]];\n const attivi = voci.filter(([v]) => n(v) !== null);\n if (!attivi.length) return null;\n const pesoTot = attivi.reduce((a, [, p]) => a + p, 0);\n const fv = attivi.reduce((a, [v, p]) => a + v * p, 0) / pesoTot;\n const valori = attivi.map(([v]) => v);\n const cv = devStd(valori) !== null && fv !== 0\n ? devStd(valori) / Math.abs(fv)\n : 0;\n return { fairValue: fv, metodiUsati: attivi.length, divergenza: cv };\n}\n\n/* ================= valutazione criterio per criterio ================ *\n * Ogni gruppo restituisce il punteggio complessivo e il dettaglio di\n * ciascun criterio: valore misurato, punteggio, soglie usate, peso e\n * strato di provenienza. È ciò che l'interfaccia mostra all'utente.\n * ------------------------------------------------------------------ */\n\nexport function valutaCriteri(lista, ctx) {\n const criteri = [];\n let num = 0, den = 0;\n const pesoTot = lista.reduce((a, c) => a + c.peso, 0);\n for (const c of lista) {\n const v = c.leggi(ctx);\n const s = band(v, c.floor, c.target);\n criteri.push({\n id: c.id,\n etichetta: c.etichetta,\n spiega: c.spiega,\n strato: c.strato,\n valore: v,\n valoreFormattato: v === null ? \"n/d\" : FMT[c.formato](v),\n score: s === null ? null : Math.round(s),\n pesoNelGruppo: +((c.peso / pesoTot) * 100).toFixed(1),\n soglie: {\n zeroPunti: FMT[c.formato](c.floor),\n centoPunti: FMT[c.formato](c.target),\n },\n nota: v === null\n ? (c.assente ?? \"dato non disponibile nella fonte\")\n : null,\n });\n if (s !== null) {\n num += s * c.peso;\n den += c.peso;\n }\n }\n return {\n score: den > 0 ? num / den : null,\n copertura: den / pesoTot,\n criteri,\n };\n}\n\nexport function valuationScore(\n { fairValue, prezzo, metriche, percentileRelativo = null },\n) {\n if (n(fairValue) === null || n(prezzo) === null || prezzo <= 0) return null;\n const upside = (fairValue - prezzo) / prezzo;\n const g = valutaCriteri(VALUATION, {\n upside,\n fcfYield: metriche?.fcfYield ?? null,\n peg: metriche?.peg ?? null,\n percentileRelativo,\n });\n return { ...g, upside, marginOfSafety: upside * 100 };\n}\n\n/**\n * Expectation Risk 0-100: quanto le attese implicite nel prezzo superano\n * ciò che l'azienda ha storicamente dimostrato di saper fare.\n */\nexport function expectationRisk(\n { crescitaImplicita, crescitaRiferimento, consensusCagr },\n) {\n const vuoto = { score: null, rapporto: null, riferimento: null };\n if (n(crescitaImplicita) === null) return vuoto;\n const rif = n(crescitaRiferimento) !== null && crescitaRiferimento > 0\n ? crescitaRiferimento\n : n(consensusCagr) !== null && consensusCagr > 0\n ? consensusCagr\n : null;\n if (rif === null) return { score: 50, rapporto: null, riferimento: null };\n const rapporto = crescitaImplicita / rif;\n // rapporto 0.6 -> rischio 0 ; rapporto 2.0 -> rischio 100 [PROPOSTA]\n return { score: band(rapporto, 0.6, 2.0), rapporto, riferimento: rif };\n}\n\nexport const scoreBusinessQuality = (m) => valutaCriteri(BUSINESS_QUALITY, m);\nexport const scoreGrowth = (m) => valutaCriteri(GROWTH, m);\nexport const scoreCashFlow = (m) => valutaCriteri(CASH_FLOW, m);\nexport const scoreFinancialStrength = (m) =>\n valutaCriteri(FINANCIAL_STRENGTH, m);\n\n/* --- strato AI: gli input arrivano su scala 0-10 con rubrica ------- */\n\nconst leggibile = (k) =>\n k.replace(/([A-Z])/g, \" $1\").replace(/^./, (c) => c.toUpperCase());\n\nexport function scoreMoat(j) {\n const fattori = j.fattori || {};\n const criteri = Object.entries(fattori).map(([k, v]) => ({\n id: k,\n etichetta: leggibile(k),\n spiega: MOAT_FATTORI[k] ??\n \"Fonte di vantaggio competitivo valutata dall'AI.\",\n strato: \"JUDGMENT\",\n valore: n(v),\n valoreFormattato: n(v) === null ? \"n/d\" : FMT.su10(v),\n score: n(v) === null ? null : Math.round(v * 10),\n pesoNelGruppo: +(100 / Math.max(1, Object.keys(fattori).length)).toFixed(1),\n soglie: { zeroPunti: \"0/10\", centoPunti: \"10/10\" },\n nota: null,\n }));\n const base = media(criteri.map((c) => c.valore));\n if (base === null) return { score: null, copertura: 0, criteri };\n const trend = { \"\\u2191\": 1.10, \"\\u2192\": 1.00, \"\\u2193\": 0.85 }[j.trend] ??\n 1;\n const durata =\n { Low: 0.80, Medium: 1.00, High: 1.10, Exceptional: 1.20 }[j.durabilita] ??\n 1;\n return {\n score: clamp(base * 10 * trend * durata),\n copertura: 1,\n criteri,\n moltiplicatori: {\n trend: j.trend ?? \"\\u2192\",\n fattoreTrend: trend,\n durabilita: j.durabilita ?? \"Medium\",\n fattoreDurabilita: durata,\n },\n };\n}\n\nexport function scoreManagement(j) {\n const pesi = {\n trackRecord: 3,\n capitalAllocation: 3,\n guidanceRispettate: 2,\n insiderAllineamento: 1,\n sbcRagionevole: 1,\n };\n const pesoTot = Object.values(pesi).reduce((a, b) => a + b, 0);\n const criteri = [], acc = { num: 0, den: 0 };\n for (const [k, peso] of Object.entries(pesi)) {\n const v = n(j[k]);\n const sc = v === null ? null : Math.round(v * 10);\n criteri.push({\n id: k,\n etichetta: leggibile(k),\n spiega: MANAGEMENT_VOCI[k],\n strato: \"JUDGMENT\",\n valore: v,\n valoreFormattato: v === null ? \"n/d\" : FMT.su10(v),\n score: sc,\n pesoNelGruppo: +((peso / pesoTot) * 100).toFixed(1),\n soglie: { zeroPunti: \"0/10\", centoPunti: \"10/10\" },\n nota: v === null ? \"non valutato dall'AI\" : null,\n });\n if (sc !== null) {\n acc.num += sc * peso;\n acc.den += peso;\n }\n }\n return {\n score: acc.den ? acc.num / acc.den : null,\n copertura: acc.den / pesoTot,\n criteri,\n };\n}\n\n/** Risk: 100 = pochi rischi. Ogni rischio pesa gravità per probabilità. */\nexport function scoreRisk(rischi = []) {\n if (!rischi.length) return { score: null, copertura: 0, criteri: [] };\n const criteri = rischi.map((r, i) => {\n const atteso = ((r.gravita ?? 5) / 10) * (r.probabilita ?? 0.3);\n return {\n id: `rischio${i}`,\n etichetta: r.nome ?? `Rischio ${i + 1}`,\n spiega: r.descrizione ??\n \"Rischio individuato dall'AI, con gravità e probabilità stimate.\",\n strato: \"JUDGMENT\",\n valore: atteso,\n valoreFormattato: `gravit\\u00e0 ${\n r.gravita ?? \"?\"\n }/10 x probabilit\\u00e0 ${Math.round((r.probabilita ?? 0.3) * 100)}%`,\n score: Math.round(clamp(100 - atteso * 100)),\n pesoNelGruppo: +(100 / rischi.length).toFixed(1),\n soglie: {\n zeroPunti: \"impatto atteso 100%\",\n centoPunti: \"impatto atteso 0%\",\n },\n nota: null,\n };\n });\n const impatto = criteri.reduce((a, c) => a + c.valore, 0);\n return { score: clamp(100 - impatto * 25), copertura: 1, criteri };\n}\n\n/* ===================== aggregazione ================================= */\n\nexport function companyScore(parti) {\n const w = CONFIG.companyWeights;\n const { score, copertura } = pesata([\n [parti.businessQuality, w.businessQuality],\n [parti.growth, w.growth],\n [parti.cashFlow, w.cashFlow],\n [parti.financialStrength, w.financialStrength],\n [parti.moat, w.moat],\n [parti.management, w.management],\n [parti.risk, w.risk],\n ]);\n return { score: score === null ? null : Math.round(score), copertura };\n}\n\n/**\n * Investment Score con gate moltiplicativi.\n * @returns { score, base, gateApplicati:[{nome, fattore, motivo}] }\n */\nexport function investmentScore(\n { valuation, company, expectationRisk: er, metriche, marginOfSafety },\n) {\n const w = CONFIG.investmentWeights;\n const { score: base } = pesata([\n [valuation, w.valuation],\n [company, w.company],\n [er === null ? null : 100 - er, w.expectationSafety],\n ]);\n if (base === null) return { score: null, base: null, gateApplicati: [] };\n\n const g = CONFIG.gates;\n const applicati = [];\n const applica = (cond, nome, fattore, motivo) => {\n if (cond) applicati.push({ nome, fattore, motivo });\n };\n const m = metriche || {};\n\n applica(\n n(marginOfSafety) !== null && marginOfSafety < g.valuationEstrema.soglia,\n \"valuation estrema\",\n g.valuationEstrema.fattore,\n `margine di sicurezza ${Math.round(marginOfSafety)}%`,\n );\n\n applica(\n (n(m.altmanZ) !== null && m.altmanZ < g.rischioFinanziario.altmanZ) ||\n (n(m.netDebtEbitda) !== null &&\n m.netDebtEbitda > g.rischioFinanziario.netDebtEbitda),\n \"rischio finanziario\",\n g.rischioFinanziario.fattore,\n `Altman Z ${m.altmanZ?.toFixed(2) ?? \"n/d\"}, NetDebt/EBITDA ${\n m.netDebtEbitda?.toFixed(1) ?? \"n/d\"\n }`,\n );\n\n applica(\n n(m.crescitaImplicita) !== null && n(m.crescitaRiferimento) !== null &&\n m.crescitaRiferimento > 0 &&\n m.crescitaImplicita / m.crescitaRiferimento >\n g.aspettativeIrreali.rapporto,\n \"aspettative irrealistiche\",\n g.aspettativeIrreali.fattore,\n n(m.crescitaImplicita) !== null && n(m.crescitaRiferimento) !== null\n ? `il prezzo sconta ${\n (m.crescitaImplicita * 100).toFixed(1)\n }% di crescita contro ${\n (m.crescitaRiferimento * 100).toFixed(1)\n }% realizzato`\n : \"crescita implicita molto sopra lo storico\",\n );\n\n applica(\n n(m.ricaviCagr3) !== null && n(m.ricaviCagr5) !== null &&\n m.ricaviCagr5 > 0 &&\n (m.ricaviCagr3 - m.ricaviCagr5) / m.ricaviCagr5 <\n g.crescitaInCalo.deltaCagr,\n \"crescita in decelerazione\",\n g.crescitaInCalo.fattore,\n \"il CAGR a 3 anni è molto sotto quello a 5\",\n );\n\n applica(\n n(m.beneishM) !== null && m.beneishM > g.redFlag.beneishM,\n \"anomalie contabili\",\n g.redFlag.fattore,\n `Beneish M ${m.beneishM?.toFixed(2) ?? \"n/d\"} sopra la soglia`,\n );\n\n applica(\n n(m.azioniCagr3) !== null && m.azioniCagr3 > g.diluizione.sharesCagr3Y,\n \"diluizione\",\n g.diluizione.fattore,\n `azioni in crescita del ${(m.azioniCagr3 * 100).toFixed(1)}% annuo`,\n );\n\n const finale = applicati.reduce((a, x) => a * x.fattore, base);\n return {\n score: Math.round(clamp(finale)),\n base: Math.round(base),\n gateApplicati: applicati,\n };\n}\n\nexport function confidenceScore(\n {\n copertura,\n divergenzaModelli,\n quotaTerminal,\n settoreCiclico,\n esercizi,\n anniCrescita,\n },\n) {\n const c = CONFIG.confidence;\n let s = 100;\n if (n(copertura) !== null) s -= (1 - copertura) * 100 * c.datiMancanti;\n if (n(divergenzaModelli) !== null && divergenzaModelli > 0.30) {\n s -= c.divergenzaModelli;\n }\n if (n(quotaTerminal) !== null && quotaTerminal > 0.75) {\n s -= c.terminalValueDominante;\n }\n if (settoreCiclico) s -= c.settoreCiclico;\n if (n(esercizi) !== null && esercizi < 5) s -= c.storicoBreve;\n if (n(anniCrescita) !== null && anniCrescita < 5) s -= c.crescitaPocoMisurata;\n return Math.round(clamp(s));\n}\n\nexport function verdetto(is, mos, conf) {\n for (const v of CONFIG.verdetti) {\n if (is >= v.is && mos >= v.mos && conf >= v.conf) return v.nome;\n }\n return \"Avoid\";\n}\n\n/* ===================== orchestratore ================================ */\n\n/**\n * Compone il report finale.\n * @param {Object} facts FACTS normalizzati\n * @param {Object} judgments { moat, management, rischi } dall'AI, 0-10\n * @param {Object} ipotesi { wacc, terminalGrowth, margineTarget, ... }\n */\nexport function valuta(facts, judgments = {}, ipotesi = {}) {\n const m = derivaMetriche(facts);\n const y0 = facts.anni?.[0] || {};\n\n const wacc = ipotesi.wacc ?? CONFIG.dcf.waccDefault;\n const tg = ipotesi.terminalGrowth ?? CONFIG.dcf.terminalGrowth;\n const baseDcf = {\n ricavi: y0.ricavi,\n margineFcf: m.margineFcf[0],\n wacc,\n terminalGrowth: tg,\n debitoNetto: m.debitoNetto,\n azioni: y0.azioni,\n margineTarget: ipotesi.margineTarget ?? null,\n };\n\n const crescitaBase = ipotesi.crescitaBase ?? m.ricaviCagr5 ?? m.ricaviCagr3 ??\n 0.03;\n const d = dcf({ ...baseDcf, crescita: crescitaBase });\n\n // --- cosa sta scontando il mercato\n m.crescitaImplicita = reverseDCF(baseDcf, facts.prezzo);\n const er = expectationRisk({\n crescitaImplicita: m.crescitaImplicita,\n crescitaRiferimento: m.crescitaRiferimento,\n consensusCagr: ipotesi.consensusCagr,\n });\n\n // --- fair value composito\n const fv = blendedFairValue({\n dcfVal: d?.valorePerAzione ?? null,\n relativeVal: ipotesi.fairValueRelativo ?? null,\n historicalVal: ipotesi.fairValueStorico ?? null,\n growthAdjVal: ipotesi.fairValueGrowthAdj ?? null,\n });\n const val = fv\n ? valuationScore({\n fairValue: fv.fairValue,\n prezzo: facts.prezzo,\n metriche: m,\n percentileRelativo: ipotesi.percentileRelativo ?? null,\n })\n : null;\n\n // --- sotto-punteggi\n const bq = scoreBusinessQuality(m),\n gr = scoreGrowth(m),\n cf = scoreCashFlow(m);\n const fs = scoreFinancialStrength(m), mo = scoreMoat(judgments.moat || {});\n const mg = scoreManagement(judgments.management || {}),\n rk = scoreRisk(judgments.rischi);\n\n const cs = companyScore({\n businessQuality: bq.score,\n growth: gr.score,\n cashFlow: cf.score,\n financialStrength: fs.score,\n moat: mo.score,\n management: mg.score,\n risk: rk.score,\n });\n\n const is = investmentScore({\n valuation: val?.score ?? null,\n company: cs.score,\n expectationRisk: er?.score ?? null,\n metriche: m,\n marginOfSafety: val?.marginOfSafety ?? null,\n });\n\n const conf = confidenceScore({\n copertura: cs.copertura,\n divergenzaModelli: fv?.divergenza,\n quotaTerminal: d?.quotaTerminal,\n settoreCiclico: ipotesi.settoreCiclico,\n esercizi: m.esercizi,\n anniCrescita: m.ricaviCagrAnni,\n });\n\n return {\n ticker: facts.ticker,\n companyScore: cs.score,\n investmentScore: is.score,\n investmentScoreBase: is.base,\n gateApplicati: is.gateApplicati,\n confidence: conf,\n verdetto: verdetto(is.score ?? 0, val?.marginOfSafety ?? -999, conf),\n prezzo: facts.prezzo,\n fairValue: fv?.fairValue ?? null,\n upside: val?.upside ?? null,\n marginOfSafety: val?.marginOfSafety ?? null,\n moat: mo.score !== null ? +(mo.score / 10).toFixed(1) : null,\n moatDurabilita: judgments.moat?.durabilita ?? null,\n aspettativeMercato: {\n crescitaRicaviImplicita: m.crescitaImplicita,\n cagrStorico5: m.ricaviCagr5,\n crescitaRiferimento: m.crescitaRiferimento,\n anniMisurati: m.ricaviCagrAnni,\n rapporto: er?.rapporto ?? null,\n expectationRisk: er?.score ?? null,\n },\n sottoPunteggi: {\n businessQuality: bq.score,\n growth: gr.score,\n cashFlow: cf.score,\n financialStrength: fs.score,\n moat: mo.score,\n management: mg.score,\n risk: rk.score,\n },\n dettaglio: {\n valuation: { peso: null, ...(val ?? { score: null, criteri: [] }) },\n businessQuality: { peso: CONFIG.companyWeights.businessQuality, ...bq },\n growth: { peso: CONFIG.companyWeights.growth, ...gr },\n cashFlow: { peso: CONFIG.companyWeights.cashFlow, ...cf },\n financialStrength: {\n peso: CONFIG.companyWeights.financialStrength,\n ...fs,\n },\n moat: { peso: CONFIG.companyWeights.moat, ...mo },\n management: { peso: CONFIG.companyWeights.management, ...mg },\n risk: { peso: CONFIG.companyWeights.risk, ...rk },\n },\n metriche: m,\n dcf: d,\n };\n}",[252],"de5ae097-c1d8-44e9-92aa-f7c2632caaeb","cron.ts","ac12e6a4-abbc-11f1-ac09-1607ee4eb77e",39,["D",1788900300372],"interval","/* =====================================================================\n * CRON — rigenera il brief ogni mattina\n * ---------------------------------------------------------------\n * Val di tipo Cron. Espressione: 0 5 * * 1-5\n *\n * I cron di Val Town girano in UTC: le 5:00 UTC sono le 7:00 italiane\n * d'estate e le 6:00 d'inverno. Per un brief va bene comunque, i\n * mercati europei aprono alle 9:00.\n *\n * Solo giorni feriali: nel fine settimana non c'è nulla di nuovo da\n * raccontare e ogni esecuzione consuma budget Alpha Vantage.\n * ===================================================================== */\n\nimport { aggiornaBrief } from \"./main.ts\";\n\nexport default async function () {\n try {\n const { brief } = await aggiornaBrief();\n console.log(`brief generato: ${brief.unaRiga}`);\n // Il radar si scalda subito dopo: così alle 7 le quotazioni della\n // watchlist sono già in cache e la pagina apre istantanea.\n try {\n const r = await fetch(\n new URL(\"/radar\", Deno.env.get(\"VAL_URL\") ?? \"http://localhost\"),\n );\n console.log(\"radar riscaldato:\", r.status);\n } catch {\n console.log(\"radar non riscaldato: VAL_URL non impostata\");\n }\n } catch (e) {\n // Un errore qui non deve restare silenzioso: senza log scopriresti\n // il guasto solo aprendo la pagina e trovandola vecchia di giorni.\n console.error(\n \"generazione brief fallita:\",\n String((e as Error)?.message ?? e),\n );\n throw e;\n }\n}",[259],"facfed5d-8c5d-4c70-acea-fd434cd9eec2","criteri.js","5b793926-abb9-11f1-97ef-1607ee4eb77e",20,["D",1788894870909],"/* =====================================================================\n * REGISTRO DEI CRITERI\n * ---------------------------------------------------------------\n * Ogni criterio dichiara: cosa misura, cosa significa in concreto,\n * la soglia sotto cui vale 0, quella sopra cui vale 100, il peso\n * dentro il suo gruppo e da quale strato viene il dato.\n *\n * `strato` è la distinzione richiesta dal punto 9 dello spec:\n * FACT preso da un bilancio pubblicato\n * DERIVED calcolato dal codice a partire dai FACT\n * ESTIMATE dipende da ipotesi di modello (DCF, fair value)\n * JUDGMENT valutazione qualitativa dell'AI\n *\n * Le soglie marcate come tarature sono scelte discutibili: cambiarle\n * qui cambia i punteggi ovunque, senza toccare la logica.\n * ===================================================================== */\n\nexport const FMT = {\n pct: (x) => (x * 100).toFixed(1) + \"%\",\n pp: (x) => (x >= 0 ? \"+\" : \"\") + (x * 100).toFixed(1) + \" p.p.\",\n mult: (x) => x.toFixed(1) + \"x\",\n num: (x) => x.toFixed(2),\n su9: (x) => Math.round(x) + \"/9\",\n su10: (x) => x.toFixed(1) + \"/10\",\n punti: (x) => Math.round(x) + \"/100\",\n};\n\n/* ---------------------- BUSINESS QUALITY 25% ---------------------- */\nexport const BUSINESS_QUALITY = [\n {\n id: \"roicMedio\",\n etichetta: \"ROIC medio pluriennale\",\n peso: 3,\n floor: 0.05,\n target: 0.25,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Quanto profitto operativo netto genera ogni euro di capitale impiegato, debito e mezzi propri insieme. Se resta sopra il costo del capitale l'azienda crea valore; sotto, lo distrugge pur restando in utile. È la metrica singola che separa meglio i business buoni da quelli mediocri.\",\n leggi: (m) => m.roicMedio5 ?? m.roicMedio3,\n },\n {\n id: \"roicPersistenza\",\n etichetta: \"Persistenza del ROIC\",\n peso: 2,\n floor: 0.3,\n target: 1.0,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Frazione degli esercizi disponibili in cui il ROIC è rimasto sopra il costo del capitale. Un rendimento alto per un anno è ciclo o fortuna; alto per dieci anni di fila è un vantaggio competitivo che qualcuno non è riuscito a copiare.\",\n leggi: (m) => m.roicPersistenza,\n },\n {\n id: \"roe\",\n etichetta: \"ROE\",\n peso: 1,\n floor: 0.08,\n target: 0.30,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Utile netto sul patrimonio netto: quanto rende il capitale degli azionisti. Va letto insieme alla leva, perché il debito lo gonfia senza che il business sia migliorato.\",\n leggi: (m) => m.roe[0],\n },\n {\n id: \"roa\",\n etichetta: \"ROA\",\n peso: 1,\n floor: 0.02,\n target: 0.15,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Utile netto sul totale attivo. A differenza del ROE non si lascia ingannare dalla leva finanziaria: misura quanto l'azienda ricava da tutto ciò che possiede.\",\n leggi: (m) => m.roa[0],\n },\n {\n id: \"margineLordo\",\n etichetta: \"Margine lordo\",\n peso: 1,\n floor: 0.20,\n target: 0.65,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Quanto resta dei ricavi dopo il costo diretto di ciò che si vende. È il primo indizio di potere di prezzo: chi può alzare i listini senza perdere clienti lo mostra qui prima che altrove.\",\n leggi: (m) => m.margineLordo[0],\n },\n {\n id: \"margineOper\",\n etichetta: \"Margine operativo\",\n peso: 1.5,\n floor: 0.05,\n target: 0.30,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Reddito operativo sui ricavi, cioè quanto rende il mestiere vero al netto della struttura ma prima di interessi e tasse. È la misura di efficienza più confrontabile fra aziende con strutture finanziarie diverse.\",\n leggi: (m) => m.margineOper[0],\n },\n {\n id: \"margineNetto\",\n etichetta: \"Margine netto\",\n peso: 1,\n floor: 0.03,\n target: 0.22,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Quanto dei ricavi arriva davvero in fondo al conto economico, dopo interessi, tasse e tutto il resto.\",\n leggi: (m) => m.margineNetto[0],\n },\n {\n id: \"margineFcf\",\n etichetta: \"Margine di cassa libera\",\n peso: 1.5,\n floor: 0.03,\n target: 0.25,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Cassa che resta dopo aver pagato gli investimenti necessari a tenere in piedi l'attività, in rapporto ai ricavi. L'utile è un'opinione contabile, questa è cassa: un divario stabile fra i due è un segnale da approfondire.\",\n leggi: (m) => m.margineFcf[0],\n },\n {\n id: \"stabilitaMargini\",\n etichetta: \"Stabilità dei margini\",\n peso: 1,\n floor: 0.08,\n target: 0.01,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Deviazione standard del margine operativo sugli ultimi cinque esercizi. Più bassa è, più il business è prevedibile e più le proiezioni del DCF sono credibili. Valori alti indicano ciclicità o scarso controllo sui costi.\",\n leggi: (m) => m.stabilitaMargini,\n },\n];\n\n/* --------------------------- GROWTH 18,75% ------------------------ */\nexport const GROWTH = [\n {\n id: \"ricaviCagrLungo\",\n etichetta: \"Crescita ricavi, periodo lungo\",\n peso: 2.5,\n floor: 0.00,\n target: 0.20,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Tasso composto di crescita dei ricavi sul periodo più lungo disponibile nei dati. Guarda la traiettoria, non l'ultimo anno, che può essere un rimbalzo o un confronto facile.\",\n leggi: (m) => m.crescitaRiferimento,\n assente: \"servono almeno due esercizi con ricavi validi\",\n },\n {\n id: \"ricaviCagr3\",\n etichetta: \"Crescita ricavi a 3 anni\",\n peso: 1.5,\n floor: 0.00,\n target: 0.20,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"La stessa misura sul periodo recente. Confrontata con quella lunga dice se l'azienda sta accelerando o rallentando: il divario fra le due alimenta il gate sulla decelerazione.\",\n leggi: (m) => m.ricaviCagr3,\n },\n {\n id: \"epsCagr\",\n etichetta: \"Crescita utile per azione\",\n peso: 2.5,\n floor: 0.00,\n target: 0.25,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Crescita dell'utile per azione, non dell'utile totale. La differenza conta: un'azienda che cresce emettendo azioni fa crescere la torta ma non la tua fetta.\",\n leggi: (m) => m.epsCagr5 ?? m.epsCagr3,\n },\n {\n id: \"fcfCagr\",\n etichetta: \"Crescita cassa libera\",\n peso: 2,\n floor: 0.00,\n target: 0.25,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Crescita del flusso di cassa libero. Se i ricavi salgono e la cassa no, la crescita si sta pagando con capitale circolante o investimenti che non rientrano.\",\n leggi: (m) => m.fcfCagr5,\n },\n {\n id: \"espansioneMargini\",\n etichetta: \"Espansione dei margini\",\n peso: 1.5,\n floor: -0.05,\n target: 0.10,\n formato: \"pp\",\n strato: \"DERIVED\",\n spiega:\n \"Variazione del margine operativo nell'arco di cinque anni, in punti percentuali. Crescere allargando i margini significa scala o potere di prezzo; crescere comprimendoli significa comprare ricavi.\",\n leggi: (m) => m.deltaMargineOper5,\n },\n {\n id: \"ruleOf40\",\n etichetta: \"Rule of 40\",\n peso: 1,\n floor: 10,\n target: 60,\n formato: \"num\",\n strato: \"DERIVED\",\n spiega:\n \"Crescita percentuale dei ricavi sommata al margine di cassa. Nata per il software: sopra 40 il compromesso fra correre e guadagnare è considerato sano. Ha poco senso fuori dai business ad alto margine ricorrente.\",\n leggi: (m) => m.ruleOf40,\n },\n];\n\n/* --------------- CASH FLOW & CAPITAL ALLOCATION 18,75% ------------ *\n * L'FCF yield è stato spostato nella Valuation: dipende dal prezzo e\n * qui contaminava un punteggio che deve misurare solo l'azienda. */\nexport const CASH_FLOW = [\n {\n id: \"margineFcfCF\",\n etichetta: \"Margine di cassa libera\",\n peso: 2,\n floor: 0.03,\n target: 0.25,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Quanta cassa libera produce ogni euro di ricavi. Ripetuto qui perché nel gruppo precedente misura la qualità del business, mentre qui è la materia prima di tutto ciò che il management può allocare.\",\n leggi: (m) => m.margineFcf[0],\n },\n {\n id: \"fcfPerAzioneCagr\",\n etichetta: \"Crescita cassa libera per azione\",\n peso: 2,\n floor: 0.00,\n target: 0.20,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"La metrica che conta davvero per chi possiede le azioni: unisce la crescita della cassa e l'effetto dei riacquisti o delle emissioni in un numero solo.\",\n leggi: (m) => m.fcfPerAzioneCagrDisp,\n },\n {\n id: \"andamentoAzioni\",\n etichetta: \"Andamento del numero di azioni\",\n peso: 2,\n floor: 0.03,\n target: -0.03,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Variazione annua composta delle azioni in circolazione. Negativa significa riacquisti che concentrano la tua quota; positiva significa diluizione, spesso da compensi in azioni.\",\n leggi: (m) => m.azioniCagr3,\n },\n {\n id: \"conversioneUtili\",\n etichetta: \"Conversione utili in cassa\",\n peso: 1.5,\n floor: 0.7,\n target: 1.3,\n formato: \"mult\",\n strato: \"DERIVED\",\n spiega:\n \"Rapporto fra cassa libera e utile netto. Intorno a 1 gli utili dichiarati corrispondono a cassa vera. Sotto 0,7 in modo persistente è la prima cosa da chiarire prima di fidarsi dei numeri.\",\n leggi: (m) => m.conversioneUtili,\n },\n {\n id: \"intensitaCapex\",\n etichetta: \"Intensità degli investimenti\",\n peso: 1,\n floor: 0.60,\n target: 0.10,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Quota della cassa operativa che se ne va in investimenti solo per restare in gioco. Bassa significa che resta molta cassa da destinare a crescita, dividendi o riacquisti.\",\n leggi: (m) => m.intensitaCapex,\n },\n];\n\n/* --------------------- FINANCIAL STRENGTH 12,5% ------------------- */\nexport const FINANCIAL_STRENGTH = [\n {\n id: \"altmanZBook\",\n etichetta: \"Altman Z'' (a valori di libro)\",\n peso: 2.5,\n floor: 1.1,\n target: 3.5,\n formato: \"num\",\n strato: \"DERIVED\",\n spiega:\n \"Indice sintetico di rischio di insolvenza che combina capitale circolante, utili accumulati, redditività e struttura patrimoniale. Qui si usa la variante che impiega il patrimonio netto contabile invece della capitalizzazione, così il punteggio non cambia quando cambia il prezzo. Sotto 1,1 è zona di allarme.\",\n leggi: (m) => (m.riacquistiSpiegano ? null : m.altmanZBook),\n assente:\n \"utili riportati negativi per riacquisti, non per perdite: su questa azienda l'indice non è diagnostico\",\n },\n {\n id: \"piotroskiF\",\n etichetta: \"Piotroski F-Score\",\n peso: 2,\n floor: 3,\n target: 8,\n formato: \"su9\",\n strato: \"DERIVED\",\n spiega:\n \"Nove test binari su redditività, struttura finanziaria ed efficienza, confrontando l'ultimo esercizio col precedente. Non dice se l'azienda è buona, dice se sta migliorando o peggiorando su tutti i fronti insieme.\",\n leggi: (m) => m.piotroskiF,\n },\n {\n id: \"netDebtEbitda\",\n etichetta: \"Debito netto su EBITDA\",\n peso: 2,\n floor: 4.0,\n target: 0.0,\n formato: \"mult\",\n strato: \"DERIVED\",\n spiega:\n \"Quanti anni di margine operativo lordo servirebbero per azzerare il debito netto. È il parametro che le banche usano nei covenant: sopra 4 la flessibilità dell'azienda si riduce parecchio.\",\n leggi: (m) => m.netDebtEbitda,\n },\n {\n id: \"interestCoverage\",\n etichetta: \"Copertura degli interessi\",\n peso: 1.5,\n floor: 2,\n target: 15,\n formato: \"mult\",\n strato: \"DERIVED\",\n spiega:\n \"Quante volte il reddito operativo copre gli oneri finanziari. Sotto 2 un anno storto basta a mettere in discussione il servizio del debito.\",\n leggi: (m) => m.interestCoverage,\n },\n {\n id: \"currentRatio\",\n etichetta: \"Indice di liquidità corrente\",\n peso: 1,\n floor: 0.9,\n target: 2.5,\n formato: \"mult\",\n strato: \"DERIVED\",\n spiega:\n \"Attivo corrente su passivo corrente: se l'azienda può far fronte agli impegni dei prossimi dodici mesi con ciò che ha già a disposizione.\",\n leggi: (m) => m.currentRatio,\n },\n {\n id: \"debtFcf\",\n etichetta: \"Debito su cassa libera\",\n peso: 1,\n floor: 8,\n target: 1,\n formato: \"mult\",\n strato: \"DERIVED\",\n spiega:\n \"Anni di cassa libera necessari a ripagare il debito lordo. Più severo del rapporto sull'EBITDA perché tiene conto degli investimenti che l'azienda non può evitare.\",\n leggi: (m) => m.debtFcf,\n },\n];\n\n/* --------------------------- VALUATION ---------------------------- */\nexport const VALUATION = [\n {\n id: \"upside\",\n etichetta: \"Scarto dal fair value\",\n peso: 4,\n floor: -0.40,\n target: 0.60,\n formato: \"pct\",\n strato: \"ESTIMATE\",\n spiega:\n \"Distanza fra il prezzo attuale e il fair value composito ottenuto mediando più metodi. È una stima, non un fatto: dipende dalle ipotesi su costo del capitale, crescita e margini, tutte esposte e modificabili.\",\n leggi: (v) => v.upside,\n },\n {\n id: \"fcfYield\",\n etichetta: \"Rendimento della cassa libera\",\n peso: 1.5,\n floor: 0.01,\n target: 0.08,\n formato: \"pct\",\n strato: \"DERIVED\",\n spiega:\n \"Cassa libera annua rapportata alla capitalizzazione: quanto rende l'azienda se la comprassi tutta al prezzo di oggi. Si confronta direttamente col rendimento di un titolo di Stato ed è il contrappeso al DCF, perché non richiede nessuna proiezione.\",\n leggi: (v) => v.fcfYield,\n },\n {\n id: \"peg\",\n etichetta: \"PEG\",\n peso: 1,\n floor: 3.0,\n target: 0.8,\n formato: \"num\",\n strato: \"DERIVED\",\n spiega:\n \"Rapporto prezzo/utili diviso per il tasso di crescita degli utili. Sotto 1 il mercato chiede poco per la crescita che l'azienda ha dimostrato. Va usato con prudenza: si rompe su aziende cicliche o con utili vicini a zero.\",\n leggi: (v) => v.peg,\n },\n {\n id: \"multipliRelativi\",\n etichetta: \"Multipli contro i comparabili\",\n peso: 1.5,\n floor: 0,\n target: 1,\n formato: \"num\",\n strato: \"ESTIMATE\",\n spiega:\n \"Posizione dei multipli dell'azienda rispetto al gruppo di aziende simili e alla propria storia. Un P/E di 30 non dice nulla in assoluto: dice molto se i concorrenti stanno a 15 o se l'azienda ha trattato a 20 negli ultimi dieci anni.\",\n leggi: (v) => v.percentileRelativo,\n assente: \"richiede il gruppo di comparabili e i multipli storici\",\n },\n];\n\n/* ---------------- MOAT, MANAGEMENT, RISK — strato AI -------------- */\nexport const MOAT_FATTORI = {\n brand:\n \"Il marchio permette di far pagare di più lo stesso prodotto, o di essere scelto a parità di prezzo.\",\n networkEffects:\n \"Ogni nuovo utente rende il servizio più utile a quelli già presenti, rendendo la sostituzione progressivamente più costosa.\",\n switchingCosts:\n \"Cambiare fornitore costa in denaro, tempo, dati da migrare o riaddestramento del personale.\",\n costAdvantage:\n \"L'azienda produce a costo strutturalmente inferiore: accesso alle materie prime, processi, posizione geografica.\",\n scala:\n \"I costi fissi si spalmano su volumi che i concorrenti più piccoli non raggiungono.\",\n ip:\n \"Brevetti, tecnologia proprietaria o know-how difendibili legalmente o difficili da replicare.\",\n distribuzione:\n \"Controllo di canali di vendita che un nuovo entrante non può ricreare in tempi ragionevoli.\",\n dati:\n \"Un patrimonio di dati accumulato che migliora il prodotto e che i concorrenti non possono comprare.\",\n barriereRegolamentari:\n \"Licenze, concessioni o requisiti normativi che limitano il numero di operatori.\",\n ecosistema:\n \"Prodotti complementari che si rafforzano a vicenda e trattengono il cliente dentro il perimetro.\",\n};\n\nexport const MANAGEMENT_VOCI = {\n trackRecord:\n \"Risultati effettivamente ottenuti dall'attuale gruppo dirigente nel tempo in cui è stato in carica.\",\n capitalAllocation:\n \"Come è stata impiegata la cassa: reinvestimento, acquisizioni, riacquisti, dividendi, e con quale ritorno.\",\n guidanceRispettate:\n \"Coerenza fra ciò che il management ha promesso nelle trimestrali passate e ciò che ha poi consegnato.\",\n insiderAllineamento:\n \"Quota posseduta dai dirigenti e direzione dei loro acquisti e vendite sul mercato.\",\n sbcRagionevole:\n \"Peso dei compensi in azioni sui ricavi e sulla cassa, e quanta diluizione producono ogni anno.\",\n};",[267],"676433b1-f0c5-41ee-9f84-e68cea3c758c","brief.ts","94b06892-abbc-11f1-a39f-1607ee4eb77e",65,["D",1788950057578],7,"/* =====================================================================\n * BRIEF — quadro mattutino\n * ---------------------------------------------------------------\n * Generato dal cron alle 5:00 UTC e salvato. Quando apri /brief è\n * già pronto da ore: nessuna attesa, nessuna notifica.\n *\n * Usa Gemini Flash invece di Claude perché il piano gratuito Google\n * è permanente e non chiede carta. Il compito è adatto: i numeri\n * arrivano già calcolati dal motore, a Flash resta il commento e la\n * ricerca di cosa è successo nelle ultime 24 ore.\n *\n * Da sapere: sul piano gratuito Google può usare i prompt per\n * addestrare i propri modelli. Qui passano solo dati macro pubblici.\n *\n * Serve la variabile d'ambiente GEMINI_API_KEY\n * (aistudio.google.com -> Get API key, senza carta)\n * ===================================================================== */\n\nconst MODELLO = \"gemini-flash-latest\";\n// Se il primo è a quota, si ripiega sul secondo: Flash-Lite ha limiti\n// più larghi e per un brief la differenza di qualità è modesta.\n// I modelli numerati sono meno soggetti a sovraccarico degli alias\n// \"latest\", che sono il default di tutti e quindi i più affollati.\nconst RIPIEGHI = [\n \"gemini-3.5-flash\",\n \"gemini-3.5-flash-lite\",\n \"gemini-flash-lite-latest\",\n];\n// 429 = quota, 5xx = sovraccarico temporaneo. Entrambi passano, con\n// attese diverse: il sovraccarico si risolve in secondi, la quota no.\nconst RIPROVABILI = [429, 500, 502, 503, 504];\n// Due tentativi, non tre: ogni tentativo è una richiesta, e su una quota\n// stretta la logica di riprova finisce per consumare ciò che difende.\nconst TENTATIVI = 2;\nconst ATTESA_BASE_MS = 5000;\n\n/** Modelli da sondare nella diagnostica, dal più capace al più leggero. */\nexport const CANDIDATI = [\n \"gemini-2.5-flash-lite\",\n \"gemini-flash-lite-latest\",\n \"gemini-flash-latest\",\n \"gemini-3.5-flash-lite\",\n \"gemini-3.5-flash\",\n \"gemini-2.5-flash\",\n];\nconst ENDPOINT = (m: string) =>\n `https://generativelanguage.googleapis.com/v1beta/models/${m}:generateContent`;\n\nconst ISTRUZIONI =\n `Sei l'analista che prepara il quadro mattutino di un desk personale.\n\nRispondi SOLO con JSON valido: nessun testo prima o dopo, nessun backtick.\n\nI numeri macro ti vengono forniti già calcolati. NON ricalcolarli e non\ninventarne altri. Ogni cifra che citi deve comparire nei dati ricevuti\noppure nelle fonti che trovi cercando.\n\nTi vengono forniti i titoli delle notizie recenti con la loro fonte. Usa\nquelli: non hai accesso al web e non devi fingere di averlo. Se una\nnotizia ti sembra importante ma il titolo non basta a spiegarla, dillo\ninvece di completare a intuito.\n\nIl tema del giorno è UNO solo: quello che davvero muove i prezzi oggi.\nNon elencare tutto ciò che è successo, scegli.\n\nStile: un analista che parla a voce a un collega la mattina presto.\nDiretto, niente entusiasmo, niente frasi di circostanza. Italiano.`;\n\nexport function promptBrief(macro: any, notizie: any[] = []) {\n const righe = Object.values(macro?.voci ?? {}).map((v: any) =>\n ` ${v.etichetta}: ${v.valore ?? \"n/d\"}${v.unita === \"%\" ? \"%\" : \"\"}` +\n (v.variazione !== null && v.variazione !== undefined\n ? ` (${\n v.variazione >= 0 ? \"+\" : \"\"\n }${v.variazione} sul precedente, rilevato ${v.data})`\n : \"\")\n ).join(\"\\n\");\n\n const curva = macro?.curva\n ? ` Curva 10 meno 2 anni: ${macro.curva.spread10meno2}${\n macro.curva.invertita ? \" — INVERTITA\" : \"\"\n }`\n : \" Curva: non disponibile\";\n\n const oggi = new Date().toLocaleDateString(\"it-IT\", {\n weekday: \"long\",\n day: \"numeric\",\n month: \"long\",\n year: \"numeric\",\n });\n\n const flusso = notizie.length\n ? notizie.slice(0, 25).map((x: any) =>\n ` [${x.fonte}${x.quando ? `, ${x.quando}` : \"\"}] ${x.titolo}` +\n (x.etichetta ? ` (sentiment ${x.etichetta})` : \"\")\n ).join(\"\\n\")\n : \" nessuna notizia recuperata: costruisci il brief sui soli numeri macro e dichiaralo\";\n\n return `${ISTRUZIONI}\n\nData di oggi: ${oggi}\n\nTITOLI RECENTI (unica fonte disponibile)\n${flusso}\n\nQUADRO MACRO GIÀ CALCOLATO\n${righe}\n${curva}\n\nRestituisci esattamente questa struttura:\n{\n \"unaRiga\": \"il quadro di oggi in massimo 20 parole\",\n \"tema\": {\n \"titolo\": \"massimo 8 parole\",\n \"spiegazione\": \"massimo 70 parole: cosa sta succedendo e perché sposta i prezzi\"\n },\n \"successo\": [\n { \"cosa\": \"massimo 15 parole\", \"perche\": \"massimo 20 parole: quale prezzo tocca e in che direzione\", \"fonte\": \"nome della fonte\" }\n ],\n \"letturaMacro\": \"massimo 50 parole: cosa dicono i numeri qui sopra messi insieme\",\n \"daGuardare\": [\n { \"evento\": \"massimo 10 parole\", \"quando\": \"es. oggi 14:30\", \"perche\": \"massimo 15 parole\" }\n ]\n}\nMassimo 5 voci in \"successo\", massimo 4 in \"daGuardare\".`;\n}\n\n/* ---------------------------- estrazione --------------------------- */\n\nexport function estraiJSON(raw: string) {\n const s = String(raw ?? \"\").replace(/```json/gi, \"\").replace(/```/g, \"\")\n .trim();\n const i = s.indexOf(\"{\");\n if (i === -1) throw new Error(\"nessun JSON nella risposta del modello\");\n let d = 0, str = false, esc = false;\n for (let k = i; k < s.length; k++) {\n const c = s[k];\n if (esc) {\n esc = false;\n continue;\n }\n if (c === \"\\\\\") {\n esc = true;\n continue;\n }\n if (c === '\"') {\n str = !str;\n continue;\n }\n if (str) continue;\n if (c === \"{\") d++;\n else if (c === \"}\" && --d === 0) return JSON.parse(s.slice(i, k + 1));\n }\n throw new Error(\"JSON troncato\");\n}\n\n/* ------------------------------ Gemini ----------------------------- */\n\n/**\n * Il grounding con Google Search sostituisce lo strumento di ricerca web.\n * Non si imposta responseMimeType a JSON: con la ricerca attiva Gemini\n * non accetta sempre l'output strutturato, quindi il formato lo chiede\n * il prompt e ci pensa estraiJSON.\n */\nconst attendi = (ms: number) => new Promise((r) => setTimeout(r, ms));\n\n/**\n * Distingue i due limiti del piano gratuito, che l'API segnala entrambi\n * con un 429. Quello al minuto passa da solo aspettando; quello\n * giornaliero no, e riprovare serve solo a bruciare tempo.\n */\nfunction analizza429(corpo: string) {\n const perGiorno = /PerDay|per day|daily/i.test(corpo);\n const ritardo = corpo.match(/\"retryDelay\"\\s*:\\s*\"(\\d+)s\"/);\n return {\n giornaliero: perGiorno,\n attesaSuggerita: ritardo ? Number(ritardo[1]) * 1000 : null,\n };\n}\n\nasync function unaChiamata(\n prompt: string,\n modello: string,\n conRicerca = false,\n) {\n const key = Deno.env.get(\"GEMINI_API_KEY\");\n if (!key) {\n throw new Error(\n \"GEMINI_API_KEY non configurata nelle variabili d'ambiente\",\n );\n }\n\n const res = await fetch(`${ENDPOINT(modello)}?key=${key}`, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\" },\n body: JSON.stringify({\n contents: [{ role: \"user\", parts: [{ text: prompt }] }],\n // Il grounding con Google Search ha una quota propria, molto più\n // stretta di quella del modello: sul piano gratuito si esaurisce\n // subito e restituisce un 429 che nessuna attesa risolve. Le\n // notizie gliele passiamo noi da Alpha Vantage.\n ...(conRicerca ? { tools: [{ google_search: {} }] } : {}),\n generationConfig: { temperature: 0.3, maxOutputTokens: 2048 },\n }),\n });\n\n if (!res.ok) {\n const corpo = await res.text();\n const err: any = new Error(\n `Gemini ${modello}: HTTP ${res.status} — ${corpo.slice(0, 400)}`,\n );\n err.stato = res.status;\n err.corpo = corpo;\n throw err;\n }\n\n const d = await res.json();\n const testo = (d?.candidates?.[0]?.content?.parts ?? [])\n .map((p: any) => p.text ?? \"\").join(\"\\n\");\n if (!testo.trim()) {\n throw new Error(`Gemini ${modello} ha risposto senza testo`);\n }\n\n const fonti = (d?.candidates?.[0]?.groundingMetadata?.groundingChunks ?? [])\n .map((c: any) => c?.web?.title).filter(Boolean).slice(0, 8);\n\n return { brief: estraiJSON(testo), fonti, modello };\n}\n\n/**\n * Attesa crescente sui limiti temporanei, poi ripiego su un altro modello.\n * Serve soprattutto al cron: senza, un 429 momentaneo alle 5:00 farebbe\n * saltare il brief di tutta la giornata, e te ne accorgeresti solo\n * aprendo la pagina e trovandola vecchia.\n */\nexport async function chiamaGemini(\n prompt: string,\n modello = MODELLO,\n conRicerca = false,\n) {\n const catena = [modello, ...RIPIEGHI];\n let ultimo: any = null;\n\n for (const m of catena) {\n for (let tentativo = 1; tentativo <= TENTATIVI; tentativo++) {\n try {\n return await unaChiamata(prompt, m, conRicerca);\n } catch (e: any) {\n ultimo = e;\n if (!RIPROVABILI.includes(e?.stato)) throw e; // errore vero: inutile insistere\n\n if (e.stato !== 429) { // sovraccarico: attesa breve\n if (tentativo === TENTATIVI) break;\n await attendi(2000 * tentativo);\n continue;\n }\n\n const { giornaliero, attesaSuggerita } = analizza429(\n String(e.corpo ?? \"\"),\n );\n if (giornaliero) break; // quota del giorno: passa al ripiego\n if (tentativo === TENTATIVI) break;\n\n await attendi(attesaSuggerita ?? ATTESA_BASE_MS * 2 ** (tentativo - 1));\n }\n }\n }\n\n const corpo = String(ultimo?.corpo ?? \"\");\n if (ultimo?.stato && ultimo.stato >= 500) {\n throw new Error(\n `Gemini: tutti i modelli sovraccarichi (${catena.join(\", \")}). ` +\n `È temporaneo e si risolve da solo: riprova fra qualche minuto, o aspetta il cron di domattina.`,\n );\n }\n const { giornaliero } = analizza429(corpo);\n // Il corpo grezzo va mostrato: senza, l'unica diagnosi possibile è\n // indovinare, ed è già costato due giri.\n const dettaglio = corpo.replace(/\\s+/g, \" \").slice(0, 300);\n throw new Error(\n giornaliero\n ? `Gemini: quota giornaliera esaurita su tutti i modelli (${\n catena.join(\", \")\n }). Si azzera a mezzanotte del Pacifico, verso le 9 in Italia. Dettaglio: ${dettaglio}`\n : `Gemini: 429 persistente su ${\n catena.join(\", \")\n } dopo ${TENTATIVI} tentativi ciascuno. Apri /gemini per capire quali modelli accetta la tua chiave. Dettaglio: ${dettaglio}`,\n );\n}\n\nexport async function generaBrief(macro: any, notizie: any[] = []) {\n const { brief, modello } = await chiamaGemini(promptBrief(macro, notizie));\n return {\n generato: new Date().toISOString(),\n modello,\n fontiConsultate: [\n ...new Set(notizie.map((x: any) => x.fonte).filter(Boolean)),\n ].slice(0, 8),\n titoliUsati: notizie.length,\n ...brief,\n };\n}\n\n/* ------------------------------ pagina ----------------------------- */\n\nconst esc = (s: unknown) =>\n String(s ?? \"\")\n .replace(/&/g, \"&\").replace(//g, \">\");\n\nexport function paginaHTML(brief: any, macro: any) {\n const oggi = new Date().toLocaleDateString(\"it-IT\", {\n weekday: \"long\",\n day: \"numeric\",\n month: \"long\",\n });\n const ora = brief?.generato\n ? new Date(brief.generato).toLocaleTimeString(\"it-IT\", {\n hour: \"2-digit\",\n minute: \"2-digit\",\n })\n : \"—\";\n\n const celle = Object.values(macro?.voci ?? {}).map((v: any) => {\n const dv = v.variazione;\n const cls = dv > 0 ? \"up\" : dv < 0 ? \"dn\" : \"\";\n return `

${esc(v.etichetta)}

${esc(v.valore ?? \"n/d\")}${\n v.unita === \"%\" ? \"%\" : \"\"\n }

${\n dv !== null && dv !== undefined\n ? `${dv >= 0 ? \"+\" : \"\"}${esc(dv)}`\n : \"—\"\n }${v.data ? ` · ${esc(v.data)}` : \"\"}

`;\n }).join(\"\");\n\n const curva = macro?.curva\n ? `

\n Curva 10 meno 2 anni\n

= 0 ? \"up\" : \"dn\"\n }\">${macro.curva.spread10meno2 >= 0 ? \"+\" : \"\"}${\n esc(macro.curva.spread10meno2)\n }${\n macro.curva.invertita ? 'invertita' : \"\"\n }

`\n : \"\";\n\n const lista = (arr: any[], render: (x: any) => string) =>\n (arr ?? []).map((x) => `

${render(x)}

`).join(\"\");\n\n return `\n\n\n\n\n\n\nBrief · ${esc(oggi)}\n\n\n

\n\n

BRIEF

\n ${esc(oggi)}\n generato ${esc(ora)}\n

\n\n

${esc(brief?.unaRiga)}

\n\n

Il tema di oggi

${esc(brief?.tema?.titolo)}

${esc(brief?.tema?.spiegazione)}

\n\n${\n brief?.successo?.length\n ? `

Cosa è successo

${\n lista(brief.successo, (s) =>\n `

${esc(s.cosa)}

${esc(s.perche)}

` +\n (s.fonte ? `${esc(s.fonte)}` : \"\"))\n }

`\n : \"\"\n }\n\n

I numeri

${celle}

\n ${curva}\n ${\n macro?.errori?.length\n ? `

non recuperate: ${\n esc(macro.errori.join(\" · \"))\n }

`\n : \"\"\n }\n

\n\n${\n brief?.letturaMacro\n ? `

Lettura

${\n esc(brief.letturaMacro)\n }

`\n : \"\"\n }\n\n${\n brief?.daGuardare?.length\n ? `

Da guardare

${\n lista(brief.daGuardare, (d) =>\n `

${esc(d.quando)} ${\n esc(d.evento)\n }

` +\n `

${esc(d.perche)}

`)\n }

`\n : \"\"\n }\n\n

\n ${esc(brief?.modello ?? \"\")}${\n brief?.fontiConsultate?.length\n ? ` · fonti: ${esc(brief.fontiConsultate.join(\", \"))}`\n : \"\"\n }\n
I numeri macro vengono dal motore, non dal modello.\n

\n\n

`;\n}\n\n/* --------------------------- diagnostica --------------------------- */\n\n/**\n * Sonda ogni modello candidato con un prompt minimo e riporta cosa\n * risponde. Serve a distinguere tre casi che dall'esterno sembrano\n * identici: modello inesistente (404), modello escluso dal piano\n * gratuito (429 con quota zero), quota davvero esaurita (429 con\n * quotaId che nomina il periodo).\n *\n * Costa una richiesta per modello, ma sono le più piccole possibili.\n */\nexport async function diagnostica() {\n const key = Deno.env.get(\"GEMINI_API_KEY\");\n if (!key) return [{ modello: \"-\", esito: \"GEMINI_API_KEY non configurata\" }];\n\n const esiti: any[] = [];\n for (const m of CANDIDATI) {\n try {\n const res = await fetch(`${ENDPOINT(m)}?key=${key}`, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\" },\n body: JSON.stringify({\n contents: [{ role: \"user\", parts: [{ text: \"Rispondi solo: ok\" }] }],\n generationConfig: { maxOutputTokens: 8 },\n }),\n });\n if (res.ok) {\n esiti.push({ modello: m, stato: 200, esito: \"FUNZIONA\" });\n } else {\n const corpo = (await res.text()).replace(/\\s+/g, \" \");\n const quota = corpo.match(/\"quotaId\"\\s*:\\s*\"([^\"]+)\"/)?.[1] ?? null;\n const valore = corpo.match(/\"quotaValue\"\\s*:\\s*\"?(\\d+)\"?/)?.[1] ?? null;\n esiti.push({\n modello: m,\n stato: res.status,\n quotaId: quota,\n quotaValore: valore,\n esito: res.status === 404\n ? \"non disponibile per questa chiave\"\n : valore === \"0\"\n ? \"escluso dal piano gratuito (quota zero)\"\n : res.status === 429\n ? \"quota esaurita o limitata\"\n : \"errore\",\n dettaglio: corpo.slice(0, 200),\n });\n }\n } catch (e) {\n esiti.push({\n modello: m,\n esito: \"rete\",\n dettaglio: String((e as Error)?.message ?? e).slice(0, 120),\n });\n }\n await attendi(700); // rispetta i limiti al secondo mentre si sonda\n }\n\n // Il modello può funzionare e il grounding no: sono due quote distinte,\n // ed è esattamente la confusione che ha fatto perdere due giri.\n const primo = esiti.find((e) => e.esito === \"FUNZIONA\");\n if (primo) {\n try {\n const res = await fetch(`${ENDPOINT(primo.modello)}?key=${key}`, {\n method: \"POST\",\n headers: { \"Content-Type\": \"application/json\" },\n body: JSON.stringify({\n contents: [{ role: \"user\", parts: [{ text: \"Rispondi solo: ok\" }] }],\n tools: [{ google_search: {} }],\n generationConfig: { maxOutputTokens: 8 },\n }),\n });\n esiti.push({\n modello: `${primo.modello} + google_search`,\n stato: res.status,\n esito: res.ok\n ? \"FUNZIONA\"\n : \"grounding non disponibile (quota separata dal modello)\",\n dettaglio: res.ok\n ? null\n : (await res.text()).replace(/\\s+/g, \" \").slice(0, 200),\n });\n } catch { /* la diagnosi resta utile anche senza questa prova */ }\n }\n return esiti;\n}",[274],"pulls","branches",1,"forks","envVars",{"_289":291,"_292":26},"connections",{"_289":26,"_290":26},"count","unfilledCount",4,"emptyCount",{"_35":273,"_13":274,"_64":275,"_45":-5,"_37":38,"_184":276,"_186":95,"_39":343,"_41":278,"_67":68,"_189":279,"_69":24,"_191":-5,"_307":344,"_17":345},{"_35":266,"_13":267,"_64":268,"_45":-5,"_37":38,"_184":269,"_186":95,"_39":340,"_41":188,"_67":68,"_189":271,"_69":24,"_191":-5,"_307":341,"_17":342},{"_35":258,"_13":259,"_64":260,"_45":-5,"_37":38,"_184":261,"_186":95,"_39":337,"_41":233,"_67":263,"_189":264,"_69":24,"_191":-5,"_307":338,"_17":339},{"_35":251,"_13":252,"_64":253,"_45":-5,"_37":38,"_184":254,"_186":95,"_39":334,"_41":248,"_67":68,"_189":256,"_69":24,"_191":-5,"_307":335,"_17":336},{"_35":243,"_13":244,"_64":245,"_45":-5,"_37":38,"_184":246,"_186":95,"_39":331,"_41":248,"_67":68,"_189":249,"_69":24,"_191":-5,"_307":332,"_17":333},{"_35":236,"_13":237,"_64":238,"_45":-5,"_37":38,"_184":239,"_186":95,"_39":328,"_41":188,"_67":68,"_189":241,"_69":24,"_191":-5,"_307":329,"_17":330},{"_35":228,"_13":229,"_64":230,"_45":-5,"_37":38,"_184":231,"_186":95,"_39":325,"_41":233,"_67":68,"_189":234,"_69":24,"_191":-5,"_307":326,"_17":327},{"_35":221,"_13":222,"_64":107,"_45":-5,"_37":38,"_184":134,"_186":95,"_39":322,"_41":224,"_67":225,"_189":226,"_69":24,"_191":-5,"_307":323,"_17":324},{"_35":214,"_13":215,"_64":216,"_45":-5,"_37":38,"_184":217,"_186":95,"_39":319,"_41":188,"_67":68,"_189":219,"_69":24,"_191":-5,"_307":320,"_17":321},{"_35":207,"_13":208,"_64":209,"_45":-5,"_37":38,"_184":210,"_186":95,"_39":316,"_41":188,"_67":68,"_189":212,"_69":24,"_191":-5,"_307":317,"_17":318},{"_35":200,"_13":201,"_64":202,"_45":-5,"_37":38,"_184":203,"_186":95,"_39":313,"_41":188,"_67":68,"_189":205,"_69":24,"_191":-5,"_307":314,"_17":315},{"_35":193,"_13":194,"_64":195,"_45":-5,"_37":38,"_184":196,"_186":95,"_39":310,"_41":188,"_67":68,"_189":198,"_69":24,"_191":-5,"_307":311,"_17":312},{"_35":181,"_13":182,"_64":183,"_45":-5,"_37":38,"_184":185,"_186":95,"_39":306,"_41":188,"_67":68,"_189":190,"_69":24,"_191":-5,"_307":308,"_17":309},["D",1788901092981],"children",[],[182],["D",1789132433139],[],[194],["D",1789132465877],[],[201],["D",1789132452917],[],[208],["D",1788901455880],[],[215],["D",1789132642565],[],[222],["D",1788900908496],[],[229],["D",1788900591280],[],[237],["D",1788879199392],[],[244],["D",1788901174031],[],[252],["D",1788900300372],[],[259],["D",1788894870909],[],[267],["D",1788950057578],[],[274],["D",1788877625254],["D",1789572079973],{"_11":12,"_147":72},{"_11":12,"_143":72,"_71":72,"_30":70,"_144":145,"_146":24},{"_41":134,"_13":16,"_35":38,"_135":97,"_136":-5,"_137":-5,"_138":-5,"_139":-5,"_140":-5,"_141":14,"_142":12},"ctx",{"_54":-5,"_165":384,"_385":386,"_387":388,"_389":24,"_390":24,"_391":24,"_392":95,"_393":-5,"_394":-7,"_395":-7,"_396":26,"_397":24,"_398":24,"_399":-5,"_400":24,"_401":24,"_402":24,"_403":-5},"ENV",{"_355":356,"_357":358,"_359":16,"_360":361,"_362":363,"_364":365,"_366":367,"_368":369,"_370":371,"_372":373,"_374":375,"_376":377,"_378":379,"_380":381,"_382":383},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","811aa22498c9b0b5a47e8d778de579cdb990f332","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]

History · prezzi.ts