\n ${\n c.score ?? \"—\"\n }\n ${esc(c.etichetta)}\n ${st.sigla}\n ${val}\n

${esc(c.spiega)}

${soglie}${\n c.pesoNelGruppo ? ` · peso nel gruppo ${esc(c.pesoNelGruppo)}%` : \"\"\n } · ${esc(st.titolo)}

`;\n}\n\nfunction gruppo(id: string, g: any) {\n if (!g) return \"\";\n const criteri = (g.criteri ?? []).map(criterio).join(\"\");\n const peso = g.peso\n ? ` · ${(g.peso * 100).toFixed(1)}% del Company Score`\n : \"\";\n const cop = g.copertura !== undefined && g.copertura < 1\n ? ` · copertura ${(g.copertura * 100).toFixed(0)}%`\n : \"\";\n return `

\n ${\n g.score === null || g.score === undefined ? \"—\" : Math.round(g.score)\n }\n ${barra(g.score ?? null)}\n ${esc(ETICHETTE[id] ?? id)}\n

${esc(peso + cop).replace(/^ · /, \"\")}

\n ${criteri}\n

`;\n}\n\nexport function paginaTitolo(r: any, extra: any = {}) {\n const { facts, giudizi, scenari, valutazioni, notizie } = extra;\n const mos = r.marginOfSafety;\n const posPrezzo = r.fairValue && r.prezzo\n ? Math.min(\n 97,\n Math.max(3, (r.prezzo / Math.max(r.prezzo, r.fairValue)) * 100),\n )\n : null;\n const posFv = r.fairValue && r.prezzo\n ? Math.min(\n 97,\n Math.max(3, (r.fairValue / Math.max(r.prezzo, r.fairValue)) * 100),\n )\n : null;\n\n const am = r.aspettativeMercato ?? {};\n const gate = (r.gateApplicati ?? []).map((g: any) =>\n `

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

${esc(g.motivo)}

`\n ).join(\"\");\n\n const righeScenari = scenari?.scenari?.length\n ? `\n \n ${\n scenari.scenari.map((s: any) =>\n `\n \n \n \n `\n ).join(\"\")\n }\n \n \n

scenario	crescita	fair value	rendimento	prob.
${esc(s.caso)}	${pct(s.crescitaRicavi)}	${num(s.fairValue)}	= 0 ? \"up\" : \"dn\"}\">${pct(s.upside, 0)}	${(s.probabilita * 100).toFixed(0)}%
atteso	${\n num(scenari.fairValueAtteso)\n }	= 0 ? \"up\" : \"dn\"}\">${\n pct(scenari.rendimentoAtteso, 0)\n }

${\n scenari.avvertenza ? `

${esc(scenari.avvertenza)}

` : \"\"\n }`\n : \"\";\n\n const evidenze =\n giudizi?.moat?.evidenze && Object.keys(giudizi.moat.evidenze).length\n ? `

Su cosa poggia il vantaggio

\n ${\n giudizi.moat.fonteDelVantaggio\n ? `

${esc(giudizi.moat.fonteDelVantaggio)}

`\n : \"\"\n }\n ${\n Object.entries(giudizi.moat.evidenze).map(([k, v]) =>\n `

${esc(k)}

${\n esc(v)\n }

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

`\n : \"\";\n\n const scarti = giudizi?.scartati?.length\n ? `

Giudizi scartati in validazione

${esc(s)}

`\n : \"\";\n\n return `\n\n\n\n\n\n${esc(r.ticker)} · scheda\n\n\n

\n\n

${esc(r.ticker)}${\n facts?.nome ? ` ${esc(facts.nome)}` : \"\"\n }

${esc(facts?.settore ?? \"\")}${\n facts?.dataPrezzo ? ` · prezzo al ${esc(facts.dataPrezzo)}` : \"\"\n }

\n\n

${\n r.companyScore ?? \"—\"\n }

COMPANY SCORE

${\n r.investmentScore ?? \"—\"\n }

INVESTMENT SCORE

${\n r.confidence ?? \"—\"\n }

CONFIDENCE

\n\n

${esc(r.verdetto)}

\n\n

Prezzo e fair value

\n prezzo ${num(r.prezzo)}\n fair value ${num(r.fairValue)}\n

\n ${\n posPrezzo !== null\n ? ``\n : \"\"\n }\n ${\n posFv !== null\n ? ``\n : \"\"\n }\n

= 0 ? \"up\" : \"dn\"}\">${\n mos === null || mos === undefined\n ? \"—\"\n : (mos >= 0 ? \"+\" : \"\") + mos.toFixed(1) + \"%\"\n }\n MARGINE DI SICUREZZA

\n ${\n valutazioni\n ? `\n \n ${\n r.dcf\n ? ``\n : \"\"\n }\n ${\n valutazioni.storica\n ? ``\n : \"\"\n }\n ${\n valutazioni.relativa\n ? ``\n : \"\"\n }\n ${\n valutazioni.crescita\n ? ``\n : \"\"\n }\n \n

metodo	fair value	riferimento
DCF	${\n num(r.dcf.valorePerAzione)\n }	terminal ${\n pct(r.dcf.quotaTerminal, 0)\n } del valore
storico	${\n num(valutazioni.storica.fairValue)\n }	P/E mediano ${num(valutazioni.storica.peMediano, 1)} su ${\n esc(valutazioni.storica.esercizi)\n } esercizi
comparabili	${\n num(valutazioni.relativa.fairValue)\n }	P/E mediano ${num(valutazioni.relativa.peMediano, 1)} · ${\n esc((valutazioni.relativa.comparabili ?? []).join(\" \"))\n }
crescita	${\n num(valutazioni.crescita.fairValue)\n }	multiplo ${\n num(valutazioni.crescita.multiploImplicito, 1)\n } su crescita ${pct(valutazioni.crescita.crescitaUsata, 0)}
composito	${num(r.fairValue)}

\n ${\n valutazioni.note?.length\n ? `

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

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

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

\n\n

Cosa sconta il mercato

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

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

\n\n${\n gate\n ? `

Penalizzazioni applicate

${gate}\n

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

`\n : \"\"\n }\n\n${\n righeScenari\n ? `

Scenari

${righeScenari}\n

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

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

I criteri, uno per uno

Tocca un criterio per leggere cosa misura, con quali soglie e quanto pesa.

\n ${ORDINE.map((k) => gruppo(k, r.dettaglio?.[k])).join(\"\")}\n

\n\n${evidenze}\n${notizie?.length ? bloccoNotizie(notizie, \"Notizie recenti\") : \"\"}\n${scarti}\n\n

\n F dato di bilancio\n D calcolato dal codice\n S stima da ipotesi\n G giudizio dell'AI\n

\n ${esc(r.provenienza?.fonte ?? \"\")}${\n r.copertura\n ? ` · copertura dati ${(r.copertura.quota * 100).toFixed(0)}% su ${\n esc(r.copertura.esercizi)\n } esercizi`\n : \"\"\n }${\n giudizi?.modelli?.length\n ? ` · giudizi da ${esc(giudizi.modelli.join(\", \"))}`\n : \"\"\n }\n
Nessun punteggio viene dal modello: l'AI compila solo le voci marcate G.\n

\n\n

`;\n}",[159],"b565a0fc-794a-48f9-b8e6-c36c28fd5eb4","struttura.ts","8d81adfe-ac40-11f1-b5a6-1607ee4eb77e",74,["D",1788952877317],"/* =====================================================================\n * STRUTTURA — Fase 1 del motore SMC\n * ---------------------------------------------------------------\n * Swing, HH/HL/LH/LL, regime, BOS, CHoCH, MSS.\n *\n * Tutto viene calcolato in una sola passata sulle barre, in avanti,\n * mantenendo lo stato che il sistema avrebbe avuto in quel momento.\n * Alla barra `i` sono confermati solo gli swing con `indice + n <= i`:\n * è il motivo per cui un BOS non può essere datato prima della\n * conferma dello swing che rompe, che è l'errore che gonfia di più le\n * statistiche nei backtest SMC.\n *\n * Le soglie vengono dalla specifica approvata. Ognuna è un parametro,\n * nessuna è una verità: vanno tutte validate nella Fase 7.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport { atr } from \"./prezzi.ts\";\nimport { creaEvento, type Evento, type TipoEvento } from \"./eventi.ts\";\n\nexport const PARAMETRI = {\n pivotN: 2, // 3.1 opzione A [da testare: 2, 3]\n bufferAtr: 0.05, // 3.2 opzione B [0, 0.05, 0.10]\n dispMinAtr: 1.0, // displacement [0.75, 1.0, 1.25]\n dispBodyRange: 0.70, // [0.60, 0.70, 0.80]\n dispClosePos: 0.80, // e 0.20 speculare per il ribasso\n mssFinestra: 3, // barre entro cui il displacement qualifica il CHoCH\n atrPeriodo: 14,\n};\n\nexport type Regime = \"BULLISH\" | \"BEARISH\" | \"NEUTRAL\";\n\nexport type Swing = {\n indice: number;\n confermaIndice: number;\n tipo: \"HIGH\" | \"LOW\";\n prezzo: number;\n classe: \"HH\" | \"HL\" | \"LH\" | \"LL\" | null;\n consumato: boolean; // già usato per un BOS o CHoCH\n};\n\n/* ------------------------------ swing ------------------------------ */\n\n/**\n * Frattale puro: `n` barre più alte da entrambi i lati.\n * Lo swing all'indice `i` è conoscibile solo dall'indice `i + n`.\n */\nexport function trovaSwing(barre: Barra[], n = PARAMETRI.pivotN): Swing[] {\n const out: Swing[] = [];\n for (let i = n; i < barre.length - n; i++) {\n let alto = true, basso = true;\n for (let k = 1; k <= n; k++) {\n if (!(barre[i].h > barre[i - k].h && barre[i].h > barre[i + k].h)) {\n alto = false;\n }\n if (!(barre[i].l < barre[i - k].l && barre[i].l < barre[i + k].l)) {\n basso = false;\n }\n }\n if (alto) {\n out.push({\n indice: i,\n confermaIndice: i + n,\n tipo: \"HIGH\",\n prezzo: barre[i].h,\n classe: null,\n consumato: false,\n });\n }\n if (basso) {\n out.push({\n indice: i,\n confermaIndice: i + n,\n tipo: \"LOW\",\n prezzo: barre[i].l,\n classe: null,\n consumato: false,\n });\n }\n }\n return out.sort((a, b) =>\n a.confermaIndice - b.confermaIndice || a.indice - b.indice\n );\n}\n\n/* -------------------------- displacement --------------------------- */\n\nexport function displacement(b: Barra, atrVal: number | null, p = PARAMETRI) {\n if (atrVal === null || atrVal <= 0) return null;\n const corpo = Math.abs(b.c - b.o);\n const range = b.h - b.l;\n if (range <= 0) return null;\n const posChiusura = (b.c - b.l) / range;\n const rapporto = corpo / atrVal;\n\n const comune = corpo >= p.dispMinAtr * atrVal &&\n corpo / range >= p.dispBodyRange;\n if (!comune) return null;\n\n if (b.c > b.o && posChiusura >= p.dispClosePos) {\n return {\n direzione: \"BULL\" as const,\n rapporto,\n corpoRange: corpo / range,\n posChiusura,\n livello: rapporto >= 2 ? 3 : rapporto >= 1.5 ? 2 : 1,\n };\n }\n if (b.o > b.c && posChiusura <= 1 - p.dispClosePos) {\n return {\n direzione: \"BEAR\" as const,\n rapporto,\n corpoRange: corpo / range,\n posChiusura,\n livello: rapporto >= 2 ? 3 : rapporto >= 1.5 ? 2 : 1,\n };\n }\n return null;\n}\n\n/* ---------------------------- passata ------------------------------ */\n\n/**\n * Una sola passata in avanti. Restituisce gli eventi con i due timestamp\n * già impostati e la serie di regime barra per barra.\n */\nexport function analizzaStruttura(\n barre: Barra[],\n ticker: string,\n timeframe: string,\n p = PARAMETRI,\n) {\n const a = atr(barre, p.atrPeriodo);\n const swings = trovaSwing(barre, p.pivotN);\n const eventi: Evento[] = [];\n const serieRegime: (Regime | null)[] = new Array(barre.length).fill(null);\n\n // swing raggruppati per barra di conferma: alla barra i entrano in gioco\n // quelli con confermaIndice === i\n const perConferma = new Map();\n for (const s of swings) {\n if (!perConferma.has(s.confermaIndice)) {\n perConferma.set(s.confermaIndice, []);\n }\n perConferma.get(s.confermaIndice)!.push(s);\n }\n\n const altiConfermati: Swing[] = [];\n const bassiConfermati: Swing[] = [];\n let regime: Regime = \"NEUTRAL\";\n\n const aggiungi = (\n tipo: TipoEvento,\n i: number,\n ritardo: number,\n extra: any = {},\n ) => {\n try {\n eventi.push(\n creaEvento(\n { ticker, timeframe, tipo, prezzo: barre[i].c, ...extra },\n barre,\n i,\n ritardo,\n ),\n );\n } catch { /* fuori serie: l'evento non è ancora confermabile, si scarta */ }\n };\n\n for (let i = 0; i < barre.length; i++) {\n // 1. entrano gli swing che diventano conoscibili adesso\n for (const s of perConferma.get(i) ?? []) {\n const lista = s.tipo === \"HIGH\" ? altiConfermati : bassiConfermati;\n const prec = lista[lista.length - 1];\n if (prec) {\n s.classe = s.tipo === \"HIGH\"\n ? (s.prezzo > prec.prezzo ? \"HH\" : \"LH\")\n : (s.prezzo > prec.prezzo ? \"HL\" : \"LL\");\n aggiungi(s.classe as TipoEvento, s.indice, p.pivotN, {\n prezzo: s.prezzo,\n });\n }\n aggiungi(\n s.tipo === \"HIGH\" ? \"SWING_HIGH\" : \"SWING_LOW\",\n s.indice,\n p.pivotN,\n { prezzo: s.prezzo },\n );\n lista.push(s);\n }\n\n // 2. regime dagli ultimi due swing confermati per lato\n const [ph, h] = altiConfermati.slice(-2);\n const [pl, l] = bassiConfermati.slice(-2);\n if (h && ph && l && pl) {\n if (h.prezzo > ph.prezzo && l.prezzo > pl.prezzo) regime = \"BULLISH\";\n else if (h.prezzo < ph.prezzo && l.prezzo < pl.prezzo) regime = \"BEARISH\";\n else regime = \"NEUTRAL\";\n }\n serieRegime[i] = regime;\n\n // 3. rotture: stesso movimento, nome diverso a seconda del regime\n const atrI = a[i];\n if (atrI === null) continue;\n const buffer = p.bufferAtr * atrI;\n const disp = displacement(barre[i], atrI, p);\n\n const ultimoAlto = [...altiConfermati].reverse().find((s) => !s.consumato);\n const ultimoBasso = [...bassiConfermati].reverse().find((s) =>\n !s.consumato\n );\n\n if (ultimoAlto && barre[i].c > ultimoAlto.prezzo + buffer) {\n // Consumare anche i massimi più bassi: se il prezzo ha chiuso sopra\n // questo livello è per forza sopra tutti quelli sotto, quindi\n // romperli nelle barre successive non è una rottura nuova ma lo\n // stesso movimento contato di nuovo.\n for (const s of altiConfermati) {\n if (s.prezzo <= ultimoAlto.prezzo) s.consumato = true;\n }\n const controTendenza = regime === \"BEARISH\";\n const forza = qualita(\n barre[i],\n atrI,\n barre[i].c - ultimoAlto.prezzo,\n disp,\n );\n aggiungi(controTendenza ? \"CHOCH_BULL\" : \"BOS_BULL\", i, 0, {\n forza,\n dati: {\n livelloRotto: ultimoAlto.prezzo,\n regimePrima: regime,\n buffer: +buffer.toFixed(6),\n },\n });\n // 4. MSS: un CHoCH accompagnato da displacement entro la finestra\n if (controTendenza) {\n const j = trovaDisplacement(barre, a, i, p.mssFinestra, \"BULL\", p);\n if (j !== null) {\n aggiungi(\"MSS_BULL\", j, 0, {\n forza,\n dati: {\n chochBarra: i,\n livelloRotto: ultimoAlto.prezzo,\n regimePrima: regime,\n },\n });\n }\n }\n }\n\n if (ultimoBasso && barre[i].c < ultimoBasso.prezzo - buffer) {\n for (const s of bassiConfermati) {\n if (s.prezzo >= ultimoBasso.prezzo) s.consumato = true;\n }\n const controTendenza = regime === \"BULLISH\";\n const forza = qualita(\n barre[i],\n atrI,\n ultimoBasso.prezzo - barre[i].c,\n disp,\n );\n aggiungi(controTendenza ? \"CHOCH_BEAR\" : \"BOS_BEAR\", i, 0, {\n forza,\n dati: {\n livelloRotto: ultimoBasso.prezzo,\n regimePrima: regime,\n buffer: +buffer.toFixed(6),\n },\n });\n if (controTendenza) {\n const j = trovaDisplacement(barre, a, i, p.mssFinestra, \"BEAR\", p);\n if (j !== null) {\n aggiungi(\"MSS_BEAR\", j, 0, {\n forza,\n dati: {\n chochBarra: i,\n livelloRotto: ultimoBasso.prezzo,\n regimePrima: regime,\n },\n });\n }\n }\n }\n\n if (disp) {\n aggiungi(\n disp.direzione === \"BULL\" ? \"DISPLACEMENT_BULL\" : \"DISPLACEMENT_BEAR\",\n i,\n 0,\n {\n forza: Math.min(1, disp.rapporto / 2),\n dati: {\n livello: disp.livello,\n rapportoAtr: +disp.rapporto.toFixed(3),\n },\n },\n );\n }\n }\n\n return { swings, eventi, serieRegime, atr: a, regimeFinale: regime };\n}\n\n/** Cerca il displacement che qualifica un CHoCH, entro la finestra ammessa. */\nfunction trovaDisplacement(\n barre: Barra[],\n a: (number | null)[],\n da: number,\n finestra: number,\n direzione: \"BULL\" | \"BEAR\",\n p: typeof PARAMETRI,\n) {\n for (let k = da; k <= Math.min(barre.length - 1, da + finestra); k++) {\n const d = displacement(barre[k], a[k], p);\n if (d && d.direzione === direzione) return k;\n }\n return null;\n}\n\n/** Qualità della rottura, 0-1. Pesi dalla tabella di specifica. */\nfunction qualita(b: Barra, atrVal: number, distanza: number, disp: any) {\n const range = b.h - b.l;\n const corpoRange = range > 0 ? Math.abs(b.c - b.o) / range : 0;\n const q = 0.4 * Math.min(1, (disp?.rapporto ?? 0) / 1.5) +\n 0.3 * corpoRange +\n 0.3 * Math.min(1, distanza / atrVal);\n return +q.toFixed(3);\n}\n\nexport const etichettaQualita = (q: number | null) =>\n q === null ? \"n/d\" : q < 0.5 ? \"weak\" : q > 1.0 ? \"strong\" : \"normal\";\n\n/* ------------------------------- bias ------------------------------ */\n\n/**\n * Sezione 17: il bias deriva solo da eventi misurabili.\n * Rialzista = ultimo BOS o MSS rialzista senza MSS ribassista successivo.\n */\nexport function bias(eventi: Evento[], asOf: string): {\n bias: \"BULLISH\" | \"BEARISH\" | \"NEUTRAL\" | \"TRANSITIONAL\";\n da: Evento | null;\n} {\n const visibili = eventi\n .filter((e) => e.confermato <= asOf)\n .filter((e) =>\n [\n \"BOS_BULL\",\n \"BOS_BEAR\",\n \"MSS_BULL\",\n \"MSS_BEAR\",\n \"CHOCH_BULL\",\n \"CHOCH_BEAR\",\n ].includes(e.tipo)\n )\n .sort((a, b) => a.confermato.localeCompare(b.confermato));\n if (!visibili.length) return { bias: \"NEUTRAL\", da: null };\n\n const ultimo = visibili[visibili.length - 1];\n if (ultimo.tipo === \"CHOCH_BULL\" || ultimo.tipo === \"CHOCH_BEAR\") {\n // un CHoCH senza displacement segnala possibile inversione, non ancora una direzione\n return { bias: \"TRANSITIONAL\", da: ultimo };\n }\n return {\n bias: ultimo.tipo.endsWith(\"BULL\") ? \"BULLISH\" : \"BEARISH\",\n da: ultimo,\n };\n}\n\n/** Bias per più timeframe, con aggregazione dichiarata invece che nascosta. */\nexport function biasAggregato(perTf: Record>) {\n const v = Object.values(perTf).map((x) => x.bias);\n const bull = v.filter((x) => x === \"BULLISH\").length;\n const bear = v.filter((x) => x === \"BEARISH\").length;\n return {\n perTimeframe: Object.fromEntries(\n Object.entries(perTf).map(([k, x]) => [k, x.bias]),\n ),\n aggregato: bull > bear && bull >= 2\n ? \"BULLISH\"\n : bear > bull && bear >= 2\n ? \"BEARISH\"\n : v.includes(\"TRANSITIONAL\")\n ? \"TRANSITIONAL\"\n : \"NEUTRAL\",\n concordi: Math.max(bull, bear),\n totali: v.length,\n };\n}",[167],"17140782-6284-4c90-af9c-7e863d03bfcc","smc.ts","2997d90e-ac99-11f1-bf3e-1607ee4eb77e",90,["D",1788991053481],3,"/* =====================================================================\n * SMC — Fase 5: punteggio, gate, macchina a stati\n * ---------------------------------------------------------------\n * Qui i rilevatori diventano un sistema. Tre idee portano il peso.\n *\n * 1. Gate e confluenza sono cose diverse. I gate sono necessari: se\n * manca un gate il setup non passa, e nessun punteggio lo promuove.\n * La confluenza alza la qualità di un setup che i gate hanno già\n * ammesso. Senza questa separazione un accumulo di elementi\n * correlati produce segnali che nessun gate ha mai autorizzato.\n *\n * 2. Displacement, FVG e Order Block nascono spesso dalla stessa\n * candela. Contarli tre volte gonfia il punteggio senza aggiungere\n * informazione, quindi vale il maggiore e gli altri vengono\n * dichiarati come assorbiti.\n *\n * 3. Ambiente e segnale sono separati. Un ambiente a 84/100 non è un\n * ingresso: dice che il contesto è favorevole. Lo stato del setup\n * è un'altra variabile e vive nella macchina a stati.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport type { Evento } from \"./eventi.ts\";\nimport {\n analizzaStruttura,\n bias,\n biasAggregato,\n trovaSwing,\n} from \"./struttura.ts\";\nimport { analizzaLiquidita } from \"./liquidita.ts\";\nimport { analizzaConsegna, zoneAttive } from \"./consegna.ts\";\nimport { analizzaPosizione, puntiLocation } from \"./posizione.ts\";\nimport { atr } from \"./prezzi.ts\";\nimport { costruisciSetup, valutaSetup } from \"./operativo.ts\";\n\nexport const PESI_SMC = {\n strutturaHtf: 20,\n liquidita: 20,\n mssChoch: 15,\n displacement: 15,\n fvg: 10,\n orderBlock: 10,\n premiumDiscount: 5,\n sessione: 5,\n};\n\nexport const PARAMETRI_SMC = {\n // Quanto resta a un elemento assorbito perché nato dalla stessa candela\n // di uno più pesante. Lo spec dice zero; un credito parziale è\n // difendibile e va misurato, non deciso a tavolino.\n assorbimento: 0,\n finestraSweepMss: 10, // barre entro cui il MSS deve seguire la sweep\n finestraZona: 30, // barre entro cui la zona resta utilizzabile\n};\n\nexport type Direzione = \"LONG\" | \"SHORT\";\n\nexport type Contributo = {\n componente: string;\n punti: number;\n massimo: number;\n motivo: string;\n origineBarra: number | null;\n assorbito?: string;\n};\n\n/* ---------------------------- punteggio ---------------------------- */\n\n/**\n * Applica la regola anti-doppio-conteggio ai contributi di price\n * delivery. Restituisce i contributi con l'assorbimento già applicato,\n * perché la sezione 18 chiede un punteggio spiegabile e non un numero.\n */\nexport function applicaAssorbimento(\n contributi: Contributo[],\n p = PARAMETRI_SMC,\n) {\n const consegna = new Set([\"displacement\", \"fvg\", \"orderBlock\"]);\n const perOrigine = new Map();\n\n for (const c of contributi) {\n if (!consegna.has(c.componente) || c.origineBarra === null) continue;\n if (!perOrigine.has(c.origineBarra)) perOrigine.set(c.origineBarra, []);\n perOrigine.get(c.origineBarra)!.push(c);\n }\n\n for (const [, gruppo] of perOrigine) {\n if (gruppo.length < 2) continue;\n const ordinati = [...gruppo].sort((a, b) => b.punti - a.punti);\n for (const c of ordinati.slice(1)) {\n c.assorbito = `stessa candela di ${ordinati[0].componente}`;\n c.punti = +(c.punti * p.assorbimento).toFixed(2);\n }\n }\n return contributi;\n}\n\nexport function smcScore(contributi: Contributo[]) {\n const finali = applicaAssorbimento(contributi);\n const totale = finali.reduce((s, c) => s + c.punti, 0);\n return {\n punteggio: Math.round(Math.min(100, Math.max(0, totale))),\n contributi: finali.filter((c) => c.punti > 0 || c.assorbito),\n assorbiti: finali.filter((c) => c.assorbito).length,\n };\n}\n\n/* ------------------------------ gate ------------------------------- */\n\nexport type Gate = { nome: string; superato: boolean; dettaglio: string };\n\n/**\n * I quattro gate obbligatori. Il quarto, sul rapporto rischio/rendimento,\n * arriva dalla Fase 6: finché non c'è, resta dichiarato come non valutato\n * invece di essere dato per buono.\n */\nexport function verificaGate(\n direzione: Direzione,\n ctx: any,\n rr: number | null = null,\n): { gate: Gate[]; tuttiSuperati: boolean } {\n const atteso = direzione === \"LONG\" ? \"BULLISH\" : \"BEARISH\";\n\n const g: Gate[] = [\n {\n nome: \"bias HTF concorde\",\n superato: ctx.bias?.aggregato === atteso,\n dettaglio: `bias ${ctx.bias?.aggregato ?? \"n/d\"}, atteso ${atteso}` +\n (ctx.bias\n ? ` (${ctx.bias.concordi}/${ctx.bias.totali} timeframe)`\n : \"\"),\n },\n {\n nome: \"liquidità presa\",\n superato: !!ctx.sweep,\n dettaglio: ctx.sweep\n ? `${ctx.sweep.tipo} su ${ctx.sweep.dati?.tipoLivello}, profondità ${ctx.sweep.dati?.profonditaAtr} ATR`\n : \"nessuna sweep nella direzione\",\n },\n {\n nome: \"MSS dopo la sweep\",\n superato: !!ctx.mss,\n dettaglio: ctx.mss\n ? `${ctx.mss.tipo} alla barra ${ctx.mss.barraIndice}`\n : \"nessun MSS confermato dopo la presa di liquidità\",\n },\n {\n nome: \"rapporto rischio/rendimento\",\n superato: rr !== null && rr >= 2,\n dettaglio: rr === null\n ? \"non ancora calcolato (Fase 6)\"\n : `R:R ${rr.toFixed(2)}`,\n },\n ];\n return { gate: g, tuttiSuperati: g.every((x) => x.superato) };\n}\n\n/* -------------------------- macchina a stati ----------------------- */\n\nexport type Stato =\n | \"NO_SETUP\"\n | \"WATCH\"\n | \"LIQUIDITY_SWEPT\"\n | \"MSS_CONFIRMED\"\n | \"ZONE_CREATED\"\n | \"WAITING_FOR_RETEST\"\n | \"RETEST_ACTIVE\"\n | \"ENTRY_CONFIRMED\"\n | \"TARGET_REACHED\"\n | \"INVALIDATED\";\n\nexport type Transizione = {\n barra: number;\n tempo: string;\n da: Stato;\n a: Stato;\n causa: string;\n};\n\n/**\n * Percorre le barre e ricostruisce la storia del setup.\n * Ogni transizione registra cosa l'ha causata: è la base della sezione\n * 35 della specifica, \"Score History\" e \"Since Last Session\".\n */\nexport function macchinaStati(\n barre: Barra[],\n direzione: Direzione,\n dati: any,\n p = PARAMETRI_SMC,\n): { stato: Stato; transizioni: Transizione[] } {\n const suffisso = direzione === \"LONG\" ? \"BULL\" : \"BEAR\";\n const ev = (tipi: string[]) =>\n dati.eventi.filter((e: Evento) => tipi.includes(e.tipo));\n\n const sweeps = ev([`SWEEP_${suffisso}`]);\n const mss = ev([`MSS_${suffisso}`]);\n const zone = dati.zone.filter((z: any) => z.direzione === suffisso);\n\n let stato: Stato = \"NO_SETUP\";\n const transizioni: Transizione[] = [];\n let sweepAttiva: Evento | null = null;\n let mssAttivo: Evento | null = null;\n let zonaAttiva: any = null;\n\n const vai = (a: Stato, i: number, causa: string) => {\n if (a === stato) return;\n transizioni.push({ barra: i, tempo: barre[i].t, da: stato, a, causa });\n stato = a;\n };\n\n for (let i = 0; i < barre.length; i++) {\n const b = barre[i];\n\n // il bias definito più una pool identificata basta per la sorveglianza\n if (stato === \"NO_SETUP\" && dati.livelliPerBarra?.(i)?.length) {\n vai(\"WATCH\", i, \"bias definito e liquidità identificata\");\n }\n\n const s = sweeps.find((e: Evento) => e.barraIndice === i);\n if (s && (stato === \"WATCH\" || stato === \"NO_SETUP\")) {\n sweepAttiva = s;\n vai(\"LIQUIDITY_SWEPT\", i, `presa liquidità su ${s.dati?.tipoLivello}`);\n }\n\n if (stato === \"LIQUIDITY_SWEPT\" && sweepAttiva) {\n if (i - sweepAttiva.barraIndice > p.finestraSweepMss) {\n vai(\n \"NO_SETUP\",\n i,\n `nessun MSS entro ${p.finestraSweepMss} barre dalla sweep`,\n );\n sweepAttiva = null;\n } else {\n const m = mss.find((e: Evento) =>\n e.barraIndice >= sweepAttiva!.barraIndice && e.barraIndice <= i\n );\n if (m) {\n mssAttivo = m;\n vai(\"MSS_CONFIRMED\", i, `${m.tipo} confermato`);\n }\n }\n }\n\n if (stato === \"MSS_CONFIRMED\" && mssAttivo) {\n const z = zone.find((x: any) =>\n x.confermaIndice <= i && x.confermaIndice >= mssAttivo!.barraIndice\n );\n if (z) {\n zonaAttiva = z;\n vai(\"ZONE_CREATED\", i, `${z.tipo} ${z.direzione} creata`);\n }\n }\n\n if (zonaAttiva) {\n const dentro = b.l <= zonaAttiva.alto && b.h >= zonaAttiva.basso;\n const oltre = direzione === \"LONG\"\n ? b.c < zonaAttiva.basso\n : b.c > zonaAttiva.alto;\n\n if (oltre) {\n vai(\"INVALIDATED\", i, \"chiusura oltre la zona\");\n zonaAttiva = null;\n sweepAttiva = null;\n mssAttivo = null;\n } else if (stato === \"ZONE_CREATED\" && !dentro) {\n vai(\"WAITING_FOR_RETEST\", i, \"il prezzo si allontana dalla zona\");\n } else if (\n (stato === \"WAITING_FOR_RETEST\" || stato === \"ZONE_CREATED\") &&\n dentro &&\n i > zonaAttiva.confermaIndice\n ) {\n vai(\"RETEST_ACTIVE\", i, \"il prezzo rientra nella zona\");\n } else if (\n stato === \"RETEST_ACTIVE\" &&\n i > zonaAttiva.confermaIndice + p.finestraZona\n ) {\n vai(\"INVALIDATED\", i, `zona scaduta dopo ${p.finestraZona} barre`);\n zonaAttiva = null;\n }\n }\n }\n\n return { stato, transizioni };\n}\n\n/* --------------------------- orchestratore ------------------------- */\n\n/**\n * Analisi completa su un timeframe. `biasHtf` arriva da fuori perché il\n * bias si calcola sui timeframe superiori, non su questo.\n */\nexport function analizzaSMC(\n barre: Barra[],\n ticker: string,\n timeframe: string,\n opzioni: { biasHtf?: any; profiloSessione?: any; asOf?: number } = {},\n) {\n const a = atr(barre, 14);\n const swings = trovaSwing(barre);\n const struttura = analizzaStruttura(barre, ticker, timeframe);\n const liquidita = analizzaLiquidita(barre, swings, a, ticker, timeframe, {\n profiloSessione: opzioni.profiloSessione ?? null,\n });\n const consegna = analizzaConsegna(\n barre,\n a,\n struttura.eventi,\n ticker,\n timeframe,\n );\n\n const i = opzioni.asOf ?? barre.length - 1;\n const posizione = analizzaPosizione(barre, swings, a, struttura.eventi, i);\n const eventi = [...struttura.eventi, ...liquidita.eventi, ...consegna.eventi];\n\n const biasLocale = bias(eventi, barre[i].t);\n const biasHtf = opzioni.biasHtf ?? biasAggregato({ [timeframe]: biasLocale });\n\n const dati = {\n barre,\n eventi,\n zone: consegna.zone,\n livelli: liquidita.livelli,\n atr: a,\n swings,\n livelliPerBarra: (k: number) =>\n liquidita.livelli.filter((l) => l.confermaIndice <= k),\n };\n\n const risultati: any = {};\n for (const direzione of [\"LONG\", \"SHORT\"] as Direzione[]) {\n const suffisso = direzione === \"LONG\" ? \"BULL\" : \"BEAR\";\n const visibili = eventi.filter((e) => e.confermato <= barre[i].t);\n\n const sweep = [...visibili].reverse().find((e) =>\n e.tipo === `SWEEP_${suffisso}`\n ) ?? null;\n const mssEv = [...visibili].reverse().find((e) =>\n e.tipo === `MSS_${suffisso}`\n ) ?? null;\n const mssValido =\n sweep && mssEv && mssEv.barraIndice >= sweep.barraIndice &&\n mssEv.barraIndice - sweep.barraIndice <= PARAMETRI_SMC.finestraSweepMss\n ? mssEv\n : null;\n\n const disp = [...visibili].reverse().find((e) =>\n e.tipo === `DISPLACEMENT_${suffisso}`\n ) ?? null;\n const zoneUsabili = zoneAttive(consegna.zone, barre, i, suffisso);\n const fvg = zoneUsabili.find((z) => z.zona.tipo === \"FVG\") ?? null;\n const ob = zoneUsabili.find((z) => z.zona.tipo === \"OB\") ?? null;\n const loc = puntiLocation(posizione.posizione, posizione.ote, direzione);\n\n const contributi: Contributo[] = [\n {\n componente: \"strutturaHtf\",\n punti:\n biasHtf.aggregato === (direzione === \"LONG\" ? \"BULLISH\" : \"BEARISH\")\n ? PESI_SMC.strutturaHtf\n : 0,\n massimo: PESI_SMC.strutturaHtf,\n motivo: `bias ${biasHtf.aggregato}`,\n origineBarra: null,\n },\n {\n componente: \"liquidita\",\n punti: sweep ? PESI_SMC.liquidita * (sweep.dati?.esterna ? 1 : 0.8) : 0,\n massimo: PESI_SMC.liquidita,\n motivo: sweep\n ? `sweep su ${sweep.dati?.tipoLivello}`\n : \"nessuna presa di liquidità\",\n origineBarra: sweep?.barraIndice ?? null,\n },\n {\n componente: \"mssChoch\",\n punti: mssValido ? PESI_SMC.mssChoch : 0,\n massimo: PESI_SMC.mssChoch,\n motivo: mssValido ? \"MSS dopo la sweep\" : \"nessun MSS valido\",\n origineBarra: mssValido?.barraIndice ?? null,\n },\n {\n componente: \"displacement\",\n punti: disp\n ? PESI_SMC.displacement * Math.min(1, (disp.dati?.livello ?? 1) / 2)\n : 0,\n massimo: PESI_SMC.displacement,\n motivo: disp ? `displacement livello ${disp.dati?.livello}` : \"assente\",\n origineBarra: disp?.barraIndice ?? null,\n },\n {\n componente: \"fvg\",\n punti: fvg ? PESI_SMC.fvg * (fvg.zona.forte ? 1 : 0.7) : 0,\n massimo: PESI_SMC.fvg,\n motivo: fvg\n ? `FVG ${fvg.zona.ampiezzaAtr} ATR`\n : \"nessun FVG utilizzabile\",\n origineBarra: fvg?.zona.origineIndice ?? null,\n },\n {\n componente: \"orderBlock\",\n punti: ob ? PESI_SMC.orderBlock * (ob.zona.forte ? 1 : 0.7) : 0,\n massimo: PESI_SMC.orderBlock,\n motivo: ob ? \"Order Block utilizzabile\" : \"nessun Order Block\",\n origineBarra: ob?.zona.origineIndice ?? null,\n },\n {\n componente: \"premiumDiscount\",\n punti: Math.min(PESI_SMC.premiumDiscount, loc.punti),\n massimo: PESI_SMC.premiumDiscount,\n motivo: loc.motivi.join(\", \") || \"posizione neutra\",\n origineBarra: null,\n },\n {\n componente: \"sessione\",\n punti: 0,\n massimo: PESI_SMC.sessione,\n motivo: \"nessun profilo di sessione configurato\",\n origineBarra: null,\n },\n ];\n\n const score = smcScore(contributi);\n\n // Fase 6: il setup operativo chiude il quarto gate. Va costruito\n // prima della verifica, altrimenti il R:R resta \"non valutato\" e il\n // gate non potrebbe mai passare.\n const barraSweep = sweep ? barre[sweep.barraIndice] : null;\n const setup = costruisciSetup(\n direzione,\n barre,\n i,\n a[i],\n consegna.zone,\n liquidita.livelli,\n barraSweep?.l ?? null,\n barraSweep?.h ?? null,\n );\n const giudizio = valutaSetup(setup);\n\n const gate = verificaGate(direzione, {\n bias: biasHtf,\n sweep,\n mss: mssValido,\n }, giudizio.rr);\n const macchina = macchinaStati(barre, direzione, dati);\n\n // ENTRY_CONFIRMED richiede i gate, non solo l'arrivo in zona:\n // è il punto in cui la macchina a stati e i gate si incontrano.\n const stato = macchina.stato === \"RETEST_ACTIVE\" && gate.tuttiSuperati\n ? \"ENTRY_CONFIRMED\" as const\n : macchina.stato;\n\n risultati[direzione] = {\n ...score,\n ...gate,\n stato,\n transizioni: macchina.transizioni,\n setup: \"errore\" in setup ? null : setup,\n setupNota: \"errore\" in setup ? setup.errore : giudizio.motivo,\n zoneUsabili: zoneUsabili.slice(0, 3).map((z) => ({\n tipo: z.zona.tipo,\n alto: z.zona.alto,\n basso: z.zona.basso,\n stato: z.stato,\n riempimento: z.riempimento,\n })),\n };\n }\n\n return {\n ticker,\n timeframe,\n asOf: barre[i].t,\n bias: biasHtf,\n posizione: posizione.posizione,\n ote: posizione.ote,\n long: risultati.LONG,\n short: risultati.SHORT,\n eventi,\n zone: consegna.zone,\n livelli: liquidita.livelli,\n note: [...liquidita.note, posizione.nota].filter(Boolean),\n };\n}",[174],"2f02b923-5d31-4e8c-b85a-68d7179257c6","radar.ts","03002efa-abc6-11f1-9b75-1607ee4eb77e",60,["D",1788901499568],"/* =====================================================================\n * RADAR — la watchlist ordinata per interesse al prezzo di oggi\n * ---------------------------------------------------------------\n * Ordina per Investment Score, non per Company Score. È la distinzione\n * su cui poggia tutto lo spec: le aziende migliori stanno quasi sempre\n * in fondo, perché il mercato lo sa già e le prezza di conseguenza.\n *\n * Costo: i bilanci restano in cache 45 giorni, quindi dopo il primo\n * caricamento un titolo costa una sola richiesta al giorno, quella del\n * prezzo. Una watchlist da dieci nomi sta dentro il budget gratuito\n * insieme al brief.\n * ===================================================================== */\n\nconst esc = (s: unknown) =>\n String(s ?? \"\")\n .replace(/&/g, \"&\").replace(//g, \">\");\n\nconst pct = (\n x: any,\n d = 1,\n) => (x === null || x === undefined ? \"—\" : (x * 100).toFixed(d) + \"%\");\nconst num = (\n x: any,\n d = 2,\n) => (x === null || x === undefined ? \"—\" : Number(x).toFixed(d));\n\nconst TESTA = `\n\n\n\n\n\n`;\n\nexport const STILE = `\n:root{--ink:#0E1A1C;--line:#20393D;--line2:#2C4B50;--fg:#DCE7E4;--mut:#7C9B99;\n--dim:#54706F;--amber:#E8A33D;--jade:#4FB286;--clay:#DB6B57}\n*{box-sizing:border-box}\nbody{margin:0;background:var(--ink);color:var(--fg);font-size:15px;line-height:1.55;\nfont-family:'IBM Plex Sans',ui-sans-serif,system-ui,sans-serif;\npadding:env(safe-area-inset-top) 0 env(safe-area-inset-bottom)}\n.mono{font-family:'IBM Plex Mono',ui-monospace,monospace;font-variant-numeric:tabular-nums}\n.wrap{max-width:760px;margin:0 auto;padding:26px 20px 70px}\n.top{display:flex;align-items:baseline;gap:12px;flex-wrap:wrap;\nborder-bottom:1px solid var(--line);padding-bottom:13px;margin-bottom:20px}\nh1{font-size:14px;font-weight:600;letter-spacing:.1em;margin:0}\n.data{color:var(--dim);font-size:12px}\n.nav{margin-left:auto;display:flex;gap:14px}\n.nav a{color:var(--dim);font-size:12px;text-decoration:none}\n.nav a:hover,.nav a.on{color:var(--amber)}\nh2{font-size:11px;letter-spacing:.1em;color:var(--dim);font-weight:600;\nmargin:0 0 12px;text-transform:uppercase}\n.sez{margin-bottom:28px}\na{color:var(--amber);text-decoration:none}\n.q{color:var(--mut);font-size:13.5px;margin:5px 0 0}\n.up{color:var(--jade)}.dn{color:var(--clay)}\n.pie{border-top:1px solid var(--line);padding-top:14px;color:var(--dim);font-size:11px;margin-top:26px}\n`;\n\nconst RADAR_CSS = `\n.riga{display:block;border-bottom:1px solid var(--line);padding:13px 0;\ntext-decoration:none;color:inherit}\n.riga:hover{background:#132528}\n.r1{display:flex;align-items:baseline;gap:11px}\n.rk{color:var(--dim);font-size:12px;width:20px;flex:0 0 20px}\n.tk{font-weight:600;font-size:16px;width:76px;flex:0 0 76px}\n.bar{flex:1;height:4px;background:var(--line);min-width:36px;position:relative;top:-3px}\n.fill{display:block;height:100%}\n.alto{background:var(--amber)}.medio{background:var(--jade)}.basso{background:var(--line2)}\n.is{width:30px;flex:0 0 30px;text-align:right;font-size:16px;font-weight:600}\n.mos{width:66px;flex:0 0 66px;text-align:right;font-size:13px}\n.r2{display:flex;gap:16px;margin:5px 0 0 31px;font-size:11.5px;color:var(--dim);flex-wrap:wrap}\n.verd{font-size:11px;padding:1px 6px;border:1px solid currentColor;border-radius:2px}\n.err{border:1px solid var(--clay);color:var(--clay);border-radius:3px;padding:11px 13px;\nmargin-bottom:16px;font-size:13px}\nform{display:flex;gap:8px;margin-top:8px}\ninput{flex:1;background:#0B1517;color:var(--fg);border:1px solid var(--line2);\nborder-radius:3px;padding:9px 11px;font-family:'IBM Plex Mono',monospace;font-size:13px}\ninput:focus{outline:none;border-color:var(--amber)}\nbutton{background:var(--amber);color:#10201F;border:none;padding:9px 16px;border-radius:3px;\nfont-weight:600;font-size:13px;cursor:pointer;font-family:'IBM Plex Mono',monospace}\n@media(max-width:480px){.tk{width:62px;flex:0 0 62px}.mos{width:56px;flex:0 0 56px}.r2{margin-left:0}}\n`;\n\nfunction colore(s: number | null) {\n if (s === null || s === undefined) return \"basso\";\n return s >= 70 ? \"alto\" : s >= 45 ? \"medio\" : \"basso\";\n}\n\nexport function paginaRadar(righe: any[], meta: any = {}) {\n const oggi = new Date().toLocaleDateString(\"it-IT\", {\n day: \"numeric\",\n month: \"long\",\n });\n\n const lista = 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 ${esc(r.errore)}

`;\n }\n\n const mos = r.marginOfSafety;\n return `\n

\n ${String(i + 1).padStart(2, \"0\")}\n ${esc(r.symbol)}\n \n ${r.investmentScore ?? \"—\"}\n = 0 ? \"up\" : \"dn\"}\">${\n mos === null || mos === undefined\n ? \"—\"\n : (mos >= 0 ? \"+\" : \"\") + mos.toFixed(0) + \"%\"\n }\n

\n ${esc(r.verdetto)}\n company ${r.companyScore ?? \"—\"}\n conf ${r.confidence ?? \"—\"}\n sconta ${pct(r.crescitaImplicita, 0)} contro ${\n pct(r.crescitaRiferimento, 0)\n } realizzato\n

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

Watchlist vuota. Aggiungi un titolo qui sotto.

`;\n\n return `${TESTA}\nRadar · ${\n esc(oggi)\n }

\n\n

RADAR

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

\n\n${meta.avviso ? `

${esc(meta.avviso)}

` : \"\"}\n\n

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

\n ${lista}\n

\n\n

Watchlist

\n \n ${\n righe.length\n ? `

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

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

\n\n

\n ${\n meta.aggiornato\n ? `aggiornato ${esc(meta.aggiornato)} · `\n : \"\"\n }budget Alpha Vantage\n ${esc(meta.budgetUsato ?? \"?\")}/${esc(meta.budgetTotale ?? \"?\")} usato oggi\n
Nessun giudizio dell'AI in questa vista: qui contano solo i numeri. Apri un titolo per il quadro completo.\n

\n\n

`;\n}\n\n/* ------------------------------- home ------------------------------ */\n\nconst HOME_CSS = `\n.card{display:block;border:1px solid var(--line);border-radius:3px;padding:16px 17px;\nmargin-bottom:12px;text-decoration:none;color:inherit}\n.card:hover{border-color:var(--line2);background:#132528}\n.ct{font-size:16px;font-weight:600;margin:0 0 4px}\n.riga1{font-size:19px;line-height:1.38;font-weight:500;margin:0 0 22px;\nborder-left:3px solid var(--amber);padding-left:15px}\nform{display:flex;gap:8px;margin-top:8px}\ninput{flex:1;background:#0B1517;color:var(--fg);border:1px solid var(--line2);\nborder-radius:3px;padding:10px 12px;font-family:'IBM Plex Mono',monospace;font-size:14px}\ninput:focus{outline:none;border-color:var(--amber)}\nbutton{background:var(--amber);color:#10201F;border:none;padding:10px 17px;border-radius:3px;\nfont-weight:600;font-size:13.5px;cursor:pointer;font-family:'IBM Plex Mono',monospace}\n`;\n\nexport function paginaHome(sintesi: any = {}) {\n const oggi = new Date().toLocaleDateString(\"it-IT\", {\n weekday: \"long\",\n day: \"numeric\",\n month: \"long\",\n });\n\n return `${TESTA}\n\nDesk

\n\n

DESK

\n ${esc(oggi)}\n

\n\n${sintesi.unaRiga ? `

${esc(sintesi.unaRiga)}

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

Brief mattutino

${\n sintesi.tema\n ? esc(sintesi.tema)\n : \"Quadro macro e cosa è successo nelle ultime 24 ore.\"\n }

\n\n\n\n

Notizie

Cosa esce sui titoli che segui, ordinato per rilevanza.

\n\n\n\n

Radar

${\n sintesi.migliore\n ? `In cima: ${esc(sintesi.migliore.symbol)}, Investment Score ${\n esc(sintesi.migliore.investmentScore)\n }.`\n : \"La watchlist ordinata per interesse al prezzo di oggi.\"\n }

\n\n\n

Analizza un titolo

\n \n

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

\n\n

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

\n\n

`;\n}",[182],"d4a8605b-5506-41ba-a556-88d9815bacd3","prezzi.ts","b7790ec8-ac3f-11f1-b1d7-1607ee4eb77e",71,["D",1788952517285],"/* =====================================================================\n * PREZZI — adattatore Twelve Data\n * ---------------------------------------------------------------\n * Il motore prezzi ha bisogno dell'opposto di quello fondamentale:\n * pochi campi, moltissime richieste. Twelve Data conta 1 credito per\n * serie storica contro i 100 di un bilancio, e ne dà 800 al giorno.\n *\n * Serve la variabile d'ambiente TWELVEDATA_KEY\n * (twelvedata.com, piano gratuito senza carta)\n *\n * ATTENZIONE a una stranezza dell'API: gli errori arrivano con HTTP\n * 200 e status \"error\" nel corpo. Controllare solo res.ok fa passare\n * per validi dei payload vuoti.\n * ===================================================================== */\n\nconst TD = \"https://api.twelvedata.com/time_series\";\nexport const BUDGET_CREDITI = 800; // piano gratuito, al giorno\nexport const PAUSA_TD_MS = 8000; // 8 crediti al minuto\n\n/** I nostri nomi verso gli intervalli Twelve Data. */\nexport const INTERVALLI: Record = {\n \"1m\": \"1min\",\n \"5m\": \"5min\",\n \"15m\": \"15min\",\n \"30m\": \"30min\",\n \"1h\": \"1h\",\n \"4h\": \"4h\",\n \"1d\": \"1day\",\n \"1w\": \"1week\",\n};\n\nexport type Barra = {\n t: string; // ISO UTC, apertura della barra\n o: number;\n h: number;\n l: number;\n c: number;\n v: number | null;\n};\n\n/* --------------------------- chiamata ----------------------------- */\n\nexport function controllaTD(j: any, contesto: string) {\n if (!j || typeof j !== \"object\") {\n throw new Error(`${contesto}: risposta non valida`);\n }\n // Twelve Data segnala gli errori dentro il corpo, non nello stato HTTP\n if (j.status === \"error\") {\n const c = Number(j.code);\n if (c === 429) {\n throw new Error(\n `TD_QUOTA: ${contesto} — ${String(j.message).slice(0, 180)}`,\n );\n }\n throw new Error(\n `${contesto}: ${String(j.message ?? \"errore\").slice(0, 180)}`,\n );\n }\n if (!Array.isArray(j.values)) {\n throw new Error(`${contesto}: nessuna serie nella risposta`);\n }\n return j;\n}\n\n/** Twelve Data restituisce dal più recente: il motore le vuole crescenti. */\nexport function normalizzaBarre(values: any[]): Barra[] {\n const n = (x: any) => {\n const v = Number(x);\n return isFinite(v) ? v : null;\n };\n return values.map((r) => ({\n t: String(r.datetime).replace(\" \", \"T\") +\n (String(r.datetime).length <= 10 ? \"T00:00:00Z\" : \"Z\"),\n o: n(r.open)!,\n h: n(r.high)!,\n l: n(r.low)!,\n c: n(r.close)!,\n v: n(r.volume),\n })).filter((b) =>\n [b.o, b.h, b.l, b.c].every((x) => x !== null && isFinite(x))\n )\n .sort((a, b) => a.t.localeCompare(b.t));\n}\n\n/* ------------------------- ricampionamento ------------------------- */\n\n/**\n * Aggrega N barre in una. L'ancoraggio è il punto delicato: raggruppare\n * per orario assoluto taglia l'apertura di sessione a metà e ogni evento\n * strutturale derivato eredita l'errore in silenzio.\n *\n * Qui l'ancora è la prima barra di ciascuna giornata presente nei dati:\n * si auto-adatta all'orario di apertura senza orari codificati, che è\n * il requisito della sezione 15 della specifica.\n */\nexport function ricampiona(barre: Barra[], fattore: number): Barra[] {\n if (fattore <= 1) return barre;\n const perGiorno = new Map();\n for (const b of barre) {\n const g = b.t.slice(0, 10);\n if (!perGiorno.has(g)) perGiorno.set(g, []);\n perGiorno.get(g)!.push(b);\n }\n\n const out: Barra[] = [];\n for (const giorno of [...perGiorno.keys()].sort()) {\n const bs = perGiorno.get(giorno)!;\n for (let i = 0; i < bs.length; i += fattore) {\n const blocco = bs.slice(i, i + fattore);\n // Un blocco incompleto a fine giornata resta fuori: una barra 4H\n // costruita su due sole barre orarie non è una barra 4H.\n if (blocco.length < fattore && i + fattore <= bs.length) continue;\n if (blocco.length < fattore) continue;\n out.push({\n t: blocco[0].t,\n o: blocco[0].o,\n h: Math.max(...blocco.map((x) => x.h)),\n l: Math.min(...blocco.map((x) => x.l)),\n c: blocco[blocco.length - 1].c,\n v: blocco.every((x) => x.v === null)\n ? null\n : blocco.reduce((a, x) => a + (x.v ?? 0), 0),\n });\n }\n }\n return out;\n}\n\n/* ------------------------------- ATR ------------------------------- */\n\n/** ATR con smoothing di Wilder. Restituisce un valore per barra, null finché non c'è storia. */\nexport function atr(barre: Barra[], periodo = 14): (number | null)[] {\n const out: (number | null)[] = [];\n const tr: number[] = [];\n let precedente: number | null = null;\n\n for (let i = 0; i < barre.length; i++) {\n const b = barre[i];\n const prevC = i > 0 ? barre[i - 1].c : null;\n const range = prevC === null\n ? b.h - b.l\n : Math.max(b.h - b.l, Math.abs(b.h - prevC), Math.abs(b.l - prevC));\n tr.push(range);\n\n if (i < periodo - 1) {\n out.push(null);\n continue;\n }\n if (i === periodo - 1) {\n precedente = tr.slice(0, periodo).reduce((a, x) => a + x, 0) / periodo;\n } else {\n precedente = (precedente! * (periodo - 1) + range) / periodo;\n }\n out.push(precedente);\n }\n return out;\n}\n\n/* ---------------------------- richiesta ---------------------------- */\n\n/**\n * @param deps { fetch, store, segnaCredito, creditiUsati, pausa }\n * Host-agnostico come facts.ts: riceve le dipendenze invece di\n * assumere un ambiente. Il 4H viene tentato nativo e, se l'API non lo\n * espone, ricostruito dal 1H — l'esito è dichiarato nel risultato.\n */\nexport async function serie(\n symbol: string,\n tf: string,\n deps: any,\n barre = 300,\n) {\n const {\n apiKey,\n fetch: f,\n leggiCache,\n scriviCache,\n creditiUsati,\n segnaCredito,\n pausa,\n } = deps;\n if (!apiKey) throw new Error(\"TWELVEDATA_KEY non configurata\");\n if (!INTERVALLI[tf]) throw new Error(`timeframe non riconosciuto: ${tf}`);\n\n const chiave = `td:${symbol}:${tf}:${barre}`;\n const ttl = tf === \"1d\" || tf === \"1w\" ? 12 * 3600e3 : 20 * 60e3;\n const c = await leggiCache(chiave, ttl);\n if (c) return { barre: c.barre, origine: c.origine, daCache: true };\n\n const scarica = async (intervallo: string, quante: number) => {\n const usati = await creditiUsati();\n if (usati >= BUDGET_CREDITI) {\n throw new Error(\n `TD_BUDGET: ${usati}/${BUDGET_CREDITI} crediti usati oggi`,\n );\n }\n const q = new URLSearchParams({\n symbol,\n interval: intervallo,\n outputsize: String(quante),\n timezone: \"UTC\",\n apikey: apiKey,\n });\n const res = await f(`${TD}?${q}`);\n if (!res.ok) throw new Error(`${intervallo}: HTTP ${res.status}`);\n const j = controllaTD(await res.json(), `${symbol} ${intervallo}`);\n await segnaCredito();\n return normalizzaBarre(j.values);\n };\n\n let dati: Barra[], origine: string;\n if (tf === \"4h\") {\n try {\n dati = await scarica(\"4h\", barre);\n origine = \"nativo\";\n } catch {\n // ricostruzione dal 1H: servono quattro volte le barre\n await pausa(PAUSA_TD_MS);\n dati = ricampiona(await scarica(\"1h\", Math.min(5000, barre * 4)), 4);\n origine = \"ricampionato da 1h\";\n }\n } else {\n dati = await scarica(INTERVALLI[tf], barre);\n origine = \"nativo\";\n }\n\n await scriviCache(chiave, { barre: dati, origine });\n return { barre: dati, origine, daCache: false };\n}\n\n/**\n * Confronta 4H nativo e 4H ricostruito su un campione. La specifica\n * chiede questa verifica: un ancoraggio sbagliato produce barre che\n * tagliano l'apertura, e nessun controllo a valle se ne accorge.\n */\nexport function confrontaRicampionamento(\n nativo: Barra[],\n ricostruito: Barra[],\n) {\n const perT = new Map(ricostruito.map((b) => [b.t, b]));\n let confrontate = 0, divergenti = 0, scartoMax = 0;\n for (const n of nativo) {\n const r = perT.get(n.t);\n if (!r) continue;\n confrontate++;\n const s = Math.max(\n Math.abs(n.h - r.h),\n Math.abs(n.l - r.l),\n Math.abs(n.c - r.c),\n );\n const rel = n.c ? s / n.c : 0;\n scartoMax = Math.max(scartoMax, rel);\n if (rel > 0.001) divergenti++;\n }\n return {\n confrontate,\n divergenti,\n scartoMassimo: +(scartoMax * 100).toFixed(4),\n allineate: perT.size\n ? confrontate / Math.min(nativo.length, ricostruito.length)\n : 0,\n esito: confrontate === 0\n ? \"nessuna barra in comune: ancoraggio diverso\"\n : divergenti === 0\n ? \"coincidono\"\n : `${divergenti} barre divergenti su ${confrontate}`,\n };\n}",[189],"3b6e30f2-739b-49a6-8867-fab423d55c97","posizione.ts","a98f0886-ac98-11f1-852a-1607ee4eb77e",83,["D",1788990719320],"/* =====================================================================\n * POSIZIONE — Fase 4 del motore SMC\n * ---------------------------------------------------------------\n * Premium/Discount e OTE.\n *\n * Entrambi si misurano sulla STESSA gamba d'impulso. È la decisione\n * presa al punto 3.5 della specifica, e serve a evitare una\n * contraddizione che nella pratica capita di continuo: prezzo in\n * discount rispetto a un range, ma fuori dall'OTE calcolato su una\n * gamba diversa. Nessuna delle due misure è sbagliata, semplicemente\n * misurano cose diverse — e un motore che le usa insieme senza\n * ancorarle produce confluenze che non esistono.\n *\n * Seconda accortezza: non ogni oscillazione fra due swing è una gamba\n * d'impulso. Senza una qualifica esplicita il range si sposta a ogni\n * minimo movimento e premium/discount diventano rumore.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport type { Swing } from \"./struttura.ts\";\nimport { displacement, PARAMETRI } from \"./struttura.ts\";\nimport type { Evento } from \"./eventi.ts\";\n\nexport const PARAMETRI_POS = {\n ampiezzaMinAtr: 1.5, // una gamba sotto questa soglia non è un impulso\n oteDa: 0.62, // ritracciamento minimo\n oteA: 0.79, // ritracciamento massimo\n oteCentro: 0.705,\n sogliaProfonda: 0.25, // deep discount / deep premium\n};\n\nexport type Gamba = {\n direzione: \"BULL\" | \"BEAR\";\n inizioIndice: number;\n inizioPrezzo: number;\n fineIndice: number;\n finePrezzo: number;\n confermaIndice: number; // quando la gamba è conoscibile per intero\n ampiezza: number;\n ampiezzaAtr: number;\n qualificata: boolean; // contiene displacement o ha prodotto una rottura\n motivo: string;\n};\n\n/* --------------------------- gamba d'impulso ----------------------- */\n\n/**\n * Costruisce tutte le gambe fra swing consecutivi di segno opposto e le\n * qualifica. Una gamba conta come impulso se supera l'ampiezza minima E\n * contiene almeno un displacement nella sua direzione, oppure ha\n * prodotto un BOS o un MSS.\n */\nexport function gambe(\n swings: Swing[],\n barre: Barra[],\n atrSerie: (number | null)[],\n eventiStruttura: Evento[] = [],\n p = PARAMETRI_POS,\n): Gamba[] {\n const rotture = new Set(\n eventiStruttura.filter((e) => /^(BOS|MSS)_/.test(e.tipo)).map((e) =>\n e.barraIndice\n ),\n );\n\n const ordinati = [...swings].sort((a, b) => a.indice - b.indice);\n const out: Gamba[] = [];\n\n for (let k = 1; k < ordinati.length; k++) {\n const a = ordinati[k - 1], b = ordinati[k];\n if (a.tipo === b.tipo) continue; // servono estremi alternati\n\n const direzione = a.tipo === \"LOW\" ? \"BULL\" : \"BEAR\";\n const ampiezza = Math.abs(b.prezzo - a.prezzo);\n const atrRif = atrSerie[b.confermaIndice] ?? atrSerie[b.indice] ?? null;\n if (atrRif === null || atrRif <= 0) continue;\n const ampiezzaAtr = ampiezza / atrRif;\n\n let conDisp = false;\n for (let i = a.indice; i <= b.indice; i++) {\n const d = displacement(barre[i], atrSerie[i], PARAMETRI);\n if (d && d.direzione === direzione) {\n conDisp = true;\n break;\n }\n }\n let conRottura = false;\n for (let i = a.indice; i <= b.indice; i++) {\n if (rotture.has(i)) {\n conRottura = true;\n break;\n }\n }\n\n const abbastanzaAmpia = ampiezzaAtr >= p.ampiezzaMinAtr;\n const qualificata = abbastanzaAmpia && (conDisp || conRottura);\n\n out.push({\n direzione,\n inizioIndice: a.indice,\n inizioPrezzo: a.prezzo,\n fineIndice: b.indice,\n finePrezzo: b.prezzo,\n // la gamba è completa solo quando anche il secondo estremo è confermato\n confermaIndice: b.confermaIndice,\n ampiezza,\n ampiezzaAtr: +ampiezzaAtr.toFixed(3),\n qualificata,\n motivo: !abbastanzaAmpia\n ? `ampiezza ${\n ampiezzaAtr.toFixed(2)\n } ATR sotto la soglia di ${p.ampiezzaMinAtr}`\n : conRottura\n ? \"contiene una rottura di struttura\"\n : conDisp\n ? \"contiene un displacement nella sua direzione\"\n : \"nessun displacement né rottura: oscillazione, non impulso\",\n });\n }\n return out;\n}\n\n/** L'ultima gamba d'impulso conoscibile alla barra `i`. */\nexport function gambaRiferimento(tutte: Gamba[], i: number): Gamba | null {\n const valide = tutte.filter((g) => g.qualificata && g.confermaIndice <= i);\n return valide.length ? valide[valide.length - 1] : null;\n}\n\n/* ------------------------ premium / discount ----------------------- */\n\nexport type Posizione = {\n gamba: Gamba;\n alto: number;\n basso: number;\n equilibrio: number;\n percentuale: number; // 0 = base della gamba, 1 = vertice\n zona:\n | \"DEEP_DISCOUNT\"\n | \"DISCOUNT\"\n | \"EQUILIBRIUM\"\n | \"PREMIUM\"\n | \"DEEP_PREMIUM\";\n favorevolePer: \"LONG\" | \"SHORT\" | null;\n};\n\nexport function posizioneNelRange(\n prezzo: number,\n g: Gamba,\n p = PARAMETRI_POS,\n): Posizione {\n const alto = Math.max(g.inizioPrezzo, g.finePrezzo);\n const basso = Math.min(g.inizioPrezzo, g.finePrezzo);\n const range = alto - basso;\n const pc = range > 0 ? (prezzo - basso) / range : 0.5;\n\n const zona = pc <= p.sogliaProfonda\n ? \"DEEP_DISCOUNT\"\n : pc < 0.48\n ? \"DISCOUNT\"\n : pc <= 0.52\n ? \"EQUILIBRIUM\"\n : pc < 1 - p.sogliaProfonda\n ? \"PREMIUM\"\n : \"DEEP_PREMIUM\";\n\n return {\n gamba: g,\n alto,\n basso,\n equilibrio: (alto + basso) / 2,\n percentuale: +pc.toFixed(4),\n zona,\n favorevolePer: zona.includes(\"DISCOUNT\")\n ? \"LONG\"\n : zona.includes(\"PREMIUM\")\n ? \"SHORT\"\n : null,\n };\n}\n\n/* -------------------------------- OTE ------------------------------ */\n\nexport type ZonaOte = {\n alto: number;\n basso: number;\n centro: number;\n direzione: \"LONG\" | \"SHORT\";\n dentro: boolean;\n ritracciamento: number; // quanto il prezzo ha ritracciato, 0-1\n};\n\n/**\n * Ritracciamento fra 62% e 79% della gamba, centro a 70.5%.\n * I punti Fibonacci non sono scelti: derivano dalla gamba qualificata.\n */\nexport function ote(g: Gamba, prezzo: number, p = PARAMETRI_POS): ZonaOte {\n const range = Math.abs(g.finePrezzo - g.inizioPrezzo);\n const verso = g.direzione === \"BULL\" ? -1 : 1; // il ritracciamento torna indietro\n const liv = (r: number) => g.finePrezzo + verso * range * r;\n\n const a = liv(p.oteDa), b = liv(p.oteA);\n const alto = Math.max(a, b), basso = Math.min(a, b);\n const ritr = range > 0 ? Math.abs(g.finePrezzo - prezzo) / range : 0;\n\n return {\n alto,\n basso,\n centro: liv(p.oteCentro),\n direzione: g.direzione === \"BULL\" ? \"LONG\" : \"SHORT\",\n dentro: prezzo >= basso && prezzo <= alto,\n ritracciamento: +ritr.toFixed(4),\n };\n}\n\n/* --------------------------- orchestratore ------------------------- */\n\n/**\n * Posizione completa alla barra `i`. Restituisce null quando non esiste\n * una gamba qualificata: preferibile a misurare su un range arbitrario.\n */\nexport function analizzaPosizione(\n barre: Barra[],\n swings: Swing[],\n atrSerie: (number | null)[],\n eventiStruttura: Evento[],\n i: number,\n) {\n const tutte = gambe(swings, barre, atrSerie, eventiStruttura);\n const g = gambaRiferimento(tutte, i);\n if (!g) {\n return {\n gamba: null,\n posizione: null,\n ote: null,\n nota:\n \"nessuna gamba d'impulso qualificata: premium/discount e OTE non sono definiti\",\n };\n }\n\n const prezzo = barre[i].c;\n const pos = posizioneNelRange(prezzo, g);\n const o = ote(g, prezzo);\n\n return {\n gamba: g,\n posizione: pos,\n ote: o,\n nota: null,\n // Le due misure condividono la gamba: se divergono è un errore di\n // calcolo, non un'ambiguità di metodo.\n coerenti: !o.dentro || o.direzione === pos.favorevolePer ||\n pos.favorevolePer === null,\n };\n}\n\n/** Contributo alla confluenza: location favorevole più bonus se dentro l'OTE. */\nexport function puntiLocation(\n pos: Posizione | null,\n o: ZonaOte | null,\n direzione: \"LONG\" | \"SHORT\",\n) {\n if (!pos) return { punti: 0, motivi: [\"nessuna gamba di riferimento\"] };\n const motivi: string[] = [];\n let punti = 0;\n if (pos.favorevolePer === direzione) {\n punti += pos.zona.startsWith(\"DEEP\") ? 5 : 3;\n motivi.push(pos.zona.toLowerCase().replace(\"_\", \" \"));\n } else if (pos.favorevolePer) {\n motivi.push(\n `prezzo in ${\n pos.zona.toLowerCase().replace(\"_\", \" \")\n }, sfavorevole per ${direzione}`,\n );\n }\n if (o?.dentro && o.direzione === direzione) {\n punti += 1;\n motivi.push(\"dentro l'OTE\");\n }\n return { punti, motivi };\n}",[196],"a22b5f93-5c03-42bd-adfe-d2ca78d5c027","operativo.ts","6a3c8784-ac99-11f1-94c6-1607ee4eb77e",89,["D",1788991041158],"/* =====================================================================\n * OPERATIVO — Fase 6: entry, stop, target, R:R\n * ---------------------------------------------------------------\n * Tre scelte che vale la pena dichiarare.\n *\n * Il prezzo d'ingresso di riferimento è il bordo VICINO della zona,\n * non il centro. È il primo punto che il prezzo tocca rientrando,\n * quindi il riempimento più realistico e il peggiore fra quelli\n * plausibili. Usare il centro fa apparire ogni R:R migliore di quanto\n * sarà, e su centinaia di operazioni la differenza non è cosmetica.\n *\n * Lo stop è strutturale, mai percentuale: sotto il minimo della sweep\n * o della zona, con un margine in ATR. Se il prezzo torna lì, la\n * ragione per cui eri entrato non esiste più.\n *\n * I target sono pool di liquidità non ancora prese, non multipli\n * arbitrari. Un target a +2% non ha nessuna ragione per essere\n * raggiunto; un massimo di giornata intatto ne ha una.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport type { Zona } from \"./consegna.ts\";\nimport { centro, intersezione } from \"./consegna.ts\";\nimport type { Livello } from \"./liquidita.ts\";\nimport type { Direzione } from \"./smc.ts\";\n\nexport const PARAMETRI_OP = {\n bufferStopAtr: 0.10,\n rrMinimo: 2.0, // [1.5, 2.0, 3.0]\n distanzaMinTargetAtr: 0.5, // un target troppo vicino non è un target\n};\n\nexport type Setup = {\n direzione: Direzione;\n entryAlto: number;\n entryBasso: number;\n entryRiferimento: number;\n origineEntry: string;\n stop: number;\n invalidazione: string;\n target1: number | null;\n target1Da: string | null;\n target2: number | null;\n target2Da: string | null;\n rischio: number;\n rr: number | null;\n rrTarget2: number | null;\n note: string[];\n};\n\n/* ---------------------------- entry zone --------------------------- */\n\n/**\n * Dove FVG e Order Block si sovrappongono la qualità è più alta ed è lì\n * che la specifica colloca l'ingresso. Se non si sovrappongono si usa la\n * zona più vicina al prezzo, dichiarando quale.\n */\nexport function zonaIngresso(\n zone: Zona[],\n direzione: Direzione,\n prezzo: number,\n) {\n const suffisso = direzione === \"LONG\" ? \"BULL\" : \"BEAR\";\n const utili = zone.filter((z) => z.direzione === suffisso);\n const fvg = utili.filter((z) => z.tipo === \"FVG\");\n const ob = utili.filter((z) => z.tipo === \"OB\");\n\n for (const f of fvg) {\n for (const o of ob) {\n const x = intersezione(f, o);\n if (x) {\n return {\n alto: x.alto,\n basso: x.basso,\n origine: \"FVG e Order Block sovrapposti\",\n };\n }\n }\n }\n if (!utili.length) return null;\n\n const vicina = [...utili].sort(\n (a, b) => Math.abs(prezzo - centro(a)) - Math.abs(prezzo - centro(b)),\n )[0];\n return {\n alto: vicina.alto,\n basso: vicina.basso,\n origine: `${vicina.tipo} ${\n vicina.tipo === \"FVG\" ? `${vicina.ampiezzaAtr} ATR` : \"\"\n } (nessuna sovrapposizione)`.trim(),\n };\n}\n\n/* ------------------------------ target ----------------------------- */\n\n/**\n * Pool di liquidità sul lato opposto, non ancora prese.\n * T1 la più vicina, T2 la prima esterna: la gerarchia della sezione 8.\n */\nexport function bersagli(\n livelli: Livello[],\n direzione: Direzione,\n entry: number,\n i: number,\n atrVal: number,\n) {\n const versoAlto = direzione === \"LONG\";\n const candidati = livelli\n .filter((l) => l.confermaIndice <= i && l.stato === \"ACTIVE\")\n .filter((l) => (versoAlto ? l.lato === \"BUY_SIDE\" : l.lato === \"SELL_SIDE\"))\n .filter((l) => (versoAlto ? l.prezzo > entry : l.prezzo < entry))\n .filter((l) =>\n Math.abs(l.prezzo - entry) >= PARAMETRI_OP.distanzaMinTargetAtr * atrVal\n )\n .sort((a, b) => Math.abs(a.prezzo - entry) - Math.abs(b.prezzo - entry));\n\n const t1 = candidati[0] ?? null;\n const esterna = candidati.find((l) => l.esterna && l !== t1) ?? null;\n return {\n t1,\n t2: esterna ?? candidati[1] ?? null,\n disponibili: candidati.length,\n };\n}\n\n/* --------------------------- costruzione --------------------------- */\n\nexport function costruisciSetup(\n direzione: Direzione,\n barre: Barra[],\n i: number,\n atrVal: number | null,\n zone: Zona[],\n livelli: Livello[],\n sweepBasso: number | null,\n sweepAlto: number | null,\n): Setup | { errore: string } {\n if (atrVal === null || atrVal <= 0) return { errore: \"ATR non disponibile\" };\n\n const prezzo = barre[i].c;\n const z = zonaIngresso(zone, direzione, prezzo);\n if (!z) return { errore: \"nessuna zona di ingresso disponibile\" };\n\n const note: string[] = [];\n const buffer = PARAMETRI_OP.bufferStopAtr * atrVal;\n\n // ingresso al bordo vicino: il primo punto toccato rientrando\n const entryRiferimento = direzione === \"LONG\" ? z.alto : z.basso;\n\n // stop strutturale: oltre il punto che ha generato il setup\n const stop = direzione === \"LONG\"\n ? Math.min(z.basso, sweepBasso ?? z.basso) - buffer\n : Math.max(z.alto, sweepAlto ?? z.alto) + buffer;\n\n const rischio = Math.abs(entryRiferimento - stop);\n if (rischio <= 0) return { errore: \"rischio nullo: zona e stop coincidono\" };\n\n const { t1, t2, disponibili } = bersagli(\n livelli,\n direzione,\n entryRiferimento,\n i,\n atrVal,\n );\n if (!t1) {\n note.push(\"nessuna liquidità opposta intatta: manca un target strutturale\");\n }\n if (disponibili === 1) note.push(\"un solo bersaglio disponibile: T2 assente\");\n\n const guadagno = t1 ? Math.abs(t1.prezzo - entryRiferimento) : null;\n const guadagno2 = t2 ? Math.abs(t2.prezzo - entryRiferimento) : null;\n\n return {\n direzione,\n entryAlto: z.alto,\n entryBasso: z.basso,\n entryRiferimento,\n origineEntry: z.origine,\n stop,\n invalidazione: direzione === \"LONG\"\n ? `chiusura sotto ${\n stop.toFixed(2)\n } (minimo della zona o della sweep, meno ${PARAMETRI_OP.bufferStopAtr} ATR)`\n : `chiusura sopra ${\n stop.toFixed(2)\n } (massimo della zona o della sweep, più ${PARAMETRI_OP.bufferStopAtr} ATR)`,\n target1: t1?.prezzo ?? null,\n target1Da: t1?.tipo ?? null,\n target2: t2?.prezzo ?? null,\n target2Da: t2?.tipo ?? null,\n rischio: +rischio.toFixed(4),\n rr: guadagno ? +(guadagno / rischio).toFixed(2) : null,\n rrTarget2: guadagno2 ? +(guadagno2 / rischio).toFixed(2) : null,\n note,\n };\n}\n\n/* ----------------------------- giudizio ---------------------------- */\n\nexport function valutaSetup(s: Setup | { errore: string }) {\n if (\"errore\" in s) return { ammesso: false, motivo: s.errore, rr: null };\n if (s.rr === null) {\n return {\n ammesso: false,\n motivo: \"nessun target strutturale: R:R non calcolabile\",\n rr: null,\n };\n }\n if (s.rr < PARAMETRI_OP.rrMinimo) {\n return {\n ammesso: false,\n rr: s.rr,\n motivo: `R:R ${s.rr} sotto il minimo di ${PARAMETRI_OP.rrMinimo}`,\n };\n }\n return {\n ammesso: true,\n rr: s.rr,\n motivo: `R:R ${s.rr} verso ${s.target1Da}`,\n };\n}",[203],"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}",[210],"110a4cb1-3373-45f1-b38f-6c0787b08578",["D",1788991330695],[28],"b9f6fe8d-1d8c-4bc7-a257-543f8427e31d","main.ts",64,["D",1788949871978],15,"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 <- facts.js normalizzazione dati\n * engine.js <- engine.js calcoli e punteggi\n * criteri.js <- criteri.js registro dei criteri\n * judgments.js<- judgments.js prompt e validazione (opzionale ora)\n * brief.ts <- brief.ts generazione e pagina del brief\n * giudizi.ts <- giudizi.ts strato qualitativo su Gemini\n * titolo.ts <- titolo.ts pagina della scheda titolo\n * radar.ts <- radar.ts pagine radar e home\n * valutazione.ts <- valutazione.ts metodi di valutazione non-DCF\n * notizie.ts <- notizie.ts flusso notizie e sentiment\n * main.ts <- questo file, di tipo HTTP\n * cron.ts <- cron.ts di tipo Cron, alle 5:00 UTC\n * 2. Environment Variables -> aggiungi:\n * ALPHAVANTAGE_KEY (alphavantage.co/support/#api-key)\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 * 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, paginaHTML } from \"./brief.ts\";\nimport { generaGiudizi, scenariCalcolati, TTL_GIUDIZI } from \"./giudizi.ts\";\nimport { paginaTitolo } from \"./titolo.ts\";\nimport { paginaHome, paginaRadar } from \"./radar.ts\";\nimport {\n PROMPT_PEERS,\n valutazioneCrescita,\n valutazioneRelativa,\n valutazioneStorica,\n} from \"./valutazione.ts\";\nimport { chiamaGemini, diagnostica } from \"./brief.ts\";\nimport {\n bloccoNotizie,\n normalizzaNotizie,\n paginaNotizie,\n umore,\n} 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/**\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\n/* ------------------------------ rotte ----------------------------- */\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, status = 200) =>\n new Response(JSON.stringify(body, null, 2), {\n status,\n headers: { \"Content-Type\": \"application/json; charset=utf-8\", ...CORS },\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/**\n * Analisi completa. Lo strato dei giudizi AI resta fuori: girerebbe qui\n * solo con una chiave Anthropic a pagamento, mentre dentro un artifact\n * Claude è gratuito. Quindi moat, management e rischi restano vuoti e la\n * copertura lo dichiara, invece di far finta che il quadro sia completo.\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/* ----------------------------- 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\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 new Response(paginaHTML(brief, macro), {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n });\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 json(await rottaMacro());\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 new Response(\n paginaHome({\n unaRiga: b?.brief?.unaRiga,\n tema: b?.brief?.tema?.titolo,\n migliore,\n }),\n { headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS } },\n );\n }\n case \"/notizie\": {\n const richiesti = symbol ? [symbol] : await watchlist();\n try {\n const { grezzo, daCache } = await notiziePer(richiesti);\n const n = grezzo ? normalizzaNotizie(grezzo, symbol || null) : [];\n return new Response(\n paginaNotizie(n, { ticker: richiesti, daCache }),\n {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n },\n );\n } catch (e) {\n return new Response(\n paginaNotizie([], {\n ticker: richiesti,\n vuoto: String((e as Error)?.message ?? e).slice(0, 160),\n }),\n {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n },\n );\n }\n }\n case \"/radar\": {\n const { righe, meta } = await rottaRadar();\n return new Response(paginaRadar(righe, meta), {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n });\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 new Response(\n paginaTitolo(r, {\n facts: r.facts,\n giudizi: r.giudizi,\n scenari: r.scenari,\n valutazioni: r.valutazioni,\n notizie: r.notizie,\n }),\n {\n headers: { \"Content-Type\": \"text/html; charset=utf-8\", ...CORS },\n },\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}",[220],"8433aa77-677c-452d-be77-839856f35602","liquidita.ts","c4698ac0-ac4b-11f1-813d-1607ee4eb77e",77,["D",1788957724576],"/* =====================================================================\n * LIQUIDITÀ — Fase 2 del motore SMC\n * ---------------------------------------------------------------\n * EQH/EQL, PDH/PDL, PWH/PWL, estremi di sessione, liquidity sweep.\n *\n * Il punto su cui si sbaglia più spesso: il massimo del giorno\n * precedente è conoscibile solo quando quel giorno ha chiuso, e il\n * massimo di sessione solo a sessione finita. Usare l'estremo del\n * giorno corrente come livello di liquidità è look-ahead travestito\n * da livello, e non lo intercetta nessun controllo a valle.\n *\n * Secondo punto: una sweep non è una rottura. La differenza è la\n * profondità, e senza una soglia esplicita ogni breakout esteso\n * finisce classificato come sweep.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport { creaEvento, type Evento } from \"./eventi.ts\";\nimport type { Swing } from \"./struttura.ts\";\n\nexport const PARAMETRI_LIQ = {\n tolleranzaEq: 0.10, // ATR, per considerare due estremi \"uguali\" [0.05, 0.10, 0.20]\n finestraEq: 50, // barre entro cui cercare il cluster\n puntiMinimiEq: 2,\n profonditaMin: 0.05, // ATR: sotto è rumore, non una presa di liquidità\n profonditaMax: 0.30, // ATR: sopra è rottura strutturale, non una sweep [0.20,0.30,0.50]\n wickBody: 1.5, // rifiuto della wick [1.0, 1.5, 2.0]\n};\n\nexport type TipoLivello =\n | \"EQH\"\n | \"EQL\"\n | \"PDH\"\n | \"PDL\"\n | \"PWH\"\n | \"PWL\"\n | \"SESSION_HIGH\"\n | \"SESSION_LOW\"\n | \"SWING_HIGH\"\n | \"SWING_LOW\";\n\nexport type Livello = {\n prezzo: number;\n tipo: TipoLivello;\n lato: \"BUY_SIDE\" | \"SELL_SIDE\"; // dove stanno gli stop che verranno presi\n timeframe: string;\n creatoIndice: number; // barra in cui il livello si è formato\n confermaIndice: number; // barra da cui il sistema poteva conoscerlo\n esterna: boolean; // gerarchia: esterna batte interna\n tocchi: number;\n forza: number; // 0-1\n stato: \"ACTIVE\" | \"SWEPT\" | \"BROKEN\";\n};\n\n/* ------------------------- equal high / low ------------------------ */\n\n/**\n * Due estremi sono \"uguali\" quando distano meno di `tolleranza` ATR.\n * Il cluster è conoscibile solo dalla conferma dello swing più recente\n * che lo compone.\n */\nexport function equalLevels(\n swings: Swing[],\n atrSerie: (number | null)[],\n p = PARAMETRI_LIQ,\n): Livello[] {\n const out: Livello[] = [];\n\n for (const tipo of [\"HIGH\", \"LOW\"] as const) {\n const lista = swings.filter((s) => s.tipo === tipo);\n const usati = new Set();\n\n for (let i = 0; i < lista.length; i++) {\n if (usati.has(i)) continue;\n const base = lista[i];\n\n // L'ATR va letto quando il cluster diventa conoscibile, non alla\n // prima barra del gruppo: lì può essere ancora null e il cluster\n // verrebbe scartato in silenzio.\n const candidati = [base];\n for (let k = i + 1; k < lista.length; k++) {\n if (lista[k].indice - base.indice > p.finestraEq) break;\n candidati.push(lista[k]);\n }\n const rif = candidati[candidati.length - 1];\n const a = atrSerie[rif.confermaIndice] ?? atrSerie[rif.indice] ??\n [...atrSerie.slice(0, rif.indice + 1)].reverse().find((x) =>\n x !== null\n ) ?? null;\n if (a === null || a <= 0) continue;\n\n const gruppo = [base];\n for (let k = i + 1; k < lista.length; k++) {\n const c = lista[k];\n if (c.indice - base.indice > p.finestraEq) break;\n if (Math.abs(c.prezzo - base.prezzo) / a <= p.tolleranzaEq) {\n gruppo.push(c);\n usati.add(k);\n }\n }\n if (gruppo.length < p.puntiMinimiEq) continue;\n\n const ultimo = gruppo[gruppo.length - 1];\n out.push({\n prezzo: gruppo.reduce((s, x) => s + x.prezzo, 0) / gruppo.length,\n tipo: tipo === \"HIGH\" ? \"EQH\" : \"EQL\",\n // gli stop dei compratori stanno sotto i minimi: prenderli è sell-side\n lato: tipo === \"HIGH\" ? \"BUY_SIDE\" : \"SELL_SIDE\",\n timeframe: \"\",\n creatoIndice: ultimo.indice,\n confermaIndice: ultimo.confermaIndice,\n esterna: false,\n tocchi: gruppo.length,\n forza: Math.min(1, 0.4 + 0.2 * gruppo.length),\n stato: \"ACTIVE\",\n });\n }\n }\n return out;\n}\n\n/* ------------------- livelli di sessione e periodo ------------------ */\n\nconst giorno = (b: Barra) => b.t.slice(0, 10);\n\nfunction settimanaIso(iso: string) {\n const d = new Date(iso);\n const g = new Date(\n Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()),\n );\n g.setUTCDate(g.getUTCDate() + 4 - (g.getUTCDay() || 7));\n const inizio = new Date(Date.UTC(g.getUTCFullYear(), 0, 1));\n return `${g.getUTCFullYear()}-W${\n String(\n Math.ceil(((+g - +inizio) / 864e5 + 1) / 7),\n ).padStart(2, \"0\")\n }`;\n}\n\n/**\n * Raggruppa per periodo e produce i livelli del periodo PRECEDENTE,\n * confermati dalla prima barra del periodo successivo.\n *\n * Nessun orario codificato: i confini vengono dai dati, quindi la\n * funzione va bene per qualsiasi mercato e gestisce da sola festivi e\n * sessioni accorciate, come chiede la sezione 15.\n */\nexport function livelliPeriodo(\n barre: Barra[],\n chiave: (b: Barra) => string,\n tipoAlto: TipoLivello,\n tipoBasso: TipoLivello,\n): Livello[] {\n const periodi = new Map<\n string,\n { da: number; a: number; h: number; l: number }\n >();\n for (let i = 0; i < barre.length; i++) {\n const k = chiave(barre[i]);\n const p = periodi.get(k);\n if (!p) periodi.set(k, { da: i, a: i, h: barre[i].h, l: barre[i].l });\n else {\n p.a = i;\n p.h = Math.max(p.h, barre[i].h);\n p.l = Math.min(p.l, barre[i].l);\n }\n }\n\n const ordinati = [...periodi.entries()].sort((a, b) =>\n a[0].localeCompare(b[0])\n );\n const out: Livello[] = [];\n for (let k = 0; k < ordinati.length - 1; k++) {\n const [, p] = ordinati[k];\n const conferma = ordinati[k + 1][1].da; // prima barra del periodo dopo\n const base = {\n timeframe: \"\",\n creatoIndice: p.a,\n confermaIndice: conferma,\n esterna: true,\n tocchi: 1,\n forza: 0.8,\n stato: \"ACTIVE\" as const,\n };\n out.push({ ...base, prezzo: p.h, tipo: tipoAlto, lato: \"BUY_SIDE\" });\n out.push({ ...base, prezzo: p.l, tipo: tipoBasso, lato: \"SELL_SIDE\" });\n }\n return out;\n}\n\nexport const livelliGiornalieri = (b: Barra[]) =>\n livelliPeriodo(b, giorno, \"PDH\", \"PDL\");\nexport const livelliSettimanali = (b: Barra[]) =>\n livelliPeriodo(b, (x) => settimanaIso(x.t), \"PWH\", \"PWL\");\n\n/**\n * Sotto-sessioni (Asia, Londra, New York). Richiedono un profilo per\n * asset: senza, i livelli semplicemente non esistono invece di essere\n * inventati con orari universali che sarebbero sbagliati per metà dei\n * mercati.\n * @param profilo es. { Asia: [0,8], Londra: [8,13], NewYork: [13,21] } in ore UTC\n */\nexport function livelliSessione(\n barre: Barra[],\n profilo: Record | null,\n) {\n if (!profilo) {\n return {\n livelli: [] as Livello[],\n nota: \"nessun profilo di sessione per questo asset\",\n };\n }\n const out: Livello[] = [];\n for (const [nome, [da, a]] of Object.entries(profilo)) {\n const perGiorno = new Map<\n string,\n { da: number; a: number; h: number; l: number }\n >();\n for (let i = 0; i < barre.length; i++) {\n const ora = Number(barre[i].t.slice(11, 13));\n if (ora < da || ora >= a) continue;\n const g = giorno(barre[i]);\n const p = perGiorno.get(g);\n if (!p) perGiorno.set(g, { da: i, a: i, h: barre[i].h, l: barre[i].l });\n else {\n p.a = i;\n p.h = Math.max(p.h, barre[i].h);\n p.l = Math.min(p.l, barre[i].l);\n }\n }\n for (const [, p] of perGiorno) {\n // conoscibile dalla prima barra dopo la chiusura della sessione\n const conferma = Math.min(p.a + 1, barre.length - 1);\n if (conferma <= p.a) continue;\n const base = {\n timeframe: nome,\n creatoIndice: p.a,\n confermaIndice: conferma,\n esterna: false,\n tocchi: 1,\n forza: 0.5,\n stato: \"ACTIVE\" as const,\n };\n out.push({\n ...base,\n prezzo: p.h,\n tipo: \"SESSION_HIGH\",\n lato: \"BUY_SIDE\",\n });\n out.push({\n ...base,\n prezzo: p.l,\n tipo: \"SESSION_LOW\",\n lato: \"SELL_SIDE\",\n });\n }\n }\n return { livelli: out, nota: null };\n}\n\n/* -------------------------- gerarchia ------------------------------ */\n\n/** Livelli conoscibili alla barra `i`, ordinati per vicinanza al prezzo. */\nexport function livelliAttivi(livelli: Livello[], i: number, prezzo: number) {\n return livelli\n .filter((l) => l.confermaIndice <= i && l.stato === \"ACTIVE\")\n .map((l) => ({ ...l, distanza: Math.abs(l.prezzo - prezzo) }))\n .sort((a, b) =>\n // esterna prima di interna, poi per vicinanza\n (Number(b.esterna) - Number(a.esterna)) || (a.distanza - b.distanza)\n );\n}\n\n/* ---------------------------- sweep -------------------------------- */\n\n/**\n * Sweep rialzista: il prezzo scende sotto il livello e RICHIUDE sopra\n * nella stessa barra. Se chiude sotto è una rottura, non una presa.\n *\n * La profondità separa i due casi: oltre `profonditaMax` ATR non è più\n * una sweep ma un movimento strutturale che è andato altrove.\n */\nexport function trovaSweep(\n barre: Barra[],\n atrSerie: (number | null)[],\n livelli: Livello[],\n ticker: string,\n timeframe: string,\n p = PARAMETRI_LIQ,\n): { eventi: Evento[]; sweeps: any[] } {\n const eventi: Evento[] = [];\n const sweeps: any[] = [];\n\n for (let i = 0; i < barre.length; i++) {\n const a = atrSerie[i];\n if (a === null || a <= 0) continue;\n const b = barre[i];\n const corpo = Math.abs(b.c - b.o) || a * 0.01;\n\n for (const l of livelli) {\n if (l.confermaIndice > i || l.stato !== \"ACTIVE\") continue;\n\n // Attraversato in chiusura senza recupero: il livello è rotto, non\n // sweepato. Senza questo ramo un livello superato resterebbe ACTIVE\n // per sempre e continuerebbe a comparire fra i bersagli.\n const oltreSotto = l.lato === \"SELL_SIDE\" &&\n b.c < l.prezzo - p.profonditaMin * a;\n const oltreSopra = l.lato === \"BUY_SIDE\" &&\n b.c > l.prezzo + p.profonditaMin * a;\n if (oltreSotto || oltreSopra) {\n l.stato = \"BROKEN\";\n continue;\n }\n\n // rialzista: presa di liquidità sotto, recupero sopra\n if (l.lato === \"SELL_SIDE\" && b.l < l.prezzo && b.c > l.prezzo) {\n const prof = (l.prezzo - b.l) / a;\n if (prof < p.profonditaMin) continue;\n if (prof > p.profonditaMax) {\n l.stato = \"BROKEN\";\n continue;\n }\n const wick = (Math.min(b.o, b.c) - b.l) / corpo;\n l.stato = \"SWEPT\";\n const s = {\n indice: i,\n direzione: \"BULL\",\n livello: l,\n profondita: prof,\n wick,\n };\n sweeps.push(s);\n eventi.push(creaEvento(\n {\n ticker,\n timeframe,\n tipo: \"SWEEP_BULL\",\n prezzo: l.prezzo,\n forza: Math.min(\n 1,\n 0.5 + (wick >= p.wickBody ? 0.3 : 0) + l.forza * 0.2,\n ),\n dati: {\n tipoLivello: l.tipo,\n profonditaAtr: +prof.toFixed(3),\n wickSuCorpo: +wick.toFixed(2),\n rifiuto: wick >= p.wickBody,\n esterna: l.esterna,\n },\n },\n barre,\n i,\n 0,\n ));\n }\n\n // ribassista: presa sopra, recupero sotto\n if (l.lato === \"BUY_SIDE\" && b.h > l.prezzo && b.c < l.prezzo) {\n const prof = (b.h - l.prezzo) / a;\n if (prof < p.profonditaMin) continue;\n if (prof > p.profonditaMax) {\n l.stato = \"BROKEN\";\n continue;\n }\n const wick = (b.h - Math.max(b.o, b.c)) / corpo;\n l.stato = \"SWEPT\";\n sweeps.push({\n indice: i,\n direzione: \"BEAR\",\n livello: l,\n profondita: prof,\n wick,\n });\n eventi.push(creaEvento(\n {\n ticker,\n timeframe,\n tipo: \"SWEEP_BEAR\",\n prezzo: l.prezzo,\n forza: Math.min(\n 1,\n 0.5 + (wick >= p.wickBody ? 0.3 : 0) + l.forza * 0.2,\n ),\n dati: {\n tipoLivello: l.tipo,\n profonditaAtr: +prof.toFixed(3),\n wickSuCorpo: +wick.toFixed(2),\n rifiuto: wick >= p.wickBody,\n esterna: l.esterna,\n },\n },\n barre,\n i,\n 0,\n ));\n }\n }\n }\n return { eventi, sweeps };\n}\n\n/* --------------------------- orchestratore ------------------------- */\n\nexport function analizzaLiquidita(\n barre: Barra[],\n swings: Swing[],\n atrSerie: (number | null)[],\n ticker: string,\n timeframe: string,\n opzioni: {\n profiloSessione?: Record | null;\n intraday?: boolean;\n } = {},\n) {\n const eq = equalLevels(swings, atrSerie).map((l) => ({ ...l, timeframe }));\n const gg = livelliGiornalieri(barre).map((l) => ({ ...l, timeframe }));\n const ss = opzioni.intraday === false\n ? []\n : livelliSettimanali(barre).map((l) => ({ ...l, timeframe }));\n const sess = livelliSessione(barre, opzioni.profiloSessione ?? null);\n\n const livelli = [...gg, ...ss, ...eq, ...sess.livelli];\n const { eventi, sweeps } = trovaSweep(\n barre,\n atrSerie,\n livelli,\n ticker,\n timeframe,\n );\n\n return {\n livelli,\n eventi,\n sweeps,\n note: [\n sess.nota,\n `${eq.length} cluster EQH/EQL, ${gg.length} livelli giornalieri, ${ss.length} settimanali`,\n ].filter(Boolean),\n };\n}",[228],"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}",[235],"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}",[243],"82bb2ff6-9c9e-40b3-ac01-8d1783be5644","facts.ts","5ead4cd6-ab91-11f1-8805-1607ee4eb77e",11,["D",1788879199392],"/* =====================================================================\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}",[250],"99135c96-4899-4336-a663-4af8345e23d5","eventi.ts","ada1f09a-ac3f-11f1-a156-1607ee4eb77e",68,["D",1788952501197],"/* =====================================================================\n * EVENTI — archivio strutturale SMC\n * ---------------------------------------------------------------\n * Il punto 33 della specifica è il requisito più facile da violare in\n * silenzio. Qui non è affidato a un controllo: è reso impossibile\n * dalla forma dell'interfaccia.\n *\n * Ogni evento porta due tempi:\n * accaduto quando il fatto è avvenuto sul grafico\n * confermato quando il sistema poteva saperlo\n *\n * E la funzione di lettura richiede `asOf` come parametro obbligatorio.\n * Non esiste una versione che lo ometta: per leggere gli eventi devi\n * dichiarare a che ora ti trovi, e ottieni solo ciò che a quell'ora era\n * conoscibile.\n *\n * Conseguenza che quasi tutti i backtest SMC ignorano: un BOS non può\n * essere datato prima della conferma dello swing che rompe. Se lo swing\n * si conferma due barre dopo essersi formato, e il prezzo lo rompe nel\n * frattempo, il BOS esiste solo dalla conferma in poi.\n * ===================================================================== */\n\nexport type TipoEvento =\n | \"SWING_HIGH\"\n | \"SWING_LOW\"\n | \"HH\"\n | \"HL\"\n | \"LH\"\n | \"LL\"\n | \"BOS_BULL\"\n | \"BOS_BEAR\"\n | \"CHOCH_BULL\"\n | \"CHOCH_BEAR\"\n | \"MSS_BULL\"\n | \"MSS_BEAR\"\n | \"EQH\"\n | \"EQL\"\n | \"SWEEP_BULL\"\n | \"SWEEP_BEAR\"\n | \"DISPLACEMENT_BULL\"\n | \"DISPLACEMENT_BEAR\"\n | \"FVG_BULL\"\n | \"FVG_BEAR\"\n | \"OB_BULL\"\n | \"OB_BEAR\";\n\nexport type Stato =\n | \"ACTIVE\"\n | \"PARTIALLY_FILLED\"\n | \"FILLED\"\n | \"INVALIDATED\"\n | \"CONSUMED\";\n\nexport type Evento = {\n ticker: string;\n timeframe: string;\n tipo: TipoEvento;\n accaduto: string; // ISO: apertura della barra in cui il fatto è avvenuto\n confermato: string; // ISO: prima ora in cui il sistema poteva saperlo\n barraIndice: number; // indice nella serie: serve all'anti-doppio-conteggio\n prezzo: number | null;\n zonaAlta?: number | null; // FVG e OB\n zonaBassa?: number | null;\n forza?: number | null; // 0-1, normalizzata in ATR dove ha senso\n stato: Stato;\n collegati?: string[]; // id di eventi correlati\n dati?: Record;\n};\n\nexport const idEvento = (e: Evento) =>\n `${e.ticker}|${e.timeframe}|${e.tipo}|${e.accaduto}`;\n\n/* ------------------------- costruzione ----------------------------- */\n\n/**\n * Unico costruttore ammesso. Impone il ritardo di conferma invece di\n * lasciarlo alla diligenza di chi scrive il rilevatore.\n *\n * @param barre serie crescente, serve per tradurre indici in tempi\n * @param indice barra in cui il fatto è avvenuto\n * @param ritardoBarre quante barre servono perché il fatto sia conoscibile\n */\nexport function creaEvento(\n base:\n & Omit\n & { stato?: Stato },\n barre: { t: string }[],\n indice: number,\n ritardoBarre = 0,\n): Evento {\n if (indice < 0 || indice >= barre.length) {\n throw new Error(`indice barra fuori serie: ${indice}`);\n }\n const iConferma = indice + ritardoBarre;\n if (iConferma >= barre.length) {\n throw new Error(\n `evento ${base.tipo} non ancora confermabile: servono ${ritardoBarre} barre ` +\n `dopo l'indice ${indice}, la serie ne ha ${barre.length}`,\n );\n }\n return {\n ...base,\n accaduto: barre[indice].t,\n confermato: barre[iConferma].t,\n barraIndice: indice,\n stato: base.stato ?? \"ACTIVE\",\n };\n}\n\n/* --------------------------- lettura ------------------------------- */\n\n/**\n * `asOf` non ha valore predefinito, ed è deliberato: un default\n * trasformerebbe una dimenticanza in un backtest che bara.\n */\nexport function leggi(\n eventi: Evento[],\n asOf: string,\n filtro: Partial = {},\n) {\n if (!asOf) {\n throw new Error(\n \"leggi() richiede asOf: senza, il risultato contiene il futuro\",\n );\n }\n return eventi.filter((e) => {\n if (e.confermato > asOf) return false;\n for (const [k, v] of Object.entries(filtro)) {\n if (v !== undefined && (e as any)[k] !== v) return false;\n }\n return true;\n });\n}\n\n/** L'ultimo evento conoscibile di un tipo. */\nexport function ultimo(eventi: Evento[], asOf: string, tipi: TipoEvento[]) {\n const c = leggi(eventi, asOf).filter((e) => tipi.includes(e.tipo));\n return c.length\n ? c.reduce((a, b) => (b.confermato > a.confermato ? b : a))\n : null;\n}\n\n/* -------------------- anti doppio conteggio ------------------------ */\n\n/**\n * Sezione 19 della specifica. Displacement, FVG e Order Block nascono\n * spesso dalla stessa candela: contarli tre volte gonfia il punteggio\n * senza aggiungere informazione.\n *\n * Il raggruppamento è per indice di barra, non per tempo: su timeframe\n * diversi lo stesso istante è barre diverse, e devono restare distinte.\n */\nexport function raggruppaPerOrigine(eventi: Evento[]) {\n const gruppi = new Map();\n for (const e of eventi) {\n const k = `${e.timeframe}|${e.barraIndice}`;\n if (!gruppi.has(k)) gruppi.set(k, []);\n gruppi.get(k)!.push(e);\n }\n return gruppi;\n}\n\n/**\n * Applica i pesi contando una volta sola gli eventi nati dalla stessa\n * barra: vale il maggiore fra loro.\n * @returns { totale, contributi } — i contributi restano visibili perché\n * la sezione 18 chiede un punteggio spiegabile, non solo un numero\n */\nexport function punteggioSenzaDuplicati(\n eventi: Evento[],\n pesi: Record,\n) {\n const contributi: any[] = [];\n let totale = 0;\n\n for (const [origine, gruppo] of raggruppaPerOrigine(eventi)) {\n const pesati = gruppo\n .map((e) => ({ evento: e, peso: pesi[e.tipo] ?? 0 }))\n .filter((x) => x.peso > 0)\n .sort((a, b) => b.peso - a.peso);\n if (!pesati.length) continue;\n\n const vincitore = pesati[0];\n totale += vincitore.peso;\n contributi.push({\n tipo: vincitore.evento.tipo,\n peso: vincitore.peso,\n origine,\n accaduto: vincitore.evento.accaduto,\n assorbiti: pesati.slice(1).map((x) => x.evento.tipo),\n });\n }\n\n return { totale: Math.min(100, totale), contributi };\n}\n\n/* --------------------------- persistenza --------------------------- */\n\nexport const SCHEMA_SQL = `CREATE TABLE IF NOT EXISTS eventi (\n id TEXT PRIMARY KEY,\n ticker TEXT NOT NULL,\n timeframe TEXT NOT NULL,\n tipo TEXT NOT NULL,\n accaduto TEXT NOT NULL,\n confermato TEXT NOT NULL,\n barra_indice INTEGER NOT NULL,\n prezzo REAL,\n zona_alta REAL,\n zona_bassa REAL,\n forza REAL,\n stato TEXT NOT NULL,\n dati TEXT\n)`;\n\nexport const INDICI_SQL = [\n `CREATE INDEX IF NOT EXISTS ix_eventi_lettura ON eventi (ticker, timeframe, confermato)`,\n `CREATE INDEX IF NOT EXISTS ix_eventi_tipo ON eventi (ticker, tipo, confermato)`,\n];\n\nexport function perDb(e: Evento) {\n return [\n idEvento(e),\n e.ticker,\n e.timeframe,\n e.tipo,\n e.accaduto,\n e.confermato,\n e.barraIndice,\n e.prezzo ?? null,\n e.zonaAlta ?? null,\n e.zonaBassa ?? null,\n e.forza ?? null,\n e.stato,\n e.dati ? JSON.stringify(e.dati) : null,\n ];\n}\n\nexport function daDb(r: any[]): Evento {\n return {\n ticker: String(r[1]),\n timeframe: String(r[2]),\n tipo: String(r[3]) as TipoEvento,\n accaduto: String(r[4]),\n confermato: String(r[5]),\n barraIndice: Number(r[6]),\n prezzo: r[7] === null ? null : Number(r[7]),\n zonaAlta: r[8] === null ? null : Number(r[8]),\n zonaBassa: r[9] === null ? null : Number(r[9]),\n forza: r[10] === null ? null : Number(r[10]),\n stato: String(r[11]) as Stato,\n dati: r[12] ? JSON.parse(String(r[12])) : undefined,\n };\n}",[257],"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}",[264],"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}",[271],"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};",[279],"41958607-87a8-4f1d-b153-595e479675e2","consegna.ts","d9a24434-ac4d-11f1-97d8-1607ee4eb77e",80,["D",1788958593056],"/* =====================================================================\n * CONSEGNA DEL PREZZO — Fase 3 del motore SMC\n * ---------------------------------------------------------------\n * Fair Value Gap e Order Block. Il displacement sta già in struttura.ts\n * perché serve al MSS.\n *\n * Due accortezze che nella maggior parte delle implementazioni mancano.\n *\n * La prima: un Order Block esiste solo a posteriori. La candela è là\n * da prima, ma diventa un OB soltanto quando arriva il displacement che\n * la qualifica. Il suo `accaduto` è la candela, il suo `confermato` è\n * il displacement — e fra i due possono passare diverse barre.\n *\n * La seconda: lo stato di riempimento di una zona non è un attributo\n * della zona, è una funzione del tempo. Salvare \"FILLED\" dentro\n * l'oggetto significa che un backtest a metà serie legge uno stato\n * che si è formato dopo. Qui lo stato si calcola sempre `fino a` una\n * barra precisa.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport { creaEvento, type Evento } from \"./eventi.ts\";\nimport { displacement, PARAMETRI } from \"./struttura.ts\";\n\nexport const PARAMETRI_ZONE = {\n fvgMinAtr: 0.10, // sotto è rumore [0.05, 0.10, 0.20, 0.25]\n fvgForteAtr: 0.25, // soglia \"strong\"\n obRicercaMax: 10, // barre indietro entro cui cercare la candela opposta\n riempimentoParziale: 0.50,\n};\n\nexport type Zona = {\n tipo: \"FVG\" | \"OB\";\n direzione: \"BULL\" | \"BEAR\";\n alto: number;\n basso: number;\n creataIndice: number; // barra in cui la zona si è formata\n confermaIndice: number; // barra da cui il sistema poteva conoscerla\n ampiezzaAtr: number;\n forte: boolean;\n origineIndice: number; // barra che l'ha generata: serve all'anti-doppio-conteggio\n dati?: Record;\n};\n\n/* ------------------------------- FVG ------------------------------- */\n\n/**\n * Definizione classica a tre candele. La terza chiude alla barra `i`,\n * quindi il gap è conoscibile esattamente lì: nessun ritardo.\n */\nexport function trovaFVG(\n barre: Barra[],\n atrSerie: (number | null)[],\n p = PARAMETRI_ZONE,\n): Zona[] {\n const out: Zona[] = [];\n for (let i = 2; i < barre.length; i++) {\n const a = atrSerie[i];\n if (a === null || a <= 0) continue;\n const c1 = barre[i - 2], c3 = barre[i];\n\n if (c3.l > c1.h) {\n const amp = (c3.l - c1.h) / a;\n if (amp >= p.fvgMinAtr) {\n out.push({\n tipo: \"FVG\",\n direzione: \"BULL\",\n alto: c3.l,\n basso: c1.h,\n creataIndice: i,\n confermaIndice: i,\n ampiezzaAtr: +amp.toFixed(3),\n forte: amp >= p.fvgForteAtr,\n origineIndice: i - 1,\n });\n }\n }\n if (c3.h < c1.l) {\n const amp = (c1.l - c3.h) / a;\n if (amp >= p.fvgMinAtr) {\n out.push({\n tipo: \"FVG\",\n direzione: \"BEAR\",\n alto: c1.l,\n basso: c3.h,\n creataIndice: i,\n confermaIndice: i,\n ampiezzaAtr: +amp.toFixed(3),\n forte: amp >= p.fvgForteAtr,\n origineIndice: i - 1,\n });\n }\n }\n }\n return out;\n}\n\n/* ---------------------------- Order Block -------------------------- */\n\n/**\n * Ultima candela di direzione opposta prima del displacement.\n * V1 usa l'intero range della candela, opzione A della specifica.\n *\n * @param rotture indici delle barre che hanno prodotto BOS o MSS:\n * un OB nato da un displacement che rompe struttura vale di più\n */\nexport function trovaOrderBlock(\n barre: Barra[],\n atrSerie: (number | null)[],\n rotture: Set = new Set(),\n p = PARAMETRI_ZONE,\n pd = PARAMETRI,\n): Zona[] {\n const out: Zona[] = [];\n // Displacement consecutivi trovano la stessa candela opposta: senza\n // deduplica lo stesso Order Block viene registrato più volte e il\n // punteggio lo conta a ogni ripetizione.\n const gia = new Set();\n\n for (let i = 1; i < barre.length; i++) {\n const d = displacement(barre[i], atrSerie[i], pd);\n if (!d) continue;\n\n const opposta = d.direzione === \"BULL\"\n ? (b: Barra) => b.c < b.o\n : (b: Barra) => b.c > b.o;\n\n let j = -1;\n for (let k = i - 1; k >= Math.max(0, i - p.obRicercaMax); k--) {\n if (opposta(barre[k])) {\n j = k;\n break;\n }\n }\n if (j < 0) continue;\n const firma = `${j}|${d.direzione}`;\n if (gia.has(firma)) continue; // prima conferma vince\n gia.add(firma);\n\n const a = atrSerie[i]!;\n out.push({\n tipo: \"OB\",\n direzione: d.direzione,\n alto: barre[j].h,\n basso: barre[j].l,\n creataIndice: j,\n // conoscibile solo quando arriva il displacement che la qualifica\n confermaIndice: i,\n ampiezzaAtr: +((barre[j].h - barre[j].l) / a).toFixed(3),\n forte: rotture.has(i) && d.livello >= 2,\n origineIndice: i,\n dati: {\n displacementBarra: i,\n rapportoAtr: +d.rapporto.toFixed(3),\n conRottura: rotture.has(i),\n ritardoBarre: i - j,\n },\n });\n }\n return out;\n}\n\n/* -------------------- stato in funzione del tempo ------------------ */\n\n/**\n * Stato della zona osservato ALLA barra `fino`, non in assoluto.\n * Guarda solo le barre fra la conferma e `fino`.\n */\nexport function statoZona(z: Zona, barre: Barra[], fino: number) {\n if (fino < z.confermaIndice) {\n return { stato: \"NON_ANCORA\" as const, riempimento: 0, invalidataA: null };\n }\n\n const altezza = z.alto - z.basso;\n let penetrazione = 0;\n\n for (\n let i = z.confermaIndice + 1; i <= Math.min(fino, barre.length - 1); i++\n ) {\n const b = barre[i];\n\n // invalidazione: chiusura oltre il lato protetto della zona\n if (z.direzione === \"BULL\" && b.c < z.basso) {\n return { stato: \"INVALIDATED\" as const, riempimento: 1, invalidataA: i };\n }\n if (z.direzione === \"BEAR\" && b.c > z.alto) {\n return { stato: \"INVALIDATED\" as const, riempimento: 1, invalidataA: i };\n }\n\n // riempimento: quanto il prezzo è rientrato nella zona\n const dentro = z.direzione === \"BULL\"\n ? Math.max(0, z.alto - Math.max(b.l, z.basso))\n : Math.max(0, Math.min(b.h, z.alto) - z.basso);\n if (altezza > 0) {penetrazione = Math.max(\n penetrazione,\n Math.min(1, dentro / altezza),\n );}\n }\n\n return {\n stato: penetrazione >= 0.999\n ? \"FILLED\" as const\n : penetrazione >= PARAMETRI_ZONE.riempimentoParziale\n ? \"PARTIALLY_FILLED\" as const\n : \"ACTIVE\" as const,\n riempimento: +penetrazione.toFixed(3),\n invalidataA: null,\n };\n}\n\n/** Zone utilizzabili alla barra `i`: conoscibili, non riempite, non invalidate. */\nexport function zoneAttive(\n zone: Zona[],\n barre: Barra[],\n i: number,\n direzione?: \"BULL\" | \"BEAR\",\n) {\n return zone\n .filter((z) => z.confermaIndice <= i)\n .filter((z) => !direzione || z.direzione === direzione)\n .map((z) => ({ zona: z, ...statoZona(z, barre, i) }))\n .filter((x) => x.stato === \"ACTIVE\" || x.stato === \"PARTIALLY_FILLED\")\n .sort((a, b) =>\n Math.abs(barre[i].c - centro(a.zona)) -\n Math.abs(barre[i].c - centro(b.zona))\n );\n}\n\nexport const centro = (z: Zona) => (z.alto + z.basso) / 2;\n\n/**\n * Intersezione fra FVG e Order Block: dove le due zone si sovrappongono\n * la qualità è più alta, ed è lì che la specifica colloca la entry zone.\n */\nexport function intersezione(a: Zona, b: Zona) {\n const alto = Math.min(a.alto, b.alto);\n const basso = Math.max(a.basso, b.basso);\n return alto > basso ? { alto, basso, ampiezza: alto - basso } : null;\n}\n\n/* --------------------------- orchestratore ------------------------- */\n\nexport function analizzaConsegna(\n barre: Barra[],\n atrSerie: (number | null)[],\n eventiStruttura: Evento[],\n ticker: string,\n timeframe: string,\n) {\n const rotture = new Set(\n eventiStruttura.filter((e) => /^(BOS|MSS)_/.test(e.tipo)).map((e) =>\n e.barraIndice\n ),\n );\n\n const fvg = trovaFVG(barre, atrSerie);\n const ob = trovaOrderBlock(barre, atrSerie, rotture);\n const eventi: Evento[] = [];\n\n const aggiungi = (z: Zona) => {\n try {\n eventi.push(creaEvento(\n {\n ticker,\n timeframe,\n tipo: `${z.tipo === \"FVG\" ? \"FVG\" : \"OB\"}_${z.direzione}` as any,\n prezzo: centro(z),\n zonaAlta: z.alto,\n zonaBassa: z.basso,\n forza: Math.min(1, z.ampiezzaAtr / 0.5),\n dati: { ampiezzaAtr: z.ampiezzaAtr, forte: z.forte, ...z.dati },\n },\n barre,\n z.creataIndice,\n z.confermaIndice - z.creataIndice,\n ));\n } catch { /* non ancora confermabile */ }\n };\n fvg.forEach(aggiungi);\n ob.forEach(aggiungi);\n\n return {\n zone: [...fvg, ...ob],\n eventi,\n riepilogo: {\n fvg: fvg.length,\n fvgForti: fvg.filter((z) => z.forte).length,\n ob: ob.length,\n obConRottura: ob.filter((z) => z.forte).length,\n ritardoMedioOb: ob.length\n ? +(ob.reduce((s, z) => s + (z.confermaIndice - z.creataIndice), 0) /\n ob.length).toFixed(2)\n : null,\n },\n };\n}",[286],"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}",[293],"pulls","branches",1,"forks","envVars",{"_308":163,"_310":61},"connections",{"_308":61,"_309":61},"count","unfilledCount","emptyCount",{"_43":292,"_33":293,"_31":294,"_150":-5,"_41":42,"_40":295,"_152":24,"_38":393,"_13":297,"_34":35,"_36":298,"_23":26,"_156":-5,"_333":394,"_27":395},{"_43":285,"_33":286,"_31":287,"_150":-5,"_41":42,"_40":288,"_152":26,"_38":390,"_13":154,"_34":35,"_36":290,"_23":26,"_156":-5,"_333":391,"_27":392},{"_43":278,"_33":279,"_31":280,"_150":-5,"_41":42,"_40":281,"_152":24,"_38":387,"_13":154,"_34":35,"_36":283,"_23":26,"_156":-5,"_333":388,"_27":389},{"_43":270,"_33":271,"_31":272,"_150":-5,"_41":42,"_40":273,"_152":24,"_38":384,"_13":239,"_34":275,"_36":276,"_23":26,"_156":-5,"_333":385,"_27":386},{"_43":263,"_33":264,"_31":265,"_150":-5,"_41":42,"_40":266,"_152":24,"_38":381,"_13":178,"_34":35,"_36":268,"_23":26,"_156":-5,"_333":382,"_27":383},{"_43":256,"_33":257,"_31":258,"_150":-5,"_41":42,"_40":259,"_152":26,"_38":378,"_13":154,"_34":35,"_36":261,"_23":26,"_156":-5,"_333":379,"_27":380},{"_43":249,"_33":250,"_31":251,"_150":-5,"_41":42,"_40":252,"_152":24,"_38":375,"_13":178,"_34":35,"_36":254,"_23":26,"_156":-5,"_333":376,"_27":377},{"_43":242,"_33":243,"_31":244,"_150":-5,"_41":42,"_40":245,"_152":24,"_38":372,"_13":154,"_34":35,"_36":247,"_23":26,"_156":-5,"_333":373,"_27":374},{"_43":234,"_33":235,"_31":236,"_150":-5,"_41":42,"_40":237,"_152":24,"_38":369,"_13":239,"_34":35,"_36":240,"_23":26,"_156":-5,"_333":370,"_27":371},{"_43":227,"_33":228,"_31":229,"_150":-5,"_41":42,"_40":230,"_152":26,"_38":366,"_13":154,"_34":35,"_36":232,"_23":26,"_156":-5,"_333":367,"_27":368},{"_43":219,"_33":220,"_31":56,"_150":-5,"_41":42,"_40":221,"_152":26,"_38":363,"_13":223,"_34":224,"_36":225,"_23":26,"_156":-5,"_333":364,"_27":365},{"_43":216,"_33":28,"_31":32,"_150":-5,"_41":42,"_40":14,"_152":26,"_38":360,"_13":61,"_34":35,"_36":37,"_23":26,"_156":-5,"_333":361,"_27":362},{"_43":209,"_33":210,"_31":211,"_150":-5,"_41":42,"_40":212,"_152":24,"_38":357,"_13":154,"_34":35,"_36":214,"_23":26,"_156":-5,"_333":358,"_27":359},{"_43":202,"_33":203,"_31":204,"_150":-5,"_41":42,"_40":205,"_152":26,"_38":354,"_13":154,"_34":35,"_36":207,"_23":26,"_156":-5,"_333":355,"_27":356},{"_43":195,"_33":196,"_31":197,"_150":-5,"_41":42,"_40":198,"_152":26,"_38":351,"_13":154,"_34":35,"_36":200,"_23":26,"_156":-5,"_333":352,"_27":353},{"_43":188,"_33":189,"_31":190,"_150":-5,"_41":42,"_40":191,"_152":26,"_38":348,"_13":154,"_34":35,"_36":193,"_23":26,"_156":-5,"_333":349,"_27":350},{"_43":181,"_33":182,"_31":183,"_150":-5,"_41":42,"_40":184,"_152":26,"_38":345,"_13":178,"_34":35,"_36":186,"_23":26,"_156":-5,"_333":346,"_27":347},{"_43":173,"_33":174,"_31":175,"_150":-5,"_41":42,"_40":176,"_152":26,"_38":342,"_13":178,"_34":35,"_36":179,"_23":26,"_156":-5,"_333":343,"_27":344},{"_43":166,"_33":167,"_31":168,"_150":-5,"_41":42,"_40":169,"_152":26,"_38":339,"_13":154,"_34":35,"_36":171,"_23":26,"_156":-5,"_333":340,"_27":341},{"_43":158,"_33":159,"_31":160,"_150":-5,"_41":42,"_40":161,"_152":26,"_38":336,"_13":163,"_34":35,"_36":164,"_23":26,"_156":-5,"_333":337,"_27":338},{"_43":147,"_33":148,"_31":149,"_150":-5,"_41":42,"_40":151,"_152":24,"_38":332,"_13":154,"_34":35,"_36":155,"_23":26,"_156":-5,"_333":334,"_27":335},["D",1788901092981],"children",[],[148],["D",1788901488510],[],[159],["D",1788952877317],[],[167],["D",1788991053481],[],[174],["D",1788901499568],[],[182],["D",1788952517285],[],[189],["D",1788990719320],[],[196],["D",1788991041158],[],[203],["D",1788901455880],[],[210],["D",1788991330695],[],[28],["D",1788949871978],[],[220],["D",1788957724576],[],[228],["D",1788900908496],[],[235],["D",1788900591280],[],[243],["D",1788879199392],[],[250],["D",1788952501197],[],[257],["D",1788901174031],[],[264],["D",1788900300372],[],[271],["D",1788894870909],[],[279],["D",1788958593056],[],[286],["D",1788950057578],[],[293],["D",1788877625254],["D",1789572079973],{"_98":97,"_104":37},{"_98":97,"_99":37,"_100":37,"_18":54,"_101":102,"_103":26},{"_13":87,"_33":88,"_43":42,"_89":44,"_90":-5,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":45,"_96":97},"ctx",{"_80":-5,"_123":434,"_435":436,"_437":438,"_439":26,"_440":26,"_441":26,"_442":24,"_443":-5,"_444":-7,"_445":-7,"_446":61,"_447":26,"_448":26,"_449":-5,"_450":26,"_451":26,"_452":26,"_453":-5},"ENV",{"_405":406,"_407":408,"_409":88,"_410":411,"_412":413,"_414":415,"_416":417,"_418":419,"_420":421,"_422":423,"_424":425,"_426":427,"_428":429,"_430":431,"_432":433},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","9e167d8120a57de5d747867e0b686da51bcc19a4","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"]

Diff · v91