[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8,"_9":10},"actionData","errors","root",{"_335":336,"_337":338},"routes/_app.x.$handle.$name",{"_99":98,"_32":44,"_106":89,"_27":53,"_13":14,"_107":-5,"_11":108,"_109":110,"_111":112,"_113":114,"_115":116,"_20":-5,"_117":-5,"_118":-5,"_119":48,"_120":121,"_122":25,"_123":-5,"_124":-5,"_125":126},"routes/_app.x.$handle.$name.branch.$branch.version.$version.diff",{"_11":12,"_13":14,"_15":16,"_17":-5,"_18":-5},"project",{"_42":43,"_32":44,"_37":45,"_46":-5,"_47":48,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":57,"_58":25,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":66,"_67":68,"_69":70,"_71":-5,"_72":73,"_74":73,"_75":76,"_77":76,"_78":76,"_79":73,"_80":73,"_81":82,"_83":84,"_85":86,"_87":48},"version",118,"changes",[19],"aiChatInfo","userId",{"_20":21,"_22":23,"_24":25,"_26":25,"_27":28,"_29":28},"file",{"_30":31,"_32":28,"_33":34,"_35":36,"_37":38,"_39":14,"_40":41,"_24":25},"previous",{"_30":31,"_32":28,"_33":34,"_35":36},"deleted",true,"deletedHere","path","posizione.ts","latestPath","fileId","a98f0886-ac98-11f1-852a-1607ee4eb77e","name","fileType","script","content","/* =====================================================================\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}","createdAt",["D",1789132378103],"branchVersion","branchId","5e3db326-f6b3-4bc5-a5cd-b244c32f6cbf","id","d095f470-1674-4a4d-9ace-b88544e253d1","desk-api",["D",1788877625254],"deletedAt","legacyEnvVars",false,"privacy","public","httpPrivacy","description","","imageUrl","4f82c29c-9334-4b68-869b-01f1e3424455","pinnedFileId","69636a3e-ab91-11f1-a1a4-1607ee4eb77e","pinPreview","pinMigrated","screenshotVersion","likeCount",0,"orgId","01a08168-2ad6-7239-bb3f-de6b9862c6c1","tursoName","d095f47016744a4d9aceb88544e253d1","tursoHostname","d095f47016744a4d9aceb88544e253d1-val-town.aws-us-east-2.turso.io","tursoMeasuredAt",["D",1789485645684],"pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_99":98,"_105":53},"org",{"_99":98,"_100":53,"_101":53,"_18":55,"_102":103,"_104":48},"branch",{"_13":88,"_32":89,"_42":41,"_90":43,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":44,"_97":98},"isOwned",134,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","Checco27","handle","displayName","avatar","tier","free","canRestrictVals","profileImageUrl","branchName","adoptOrgId",{"_42":43,"_32":44,"_37":330,"_46":-5,"_47":48,"_49":50,"_51":50,"_52":53,"_54":-5,"_18":55,"_56":57,"_58":25,"_59":-5,"_60":-5,"_61":62,"_63":64,"_65":66,"_67":68,"_69":331,"_71":-5,"_72":73,"_74":73,"_75":76,"_77":76,"_78":76,"_79":73,"_80":73,"_81":332,"_83":333,"_85":334,"_87":48},"tree",[269,270,271,272,273,274,275,276,277,278,279,280,281,282,283],"files",[269,270,271,272,273,274,275,276,277,278,279,280,281,282,283],"counts",{"_258":62,"_259":260,"_261":62,"_262":263,"_264":265},"contents",[127,128,129,130,131,132,133,134,135,136,137,138,139,140,141],"upstreamProject","upstreamBranch","emptyEnvVars","flags",[],"hasHttpFiles","grants","orgs","customDomains",{},{"_42":251,"_32":252,"_30":253,"_145":-5,"_40":41,"_39":254,"_147":48,"_37":255,"_13":248,"_33":34,"_35":256,"_24":48,"_151":-5,"_27":257},{"_42":243,"_32":244,"_30":245,"_145":-5,"_40":41,"_39":246,"_147":25,"_37":247,"_13":248,"_33":34,"_35":249,"_24":48,"_151":-5,"_27":250},{"_42":236,"_32":237,"_30":238,"_145":-5,"_40":41,"_39":239,"_147":25,"_37":240,"_13":149,"_33":34,"_35":241,"_24":48,"_151":-5,"_27":242},{"_42":228,"_32":229,"_30":230,"_145":-5,"_40":41,"_39":231,"_147":25,"_37":232,"_13":204,"_33":233,"_35":234,"_24":48,"_151":-5,"_27":235},{"_42":221,"_32":222,"_30":223,"_145":-5,"_40":41,"_39":224,"_147":25,"_37":225,"_13":173,"_33":34,"_35":226,"_24":48,"_151":-5,"_27":227},{"_42":214,"_32":215,"_30":216,"_145":-5,"_40":41,"_39":217,"_147":25,"_37":218,"_13":173,"_33":34,"_35":219,"_24":48,"_151":-5,"_27":220},{"_42":207,"_32":208,"_30":209,"_145":-5,"_40":41,"_39":210,"_147":25,"_37":211,"_13":149,"_33":34,"_35":212,"_24":48,"_151":-5,"_27":213},{"_42":199,"_32":200,"_30":201,"_145":-5,"_40":41,"_39":202,"_147":25,"_37":203,"_13":204,"_33":34,"_35":205,"_24":48,"_151":-5,"_27":206},{"_42":191,"_32":192,"_30":57,"_145":-5,"_40":41,"_39":193,"_147":48,"_37":194,"_13":195,"_33":196,"_35":197,"_24":48,"_151":-5,"_27":198},{"_42":184,"_32":185,"_30":186,"_145":-5,"_40":41,"_39":187,"_147":25,"_37":188,"_13":149,"_33":34,"_35":189,"_24":48,"_151":-5,"_27":190},{"_42":176,"_32":177,"_30":178,"_145":-5,"_40":41,"_39":179,"_147":48,"_37":180,"_13":181,"_33":34,"_35":182,"_24":48,"_151":-5,"_27":183},{"_42":168,"_32":169,"_30":170,"_145":-5,"_40":41,"_39":171,"_147":48,"_37":172,"_13":173,"_33":34,"_35":174,"_24":48,"_151":-5,"_27":175},{"_42":161,"_32":162,"_30":163,"_145":-5,"_40":41,"_39":164,"_147":48,"_37":165,"_13":158,"_33":34,"_35":166,"_24":48,"_151":-5,"_27":167},{"_42":153,"_32":154,"_30":155,"_145":-5,"_40":41,"_39":156,"_147":48,"_37":157,"_13":158,"_33":34,"_35":159,"_24":48,"_151":-5,"_27":160},{"_42":142,"_32":143,"_30":144,"_145":-5,"_40":41,"_39":146,"_147":25,"_37":148,"_13":149,"_33":34,"_35":150,"_24":48,"_151":-5,"_27":152},"026cb22e-1a8f-4944-bd7c-acdbd1c0cc16","valutazione.ts","f4ec8122-abc7-11f1-b57b-1607ee4eb77e","parentId",51,"latest",["D",1788901092981],2,"/* =====================================================================\n * VALUTAZIONE RELATIVA, STORICA E CORRETTA PER LA CRESCITA\n * ---------------------------------------------------------------\n * Il DCF da solo è fragile: due decimali di WACC spostano il fair value\n * di decine di punti percentuali. Questi tre metodi non lo rendono più\n * preciso, lo rendono meno solo. Quando divergono molto, il Confidence\n * Score scende — ed è l'informazione più onesta che il sistema possa\n * dare su un titolo difficile da valutare.\n *\n * Nessuno di questi metodi proietta il futuro: guardano cosa il mercato\n * ha pagato in passato per questa azienda e cosa paga oggi per le sue\n * simili. Sono un contrappeso, non una conferma.\n * ===================================================================== */\n\nconst n = (x: any) => (typeof x === \"number\" && isFinite(x) ? x : null);\n\nexport function mediana(arr: any[]) {\n const v = arr.filter((x) => n(x) !== null).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\nfunction percentile(x: any, arr: any[]) {\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/* --------------------------- storica ------------------------------- */\n\n/**\n * Ricostruisce i multipli che il mercato ha pagato per questa azienda,\n * esercizio per esercizio, accoppiando il prezzo di fine anno fiscale\n * con l'utile e la cassa di quell'anno.\n *\n * @param serieMensile TIME_SERIES_MONTHLY_ADJUSTED grezzo di Alpha Vantage\n * @returns fair value implicito ai multipli mediani storici, più il\n * percentile in cui si colloca la valutazione di oggi\n */\nexport function valutazioneStorica(\n facts: any,\n metriche: any,\n serieMensile: any,\n anni = 10,\n) {\n const serie = serieMensile?.[\"Monthly Adjusted Time Series\"];\n if (!serie || !facts?.anni?.length) return null;\n\n const date = Object.keys(serie).sort().reverse();\n const prezzoVicino = (bersaglio: string) => {\n const d = date.find((x) => x <= bersaglio);\n if (!d) return null;\n const v = Number(serie[d]?.[\"5. adjusted close\"]);\n return isFinite(v) ? v : null;\n };\n\n const storia: any[] = [];\n for (let i = 0; i < Math.min(anni, facts.anni.length); i++) {\n const a = facts.anni[i];\n const prezzo = prezzoVicino(a.esercizio);\n const eps = n(a.utileNetto) !== null && n(a.azioni)\n ? a.utileNetto / a.azioni\n : null;\n const fcfAz = n(metriche.fcf[i]) !== null && n(a.azioni)\n ? metriche.fcf[i] / a.azioni\n : null;\n if (prezzo === null) continue;\n storia.push({\n esercizio: a.esercizio,\n pe: eps !== null && eps > 0 ? prezzo / eps : null,\n pfcf: fcfAz !== null && fcfAz > 0 ? prezzo / fcfAz : null,\n });\n }\n if (storia.length < 4) return null; // meno di quattro punti non fa una storia\n\n const peMediano = mediana(storia.map((x) => x.pe));\n const pfcfMediano = mediana(storia.map((x) => x.pfcf));\n\n const epsOggi = metriche.eps?.[0] ?? null;\n const fcfAzOggi = metriche.fcfPerAzione?.[0] ?? null;\n\n const daPe = peMediano !== null && n(epsOggi) !== null && epsOggi > 0\n ? peMediano * epsOggi\n : null;\n const daPfcf = pfcfMediano !== null && n(fcfAzOggi) !== null && fcfAzOggi > 0\n ? pfcfMediano * fcfAzOggi\n : null;\n\n const fairValue = mediana([daPe, daPfcf]);\n return fairValue === null ? null : {\n fairValue,\n peMediano,\n pfcfMediano,\n esercizi: storia.length,\n percentilePe: percentile(metriche.pe, storia.map((x) => x.pe)),\n // percentile alto = l'azienda tratta cara rispetto alla propria storia\n };\n}\n\n/* --------------------------- relativa ------------------------------ */\n\n/**\n * @param peers array di OVERVIEW grezzi dei comparabili\n * Confronta i multipli con la mediana del gruppo. Il gruppo va scelto\n * bene: un P/E di 30 non dice nulla in assoluto, dice molto se i\n * concorrenti stanno a 15.\n */\nexport function valutazioneRelativa(metriche: any, peers: any[]) {\n const validi = (peers ?? []).filter(Boolean);\n if (validi.length < 2) return null;\n\n const num = (o: any, k: string) => {\n const v = Number(o?.[k]);\n return isFinite(v) && v > 0 ? v : null;\n };\n\n const pe = validi.map((p) => num(p, \"PERatio\"));\n const evEbitda = validi.map((p) => num(p, \"EVToEBITDA\"));\n const peMediano = mediana(pe), evMediano = mediana(evEbitda);\n\n const epsOggi = metriche.eps?.[0] ?? null;\n const daPe = peMediano !== null && n(epsOggi) !== null && epsOggi > 0\n ? peMediano * epsOggi\n : null;\n\n // dal multiplo EV/EBITDA si torna al valore per azione togliendo il debito netto\n const daEv =\n evMediano !== null && n(metriche.ebitdaCorrente) !== null &&\n n(metriche.azioniCorrenti)\n ? (evMediano * metriche.ebitdaCorrente - (metriche.debitoNetto ?? 0)) /\n metriche.azioniCorrenti\n : null;\n\n const fairValue = mediana([daPe, daEv]);\n return fairValue === null ? null : {\n fairValue,\n peMediano,\n evMediano,\n comparabili: validi.map((p) => p?.Symbol).filter(Boolean),\n percentilePe: percentile(metriche.pe, pe),\n };\n}\n\n/* ------------------ corretta per la crescita ----------------------- */\n\n/**\n * Formula di Graham nella forma V = EPS x (8.5 + 2g).\n * È una scorciatoia degli anni Sessanta, non un modello: la tengo perché\n * ancora il valore alla crescita dimostrata invece che alle proiezioni,\n * e perché nel fair value composito pesa solo il 10%. Su aziende cicliche\n * o con utili vicini a zero non va usata, e infatti si astiene.\n */\nexport function valutazioneCrescita(metriche: any, crescitaAttesa: any) {\n const eps = metriche.eps?.[0] ?? null;\n const g = n(crescitaAttesa);\n if (n(eps) === null || eps <= 0 || g === null) return null;\n const gPerc = Math.max(0, Math.min(20, g * 100)); // oltre il 20% la formula esplode\n const multiplo = 8.5 + 2 * gPerc;\n return {\n fairValue: eps * multiplo,\n multiploImplicito: multiplo,\n crescitaUsata: gPerc / 100,\n };\n}\n\n/* --------------------------- comparabili --------------------------- */\n\nexport const PROMPT_PEERS = (ticker: string, nome: string, settore: string) =>\n `Elenca da 4 a 6 aziende quotate direttamente confrontabili con ${nome} (${ticker})${\n settore ? `, settore ${settore}` : \"\"\n }.\n\nCriteri: stesso modello di business e clientela simile, dimensione comparabile,\nquotate su borse USA con ticker valido. Non includere ${ticker}.\nNon includere conglomerati o holding se ${nome} è un operatore puro.\n\nRispondi SOLO con JSON, senza testo attorno e senza backtick:\n{ \"peers\": [\"TICK1\", \"TICK2\"], \"criterio\": \"max 20 parole sul perché questo gruppo\" }`;","label",[143],"1a6b987a-10d5-4d04-be50-2ceee440a6c9","titolo.ts","c047952a-abc6-11f1-af6d-1607ee4eb77e",59,["D",1788901488510],4,"/* =====================================================================\n * SCHEDA TITOLO — la pagina che rende leggibile il motore\n * ---------------------------------------------------------------\n * Il vincolo di progetto è il punto 9 dello spec: chi legge deve\n * distinguere a colpo d'occhio un dato di bilancio da una stima del\n * modello. Per questo ogni criterio porta una sigla di provenienza,\n * e le quattro sigle hanno colori diversi.\n * ===================================================================== */\n\nimport { bloccoNotizie } from \"./notizie.ts\";\n\nconst esc = (s: unknown) =>\n String(s ?? \"\")\n .replace(/&/g, \"&\").replace(//g, \">\");\n\nconst num = (\n x: any,\n d = 2,\n) => (x === null || x === undefined ? \"—\" : Number(x).toFixed(d));\nconst pct = (\n x: any,\n d = 1,\n) => (x === null || x === undefined ? \"—\" : (x * 100).toFixed(d) + \"%\");\n\nconst STRATI: Record = {\n FACT: { sigla: \"F\", titolo: \"Dato di bilancio pubblicato\" },\n DERIVED: { sigla: \"D\", titolo: \"Calcolato dal codice sui dati di bilancio\" },\n ESTIMATE: { sigla: \"S\", titolo: \"Stima: dipende da ipotesi di modello\" },\n JUDGMENT: {\n sigla: \"G\",\n titolo: \"Giudizio qualitativo dell'AI, con evidenza\",\n },\n};\n\nconst ETICHETTE: Record = {\n valuation: \"Valutazione\",\n businessQuality: \"Qualità del business\",\n growth: \"Crescita\",\n cashFlow: \"Cassa e allocazione del capitale\",\n financialStrength: \"Solidità finanziaria\",\n moat: \"Vantaggio competitivo\",\n management: \"Management\",\n risk: \"Rischi\",\n};\n\nconst ORDINE = [\n \"valuation\",\n \"businessQuality\",\n \"growth\",\n \"cashFlow\",\n \"financialStrength\",\n \"moat\",\n \"management\",\n \"risk\",\n];\n\nfunction barra(score: number | null) {\n if (score === null || score === undefined) return ``;\n const cls = score >= 70 ? \"alto\" : score >= 45 ? \"medio\" : \"basso\";\n return ``;\n}\n\nfunction criterio(c: any) {\n const st = STRATI[c.strato] ??\n { sigla: \"?\", titolo: \"provenienza non dichiarata\" };\n const val = c.score === null\n ? `${esc(c.nota ?? \"non disponibile\")}`\n : `${esc(c.valoreFormattato)}`;\n const soglie = c.soglie && c.score !== null\n ? `0 a ${esc(c.soglie.zeroPunti)} · 100 a ${\n esc(c.soglie.centoPunti)\n }`\n : \"\";\n\n return `

\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}",[154],"210d005b-b514-4294-bdfe-38472cda844a","smc.ts","2997d90e-ac99-11f1-bf3e-1607ee4eb77e",99,["D",1789024355161],"/* =====================================================================\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 // la zona del setup è quella nata dopo il MSS, non la più vicina\n const zonaSetup = mssValido\n ? consegna.zone.find((z) =>\n z.direzione === suffisso &&\n z.confermaIndice >= mssValido.barraIndice &&\n z.confermaIndice <=\n mssValido.barraIndice + PARAMETRI_SMC.finestraSweepMss\n ) ?? null\n : 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 zonaSetup,\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}",[162],"2f02b923-5d31-4e8c-b85a-68d7179257c6","radar.ts","03002efa-abc6-11f1-9b75-1607ee4eb77e",60,["D",1788901499568],3,"/* =====================================================================\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}",[169],"64d7fbb1-d590-42af-80a0-2ca3281c399e","operativo.ts","6a3c8784-ac99-11f1-94c6-1607ee4eb77e",110,["D",1789063795088],6,"/* =====================================================================\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 // Il minimo della sweep entra nello stop solo se è vicino alla zona.\n // Una sweep avvenuta molto prima non invalida un ingresso in zona: ciò\n // che lo invalida è la zona che cede. Ancorare lo stop a una sweep\n // lontana produce rischi di decine di ATR e R:R sempre inferiori a 1.\n maxDistanzaSweepAtr: 1.0, // [0.5, 1.0, 2.0]\n zonaMaxAtr: 1.5, // una zona più larga non è un ingresso preciso\n // Uno stop più stretto di questo sta dentro il rumore: viene preso da\n // oscillazioni che non hanno niente a che fare con la tesi, e produce\n // R:R apparenti altissimi che non sopravvivono al primo tick.\n rischioMinAtr: 0.30, // [0.2, 0.3, 0.5]\n rrSospetto: 15, // oltre, quasi sempre il rischio è mal misurato\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 target1PiuVicina: number | null; // per confrontare le regole di uscita\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 rischio: number | null = null,\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 // La pool più vicina è per costruzione la ricompensa minima possibile.\n // Se il rischio è noto si preferisce la prima che paghi almeno il\n // minimo richiesto, dichiarando quando non esiste.\n const sufficiente = rischio && rischio > 0\n ? candidati.find((l) =>\n Math.abs(l.prezzo - entry) / rischio >= PARAMETRI_OP.rrMinimo\n )\n : null;\n const t1 = sufficiente ?? candidati[0] ?? null;\n const esterna = candidati.find((l) => l.esterna && l !== t1) ?? null;\n return {\n t1,\n t2: esterna ?? candidati.find((l) => l !== t1) ?? null,\n disponibili: candidati.length,\n piuVicina: candidati[0] ?? null,\n scelta: sufficiente\n ? \"prima pool che paga il rischio\"\n : \"pool più vicina (nessuna paga il minimo)\",\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 zonaSpecifica: Zona | null = null,\n // Sovrascritture per la sensibilità: i due filtri geometrici sono i\n // parametri che oggi governano il sistema più di ogni altro, quindi\n // devono essere misurabili dall'esterno invece che fissi nel modulo.\n override: { zonaMaxAtr?: number; rischioMinAtr?: number } = {},\n): Setup | { errore: string } {\n const P = { ...PARAMETRI_OP, ...override };\n if (atrVal === null || atrVal <= 0) return { errore: \"ATR non disponibile\" };\n\n const prezzo = barre[i].c;\n\n // Se il chiamante conosce la zona che ha generato il setup, quella è\n // vincolante: scegliere \"la più vicina al prezzo\" fra tutte le zone\n // della serie significa costruire l'operazione su una zona che non\n // c'entra nulla con la sweep e il MSS che l'hanno prodotta.\n let z: { alto: number; basso: number; origine: string } | null;\n if (zonaSpecifica) {\n z = {\n alto: zonaSpecifica.alto,\n basso: zonaSpecifica.basso,\n origine: `${zonaSpecifica.tipo} del setup`,\n };\n // se un'altra zona concorde si sovrappone, l'intersezione è migliore\n for (const altra of zone) {\n if (\n altra === zonaSpecifica || altra.direzione !== zonaSpecifica.direzione\n ) continue;\n const x = intersezione(zonaSpecifica, altra);\n if (x) {\n z = {\n alto: x.alto,\n basso: x.basso,\n origine: `${zonaSpecifica.tipo} e ${altra.tipo} sovrapposti`,\n };\n break;\n }\n }\n } else {\n z = zonaIngresso(zone, direzione, prezzo);\n }\n if (!z) return { errore: \"nessuna zona di ingresso disponibile\" };\n\n const note: string[] = [];\n const buffer = P.bufferStopAtr * atrVal;\n\n // ingresso al bordo vicino: il primo punto toccato rientrando\n const entryRiferimento = direzione === \"LONG\" ? z.alto : z.basso;\n\n const altezzaZona = z.alto - z.basso;\n if (altezzaZona > P.zonaMaxAtr * atrVal) {\n return {\n errore: `ZONA_LARGA: ${\n (altezzaZona / atrVal).toFixed(2)\n } ATR, oltre il massimo di ${P.zonaMaxAtr}`,\n };\n }\n\n // Lo stop è ancorato alla ZONA. Il minimo della sweep lo estende solo\n // se cade entro la distanza ammessa, cioè se appartiene davvero allo\n // stesso movimento.\n let ancora = direzione === \"LONG\" ? z.basso : z.alto;\n if (direzione === \"LONG\" && sweepBasso !== null && sweepBasso < z.basso) {\n if (z.basso - sweepBasso <= P.maxDistanzaSweepAtr * atrVal) {\n ancora = sweepBasso;\n } else {note.push(\n `sweep a ${\n ((z.basso - sweepBasso) / atrVal).toFixed(1)\n } ATR dalla zona: esclusa dallo stop`,\n );}\n }\n if (direzione === \"SHORT\" && sweepAlto !== null && sweepAlto > z.alto) {\n if (sweepAlto - z.alto <= P.maxDistanzaSweepAtr * atrVal) {\n ancora = sweepAlto;\n } else {note.push(\n `sweep a ${\n ((sweepAlto - z.alto) / atrVal).toFixed(1)\n } ATR dalla zona: esclusa dallo stop`,\n );}\n }\n const stop = direzione === \"LONG\" ? ancora - buffer : ancora + buffer;\n\n const rischio = Math.abs(entryRiferimento - stop);\n if (rischio <= 0) return { errore: \"rischio nullo: zona e stop coincidono\" };\n if (rischio < P.rischioMinAtr * atrVal) {\n return {\n errore: `STOP_STRETTO: ${\n (rischio / atrVal).toFixed(2)\n } ATR, sotto il minimo di ${P.rischioMinAtr}`,\n };\n }\n\n const { t1, t2, disponibili, piuVicina } = bersagli(\n livelli,\n direzione,\n entryRiferimento,\n i,\n atrVal,\n rischio,\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 target1PiuVicina: piuVicina?.prezzo ?? 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: rr(guadagno, rischio) > PARAMETRI_OP.rrSospetto\n ? [\n ...note,\n `R:R ${\n rr(guadagno, rischio)\n } implausibile: verificare la misura del rischio`,\n ]\n : note,\n };\n}\n\nconst rr = (g: number | null, r: number) => (g ? +(g / r).toFixed(2) : 0);\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}",[177],"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}",[185],"e5c28e95-a301-4884-9f31-c47d11ee0559","main.ts",112,["D",1789071906578],24,"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 * TWELVEDATA_KEY (twelvedata.com, per il motore prezzi)\n * GEMINI_API_KEY (aistudio.google.com, senza carta)\n * 3. Una modifica qualsiasi al codice forza il redeploy: senza, la\n * chiave appena salvata non raggiunge gli isolate già avviati.\n *\n * ROTTE\n * GET / home\n * GET /radar watchlist ordinata per Investment Score\n * GET /notizie notizie sui titoli seguiti, con sentiment\n * GET /smc?symbol=AAPL&tf=1h analisi SMC su dati reali\n * GET /smc/imbuto?symbol=AAPL dove muoiono i setup, su dati reali\n * GET /smc/campione?uscitaR=2 campione multi-titolo, a lotti\n *\n * CAMPIONE A LOTTI: i parametri si passano UNA VOLTA sola, al primo\n * lancio. Vengono memorizzati, e le chiamate successive senza parametri\n * riprendono la stessa configurazione fino a completarla. Per passare a\n * una configurazione diversa basta rilanciare con i nuovi parametri.\n * GET /titolo?symbol=AAPL scheda completa, pagina da leggere\n * GET /brief quadro mattutino, pagina da leggere\n * GET /brief.json lo stesso in JSON\n * GET /macro quadro macro: tassi, curva, inflazione, petrolio\n * GET /analizza?symbol=AAPL analisi completa: due punteggi e criteri\n * GET /facts?symbol=AAPL bilanci normalizzati + copertura\n * GET /quote?symbol=AAPL solo il prezzo, cache breve\n * GET /budget quante richieste restano oggi\n *\n * Il piano gratuito Alpha Vantage dà 25 richieste al giorno e una\n * scheda completa ne consuma 5. Senza un contatore le bruci in dieci\n * minuti di prove e passi il resto della giornata a leggere errori\n * che sembrano bug del codice. Per questo il budget è qui dentro.\n * ===================================================================== */\n\n// Entrambe le righe servono. Non modificarne nessuna: il file facts.ts\n// sta nello stesso val, quindi l'import è relativo e non serve username.\nimport { sqlite } from \"https://esm.town/v/std/sqlite\";\nimport {\n controllaRisposta,\n copertura,\n normalizzaAlphaVantage,\n} from \"./facts.ts\";\nimport { valuta } from \"./engine.js\";\nimport { generaBrief, 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\";\nimport { BUDGET_CREDITI, PAUSA_TD_MS, serie as serieTD } from \"./prezzi.ts\";\nimport { analizzaSMC } from \"./smc.ts\";\nimport {\n confrontaUscite,\n distribuzioneMfe,\n imbuto,\n metriche,\n metricheConRegola,\n segmenti,\n sensibilitaCosti,\n simula,\n walkForward,\n} from \"./backtest.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 campione (\n chiave TEXT PRIMARY KEY, ticker TEXT NOT NULL, tf TEXT NOT NULL,\n payload TEXT NOT NULL, t INTEGER NOT NULL)`);\n await sqlite.execute(`CREATE TABLE IF NOT EXISTS consumo_td (\n giorno TEXT PRIMARY KEY, crediti 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/* ------------------------------- SMC ------------------------------ */\n\nasync function creditiUsatiTD() {\n const r = await sqlite.execute({\n sql: \"SELECT crediti FROM consumo_td WHERE giorno = ?\",\n args: [oggi()],\n });\n return r.rows.length ? Number(r.rows[0][0]) : 0;\n}\nasync function segnaCreditoTD() {\n await sqlite.execute({\n sql: `INSERT INTO consumo_td (giorno, crediti) VALUES (?, 1)\n ON CONFLICT(giorno) DO UPDATE SET crediti = crediti + 1`,\n args: [oggi()],\n });\n}\n\n/** Dipendenze per prezzi.ts, che è scritto host-agnostico apposta. */\nconst depsTD = {\n apiKey: Deno.env.get(\"TWELVEDATA_KEY\"),\n fetch,\n leggiCache,\n scriviCache,\n creditiUsati: creditiUsatiTD,\n segnaCredito: segnaCreditoTD,\n pausa,\n};\n\nasync function rottaSMC(symbol: string, url: URL) {\n const tf = url.searchParams.get(\"tf\") ?? \"1h\";\n const quante = Math.min(5000, Number(url.searchParams.get(\"barre\")) || 800);\n const { barre, origine, daCache } = await serieTD(symbol, tf, depsTD, quante);\n\n if (barre.length < 100) {\n return {\n errore:\n `solo ${barre.length} barre: servono almeno 100 per l'ATR e la struttura`,\n };\n }\n\n const r = analizzaSMC(barre, symbol, tf);\n const snello = (d: any) => ({\n punteggio: d.punteggio,\n stato: d.stato,\n gate: d.gate.map((g: any) => ({\n nome: g.nome,\n superato: g.superato,\n dettaglio: g.dettaglio,\n })),\n tuttiSuperati: d.tuttiSuperati,\n contributi: d.contributi,\n setup: d.setup,\n setupNota: d.setupNota,\n zoneUsabili: d.zoneUsabili,\n ultimeTransizioni: d.transizioni.slice(-5),\n });\n\n return {\n ticker: symbol,\n timeframe: tf,\n asOf: r.asOf,\n barre: barre.length,\n origineSerie: origine,\n daCache,\n bias: r.bias,\n posizione: r.posizione\n ? {\n zona: r.posizione.zona,\n percentuale: r.posizione.percentuale,\n equilibrio: r.posizione.equilibrio,\n }\n : null,\n ote: r.ote\n ? { basso: r.ote.basso, alto: r.ote.alto, dentro: r.ote.dentro }\n : null,\n long: snello(r.long),\n short: snello(r.short),\n conteggioEventi: r.eventi.reduce((a: any, e: any) => {\n a[e.tipo] = (a[e.tipo] ?? 0) + 1;\n return a;\n }, {}),\n note: r.note,\n crediti: { usatiOggi: await creditiUsatiTD(), budget: BUDGET_CREDITI },\n };\n}\n\n/**\n * L'imbuto su dati reali. È la domanda aperta della Fase 7: la sequenza\n * A+ è troppo restrittiva, o lo erano i dati sintetici?\n */\nasync function rottaImbuto(symbol: string, url: URL) {\n const tf = url.searchParams.get(\"tf\") ?? \"1h\";\n const quante = Math.min(5000, Number(url.searchParams.get(\"barre\")) || 2000);\n const { barre, origine } = await serieTD(symbol, tf, depsTD, quante);\n if (barre.length < 200) {\n return {\n errore:\n `solo ${barre.length} barre: troppo poche per un imbuto significativo`,\n };\n }\n\n const finestre = (url.searchParams.get(\"finestre\") ?? \"10,20,30\")\n .split(\",\").map(Number).filter((x) => x > 0);\n\n const confronto = finestre.map((w) => {\n const im = imbuto(barre, { finestraSweepMss: w });\n return {\n finestra: w,\n stadi: im.stadi,\n collo: im.collo,\n operazioni: im.operazioni,\n };\n });\n\n const migliore = confronto.reduce((\n a,\n b,\n ) => (b.operazioni > a.operazioni ? b : a));\n const r = simula(barre, { finestraSweepMss: migliore.finestra });\n\n return {\n ticker: symbol,\n timeframe: tf,\n barre: barre.length,\n origineSerie: origine,\n confronto,\n conFinestra: migliore.finestra,\n metriche: metriche(r.operazioni, barre.length),\n walkForward: r.operazioni.length >= 10\n ? walkForward(barre, { finestraSweepMss: migliore.finestra })\n : {\n nota:\n `solo ${r.operazioni.length} operazioni: il walk-forward non direbbe nulla di affidabile`,\n },\n operazioni: r.operazioni.slice(0, 20),\n crediti: { usatiOggi: await creditiUsatiTD(), budget: BUDGET_CREDITI },\n };\n}\n\n/**\n * Imbuto aggregato su più titoli e timeframe.\n *\n * Con una operazione ogni 2000 barre su un solo asset non si valida\n * nulla. Prima di toccare un parametro serve un campione: 20 titoli per\n * 3 timeframe costano 60 crediti su 800, e portano il numero di\n * operazioni in un intervallo dove le metriche cominciano a dire\n * qualcosa.\n *\n * I tre segmenti si dividono DENTRO ogni asset e poi si aggregano:\n * mettere insieme titoli diversi in un'unica serie temporale\n * distruggerebbe l'ordine cronologico e renderebbe il walk-forward\n * una finzione.\n */\nasync function rottaCampione(url: URL) {\n const tickers = (url.searchParams.get(\"tickers\") ??\n \"AAPL,MSFT,NVDA,AMZN,GOOGL,META,TSLA,JPM,XOM,WMT\")\n .split(\",\").map((x) => x.trim().toUpperCase()).filter(Boolean).slice(0, 25);\n const timeframes = (url.searchParams.get(\"tf\") ?? \"1h,4h,1d\")\n .split(\",\").map((x) => x.trim()).filter(Boolean).slice(0, 4);\n const quante = Math.min(5000, Number(url.searchParams.get(\"barre\")) || 2000);\n\n // Un lavoro a lotti che si biforca quando ometti un parametro è una\n // trappola: il secondo lotto finisce su una configurazione nuova e\n // quella in corso resta ferma per sempre. Quindi la configurazione si\n // memorizza al primo lancio e i lotti successivi la riprendono da soli.\n const CHIAVI = [\"finestra\", \"uscitaR\", \"zonaMax\", \"rischioMin\"];\n const espliciti = CHIAVI.filter((k) => url.searchParams.has(k));\n const salvata = espliciti.length\n ? null\n : await leggiCache(\"campione:config\", 30 * GIORNO);\n\n const finestra = espliciti.length\n ? (Number(url.searchParams.get(\"finestra\")) || 30)\n : (salvata?.finestra ?? 30);\n const uscitaR = espliciti.length\n ? (url.searchParams.get(\"uscitaR\")\n ? Number(url.searchParams.get(\"uscitaR\"))\n : null)\n : (salvata?.uscitaR ?? null);\n const zonaMax = espliciti.length\n ? (Number(url.searchParams.get(\"zonaMax\")) || 1.5)\n : (salvata?.zonaMax ?? 1.5);\n const rischioMin = espliciti.length\n ? (Number(url.searchParams.get(\"rischioMin\")) || 0.30)\n : (salvata?.rischioMin ?? 0.30);\n\n if (espliciti.length) {\n await scriviCache(\"campione:config\", {\n finestra,\n uscitaR,\n zonaMax,\n rischioMin,\n });\n }\n\n const config = `${finestra}|${uscitaR ?? \"pool\"}|z${zonaMax}|r${rischioMin}`;\n const lotto = Math.min(8, Number(url.searchParams.get(\"lotto\")) || 4);\n\n if (url.searchParams.get(\"reset\") === \"true\") {\n await sqlite.execute(\"DELETE FROM campione\");\n }\n\n const fatte = await sqlite.execute(\"SELECT chiave FROM campione\");\n const gia = new Set(fatte.rows.map((r: any) => String(r[0])));\n // Fotografia dello stato PRIMA di lavorare: se il lavoro non avanza,\n // la causa sta qui e va vista, non dedotta.\n const primaDi = {\n righeInTabella: fatte.rows.length,\n esempioChiavi: [...gia].slice(0, 3),\n };\n\n // Elenco completo del lavoro, poi solo il primo lotto non ancora fatto.\n const compiti: [string, string][] = [];\n for (const t of tickers) {\n for (const tf of timeframes) {\n if (!gia.has(`${t}|${tf}|${finestra}|${uscitaR ?? \"pool\"}`)) {\n compiti.push([t, tf]);\n }\n }\n }\n\n const errori: string[] = [];\n let elaborate = 0;\n\n for (const [t, tf] of compiti.slice(0, lotto)) {\n try {\n const { barre, daCache } = await serieTD(t, tf, depsTD, quante);\n if (barre.length < 300) {\n errori.push(`${t} ${tf}: solo ${barre.length} barre`);\n continue;\n }\n\n const opz = {\n finestraSweepMss: finestra,\n uscitaFissaR: uscitaR,\n zonaMaxAtr: zonaMax,\n rischioMinAtr: rischioMin,\n };\n const im = imbuto(barre, opz);\n const s = segmenti(barre);\n const perSeg: any = {};\n for (const k of [\"inSample\", \"outOfSample\", \"walkForward\"] as const) {\n const b = (s as any)[k];\n perSeg[k] = b.length < 200\n ? []\n : simula(b, opz).operazioni.filter((o: any) => o.r !== null);\n }\n\n await sqlite.execute({\n sql:\n `INSERT INTO campione (chiave, ticker, tf, payload, t) VALUES (?, ?, ?, ?, ?)\n ON CONFLICT(chiave) DO UPDATE SET payload = excluded.payload, t = excluded.t`,\n args: [\n `${t}|${tf}|${config}`,\n t,\n tf,\n JSON.stringify({\n barre: barre.length,\n stadi: im.stadi,\n collo: im.collo,\n operazioni: im.operazioni,\n perSeg,\n }),\n Date.now(),\n ],\n });\n elaborate++;\n // La pausa serve solo se abbiamo davvero scaricato: dalla cache\n // non consumiamo crediti e non c'è limite al minuto da rispettare.\n if (!daCache) await pausa(PAUSA_TD_MS);\n } catch (e) {\n errori.push(\n `${t} ${tf}: ${String((e as Error)?.message ?? e).slice(0, 70)}`,\n );\n }\n }\n\n // Rilettura di controllo: quante righe risultano scritte adesso.\n const dopo = await sqlite.execute(\"SELECT chiave FROM campione\");\n const rimaste = Math.max(0, compiti.length - lotto);\n\n // Solo le righe calcolate con QUESTA finestra e QUESTA regola d'uscita.\n // Rileggere l'intera tabella mescolava campioni prodotti con parametri\n // diversi: le operazioni si sommavano fra loro e l'aggregato non\n // corrispondeva a nessuna configurazione realmente eseguita.\n const suffisso = `|${config}`;\n const salvate = await sqlite.execute({\n sql: \"SELECT ticker, tf, payload FROM campione WHERE chiave LIKE ?\",\n args: [`%${suffisso}`],\n });\n const serie = salvate.rows.map((r: any) => ({\n ticker: String(r[0]),\n tf: String(r[1]),\n ...JSON.parse(String(r[2])),\n }));\n\n if (!serie.length) {\n return {\n stato: \"vuoto\",\n elaborate,\n rimaste,\n errori,\n nota: \"nessuna serie completata: rilancia /smc/campione\",\n };\n }\n\n const stadiTot: Record = {};\n let barreTot = 0;\n const perSegmento: any = { inSample: [], outOfSample: [], walkForward: [] };\n for (const x of serie) {\n barreTot += x.barre;\n for (const st of x.stadi) {\n if (!stadiTot[st.stadio]) stadiTot[st.stadio] = { entrati: 0, persi: 0 };\n stadiTot[st.stadio].entrati += st.entrati;\n stadiTot[st.stadio].persi += st.persi;\n }\n for (const k of [\"inSample\", \"outOfSample\", \"walkForward\"]) {\n perSegmento[k].push(...(x.perSeg?.[k] ?? []));\n }\n }\n\n const tutte = [\n ...perSegmento.inSample,\n ...perSegmento.outOfSample,\n ...perSegmento.walkForward,\n ];\n // La regola di uscita è ora un parametro: i segmenti vanno confrontati\n // con la regola che si vuole adottare, non con quella che è fallita.\n const regola = url.searchParams.get(\"uscita\") ?? \"fisso_2R\";\n const e = (\n v: any,\n ) => (typeof v?.expectancyR === \"number\" ? v.expectancyR : null);\n const mIn = metricheConRegola(perSegmento.inSample, regola, barreTot * 0.6);\n const mOut = metricheConRegola(\n perSegmento.outOfSample,\n regola,\n barreTot * 0.2,\n );\n const mWf = metricheConRegola(\n perSegmento.walkForward,\n regola,\n barreTot * 0.2,\n );\n const tre = [e(mIn), e(mOut), e(mWf)];\n\n return {\n stato: rimaste > 0 ? \"parziale\" : \"completo\",\n progresso: `${serie.length} serie fatte, ${rimaste} da fare` +\n (rimaste > 0 ? \" — rilancia /smc/campione per il lotto successivo\" : \"\"),\n elaborateOra: elaborate,\n diagnostica: {\n ...primaDi,\n righeDopo: dopo.rows.length,\n scritteInQuestoLotto: dopo.rows.length - primaDi.righeInTabella,\n chiaveAttesa: `||${config}`,\n filtroRilettura: `%|${config}`,\n compitiRimasti: compiti.length,\n nota: elaborate > 0 && dopo.rows.length === primaDi.righeInTabella\n ? \"elaborate ma non scritte: l'INSERT non persiste\"\n : primaDi.righeInTabella > 0 &&\n compiti.length === tickers.length * timeframes.length\n ? \"righe presenti ma nessuna riconosciuta: le chiavi non corrispondono\"\n : \"coerente\",\n },\n campione: {\n serie: serie.length,\n barreTotali: barreTot,\n finestraUsata: finestra,\n uscita: uscitaR\n ? `multiplo fisso ${uscitaR}R (gate R:R disattivato)`\n : \"pool di liquidità\",\n zonaMaxAtr: zonaMax,\n rischioMinAtr: rischioMin,\n parametriDa: espliciti.length ? \"URL\" : \"configurazione memorizzata\",\n config,\n },\n imbutoAggregato: Object.entries(stadiTot).map(([stadio, v]) => ({\n stadio,\n entrati: v.entrati,\n persi: v.persi,\n tassoScarto: v.entrati ? +(v.persi / v.entrati).toFixed(3) : null,\n })),\n operazioniTotali: tutte.length,\n metricheComplessive: metriche(tutte, barreTot),\n // Le due analisi che separano l'ingresso dall'uscita.\n confrontoUscite: confrontaUscite(tutte),\n escursioneFavorevole: distribuzioneMfe(tutte),\n regolaUscitaValutata: regola,\n perSegmento: { inSample: mIn, outOfSample: mOut, walkForward: mWf },\n costi: sensibilitaCosti(tutte, regola),\n verdetto: rimaste > 0\n ? \"campione incompleto: nessuna conclusione\"\n : tutte.length < 30\n ? `solo ${tutte.length} operazioni: nessuna conclusione statistica è lecita`\n : tre.every((x) => typeof x === \"number\" && x > 0)\n ? `positivo su tutti e tre i segmenti con ${regola}, ma su ${tutte.length} operazioni: indizio, non prova`\n : `non positivo in modo consistente con ${regola}`,\n perSerie: serie.map((x) => ({\n ticker: x.ticker,\n tf: x.tf,\n barre: x.barre,\n operazioni: x.operazioni,\n collo: x.collo,\n }))\n .sort((a, b) => b.operazioni - a.operazioni),\n errori,\n crediti: { usatiOggi: await creditiUsatiTD(), budget: BUDGET_CREDITI },\n };\n}\n\n/**\n * Confronta tutte le configurazioni già costruite. Non ricalcola nulla:\n * legge la tabella campione e raggruppa per chiave.\n *\n * La regola resta quella del punto 31: una configurazione si adotta solo\n * se batte l'attuale su TUTTI E TRE i segmenti. Vincere in-sample e\n * perdere fuori è il comportamento normale di un parametro sovraadattato,\n * non un caso sfortunato.\n */\nasync function rottaConfronto(url: URL) {\n const regola = url.searchParams.get(\"uscita\") ?? \"fisso_2R\";\n const righe = await sqlite.execute(\"SELECT chiave, payload FROM campione\");\n if (!righe.rows.length) return { nota: \"nessun campione costruito\" };\n\n const gruppi = new Map();\n for (const r of righe.rows) {\n const chiave = String(r[0]);\n const config = chiave.split(\"|\").slice(2).join(\"|\"); // toglie ticker e tf\n if (!gruppi.has(config)) gruppi.set(config, []);\n gruppi.get(config)!.push(JSON.parse(String(r[1])));\n }\n\n const esiti = [...gruppi.entries()].map(([config, serie]) => {\n const seg: any = { inSample: [], outOfSample: [], walkForward: [] };\n let barreTot = 0, serieComplete = serie.length;\n for (const x of serie) {\n barreTot += x.barre;\n for (const k of Object.keys(seg)) seg[k].push(...(x.perSeg?.[k] ?? []));\n }\n const m = (k: string, q: number) =>\n metricheConRegola(seg[k], regola, barreTot * q);\n const mIn = m(\"inSample\", 0.6),\n mOut = m(\"outOfSample\", 0.2),\n mWf = m(\"walkForward\", 0.2);\n const tot = [...seg.inSample, ...seg.outOfSample, ...seg.walkForward];\n const e = (\n v: any,\n ) => (typeof v?.expectancyR === \"number\" ? v.expectancyR : null);\n const tre = [e(mIn), e(mOut), e(mWf)];\n const compl = metricheConRegola(tot, regola, barreTot);\n\n // errore standard: con uscita a kR ogni esito vale -1 o +k\n const k = Number(regola.match(/fisso_(\\d+)R/)?.[1] ?? 2);\n const p = (compl as any).winRate ?? 0;\n const sd = Math.sqrt(p * (1 - p)) * (k + 1);\n const es = tot.length ? sd / Math.sqrt(tot.length) : null;\n\n return {\n config,\n serie: serieComplete,\n operazioni: tot.length,\n winRate: (compl as any).winRate ?? null,\n expectancy: (compl as any).expectancyR ?? null,\n erroreStandard: es ? +es.toFixed(3) : null,\n deviazioniDaZero: es && es > 0\n ? +(((compl as any).expectancyR ?? 0) / es).toFixed(2)\n : null,\n perSegmento: {\n inSample: e(mIn),\n outOfSample: e(mOut),\n walkForward: e(mWf),\n },\n operazioniPerSegmento: [\n seg.inSample.length,\n seg.outOfSample.length,\n seg.walkForward.length,\n ],\n positivoOvunque: tre.every((x) => typeof x === \"number\" && x > 0),\n };\n }).sort((a, b) => (b.expectancy ?? -9) - (a.expectancy ?? -9));\n\n const robuste = esiti.filter((x) => x.positivoOvunque && x.operazioni >= 30);\n return {\n regolaValutata: regola,\n configurazioni: esiti,\n lettura: robuste.length === 0\n ? \"nessuna configurazione è positiva su tutti e tre i segmenti con almeno 30 operazioni\"\n : `${robuste.length} configurazioni positive ovunque; la migliore per aspettativa è ${\n robuste[0].config\n }`,\n avvertenza:\n \"confrontare più configurazioni sullo stesso dataset aumenta la probabilità \" +\n \"che la migliore lo sia per caso: con N configurazioni, la soglia di significatività \" +\n \"va alzata di conseguenza.\",\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 \"/smc\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n return json(await rottaSMC(symbol, url));\n }\n case \"/smc/confronto\":\n return json(await rottaConfronto(url));\n case \"/smc/campione\":\n return json(await rottaCampione(url));\n case \"/smc/imbuto\": {\n if (!symbol) return json({ errore: \"manca il parametro symbol\" }, 400);\n return json(await rottaImbuto(symbol, url));\n }\n case \"/crediti\":\n return json({\n alphaVantage: {\n usati: await usateOggi(),\n budget: BUDGET_GIORNALIERO,\n },\n twelveData: { usati: await creditiUsatiTD(), budget: BUDGET_CREDITI },\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 \"/smc?symbol=\",\n \"/smc/imbuto?symbol=\",\n \"/smc/campione\",\n \"/smc/confronto\",\n \"/crediti\",\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}",[192],"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}",[200],"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}",[208],"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}",[215],"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}",[222],"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}",[229],"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};",[237],"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}",[244],"c60ad465-cf16-4a54-9c5e-9c08228ac2fd","backtest.ts","1b3d0ebe-ac9a-11f1-881f-1607ee4eb77e",109,["D",1789063784138],"/* =====================================================================\n * BACKTEST — Fase 7\n * ---------------------------------------------------------------\n * Quattro convenzioni dichiarate, perché ognuna sposta i risultati e\n * nasconderle renderebbe i numeri incomparabili.\n *\n * 1. INTRABAR. Da OHLC non si sa se prima è stato toccato lo stop o il\n * target quando entrambi cadono nella stessa barra. Qui si assume\n * SEMPRE lo stop per primo. È la convenzione pessimistica: chi\n * assume il target ottiene risultati migliori che non esistono.\n *\n * 2. INGRESSO. Al bordo vicino della zona, come in Fase 6.\n *\n * 3. NESSUN COSTO. Spread, commissioni e slippage non sono simulati.\n * I risultati vanno quindi letti come limite superiore, e un sistema\n * con expectancy di 0.1R non sopravvive ai costi reali.\n *\n * 4. UNA POSIZIONE PER VOLTA e per direzione: setup sovrapposti\n * verrebbero contati più volte gonfiando la frequenza.\n *\n * E una regola metodologica, dal punto 31 della specifica: un parametro\n * si cambia solo se migliora su TUTTI E TRE i segmenti. Un parametro\n * che funziona solo in-sample non è un parametro, è una coincidenza.\n * ===================================================================== */\n\nimport type { Barra } from \"./prezzi.ts\";\nimport { atr } from \"./prezzi.ts\";\nimport { analizzaStruttura, bias, PARAMETRI, trovaSwing } from \"./struttura.ts\";\nimport { analizzaLiquidita, PARAMETRI_LIQ } from \"./liquidita.ts\";\nimport { analizzaConsegna, PARAMETRI_ZONE, statoZona } from \"./consegna.ts\";\nimport { PARAMETRI_SMC } from \"./smc.ts\";\nimport { costruisciSetup, PARAMETRI_OP, valutaSetup } from \"./operativo.ts\";\nimport type { Direzione } from \"./smc.ts\";\n\nexport type Operazione = {\n direzione: Direzione;\n sweepIndice: number;\n mssIndice: number;\n zonaIndice: number;\n entrataIndice: number;\n entrataPrezzo: number;\n stop: number;\n target1: number | null;\n target2: number | null;\n esito: \"TARGET1\" | \"TARGET2\" | \"STOP\" | \"APERTA\";\n uscitaIndice: number | null;\n uscitaPrezzo: number | null;\n r: number | null;\n mae: number;\n mfe: number;\n durata: number | null;\n rrAtteso: number | null;\n // Stesso ingresso, regole di uscita diverse. Serve a distinguere un\n // ingresso cattivo da un'uscita mal scelta: finora erano confusi in\n // un unico numero, e un tasso di successo nullo non diceva quale dei\n // due fosse rotto.\n uscite?: Record<\n string,\n { esito: string; r: number | null; barre: number | null }\n >;\n};\n\nexport const REGOLE_USCITA = {\n pool_vicina: null as null, // la pool opposta più vicina\n pool_scelta: null as null, // quella scelta dal motore\n fisso_1R: 1,\n fisso_2R: 2,\n fisso_3R: 3,\n fisso_5R: 5,\n};\n\n/* --------------------------- simulazione --------------------------- */\n\nexport function simula(\n barre: Barra[],\n opzioni: {\n scadenzaBarre?: number;\n finestraSweepMss?: number;\n // Multiplo fisso di R come bersaglio. Quando è impostato, il gate\n // sul rapporto rischio/rendimento diventa vacuo — il rapporto è\n // fissato per costruzione — quindi va disattivato, altrimenti\n // filtriamo i setup con un criterio che non useremo per uscire.\n uscitaFissaR?: number | null;\n zonaMaxAtr?: number;\n rischioMinAtr?: number;\n } = {},\n) {\n const scadenza = opzioni.scadenzaBarre ?? 60;\n // Esplicita invece che letta dal modulo: i parametri vanno passati,\n // altrimenti una prova di sensibilità muta una copia e misura l'altra.\n const finestra = opzioni.finestraSweepMss ?? PARAMETRI_SMC.finestraSweepMss;\n const a = atr(barre, PARAMETRI.atrPeriodo);\n const swings = trovaSwing(barre);\n const struttura = analizzaStruttura(barre, \"BT\", \"sim\");\n const liquidita = analizzaLiquidita(barre, swings, a, \"BT\", \"sim\");\n const consegna = analizzaConsegna(barre, a, struttura.eventi, \"BT\", \"sim\");\n const eventi = [...struttura.eventi, ...liquidita.eventi, ...consegna.eventi];\n\n const operazioni: Operazione[] = [];\n const scartate: { motivo: string; barra: number }[] = [];\n\n for (const direzione of [\"LONG\", \"SHORT\"] as Direzione[]) {\n const suf = direzione === \"LONG\" ? \"BULL\" : \"BEAR\";\n const sweeps = eventi.filter((e) => e.tipo === `SWEEP_${suf}`);\n const mssTutti = eventi.filter((e) => e.tipo === `MSS_${suf}`);\n const zone = consegna.zone.filter((z) => z.direzione === suf);\n let liberaDa = -1; // una posizione per volta e per direzione\n\n for (const s of sweeps) {\n if (s.barraIndice <= liberaDa) continue;\n\n const m = mssTutti.find((x) =>\n x.barraIndice >= s.barraIndice &&\n x.barraIndice - s.barraIndice <= finestra\n );\n if (!m) {\n scartate.push({\n motivo: \"nessun MSS entro la finestra\",\n barra: s.barraIndice,\n });\n continue;\n }\n\n const z = zone.find((x) =>\n x.confermaIndice >= m.barraIndice &&\n x.confermaIndice <= m.barraIndice + finestra\n );\n if (!z) {\n scartate.push({\n motivo: \"nessuna zona dopo il MSS\",\n barra: m.barraIndice,\n });\n continue;\n }\n\n // primo rientro nella zona dopo esserne uscito\n let uscito = false, entrata = -1;\n for (\n let i = z.confermaIndice + 1;\n i < Math.min(barre.length, z.confermaIndice + scadenza);\n i++\n ) {\n const dentro = barre[i].l <= z.alto && barre[i].h >= z.basso;\n const oltre = direzione === \"LONG\"\n ? barre[i].c < z.basso\n : barre[i].c > z.alto;\n if (oltre) break;\n if (!dentro) {\n uscito = true;\n continue;\n }\n if (uscito && dentro) {\n entrata = i;\n break;\n }\n }\n if (entrata < 0) {\n scartate.push({\n motivo: \"nessun rientro in zona\",\n barra: z.confermaIndice,\n });\n continue;\n }\n\n // gate al momento dell'ingresso, non a posteriori\n const atteso = direzione === \"LONG\" ? \"BULLISH\" : \"BEARISH\";\n if (bias(eventi, barre[entrata].t).bias !== atteso) {\n scartate.push({\n motivo: \"bias non concorde all'ingresso\",\n barra: entrata,\n });\n continue;\n }\n\n const setup = costruisciSetup(\n direzione,\n barre,\n entrata,\n a[entrata],\n consegna.zone,\n liquidita.livelli,\n barre[s.barraIndice].l,\n barre[s.barraIndice].h,\n z,\n {\n zonaMaxAtr: opzioni.zonaMaxAtr,\n rischioMinAtr: opzioni.rischioMinAtr,\n },\n );\n if (\"errore\" in setup) {\n // Il motivo va ridotto a una categoria stabile: se contiene il\n // valore misurato, ogni setup produce un motivo diverso e il\n // filtro sparisce dal conteggio anche quando decide quasi tutto.\n const cat = setup.errore.startsWith(\"ZONA_LARGA\")\n ? \"zona troppo larga\"\n : setup.errore.startsWith(\"STOP_STRETTO\")\n ? \"stop dentro il rumore\"\n : setup.errore;\n scartate.push({ motivo: cat, barra: entrata });\n continue;\n }\n const giudizio = valutaSetup(setup);\n if (!opzioni.uscitaFissaR && !giudizio.ammesso) {\n scartate.push({ motivo: giudizio.motivo, barra: entrata });\n continue;\n }\n\n const op = eseguí(\n barre,\n entrata,\n setup,\n direzione,\n scadenza,\n opzioni.uscitaFissaR ?? null,\n );\n op.sweepIndice = s.barraIndice;\n op.mssIndice = m.barraIndice;\n op.zonaIndice = z.confermaIndice;\n operazioni.push(op);\n liberaDa = op.uscitaIndice ?? entrata + scadenza;\n }\n }\n\n operazioni.sort((x, y) => x.entrataIndice - y.entrataIndice);\n return { operazioni, scartate, eventi, barre: barre.length };\n}\n\n/** Percorre le barre successive all'ingresso. Stop prima del target, sempre. */\nfunction eseguí(\n barre: Barra[],\n entrata: number,\n s: any,\n direzione: Direzione,\n scadenza: number,\n uscitaFissaR: number | null = null,\n): Operazione {\n const long = direzione === \"LONG\";\n const prezzo = s.entryRiferimento,\n stop = s.stop,\n rischio = Math.abs(prezzo - stop);\n let mae = 0, mfe = 0;\n\n const base: Operazione = {\n direzione,\n sweepIndice: -1,\n mssIndice: -1,\n zonaIndice: -1,\n entrataIndice: entrata,\n entrataPrezzo: prezzo,\n stop,\n target1: s.target1,\n target2: s.target2,\n esito: \"APERTA\",\n uscitaIndice: null,\n uscitaPrezzo: null,\n r: null,\n mae: 0,\n mfe: 0,\n durata: null,\n rrAtteso: s.rr,\n };\n\n // Una sola passata in avanti, tutte le regole di uscita valutate\n // insieme sugli stessi dati.\n const uscite: Record<\n string,\n { esito: string; r: number | null; barre: number | null }\n > = {};\n const multipli: Record = {\n fisso_1R: 1,\n fisso_2R: 2,\n fisso_3R: 3,\n fisso_5R: 5,\n };\n const poolVicina = s.target1PiuVicina ?? s.target1;\n let esitoPrincipale: Operazione | null = null;\n\n const chiudi = (nome: string, esito: string, r: number | null, i: number) => {\n if (!uscite[nome]) uscite[nome] = { esito, r, barre: i - entrata };\n };\n\n for (\n let i = entrata + 1; i < Math.min(barre.length, entrata + scadenza); i++\n ) {\n const b = barre[i];\n const contro = long ? (prezzo - b.l) / rischio : (b.h - prezzo) / rischio;\n const favore = long ? (b.h - prezzo) / rischio : (prezzo - b.l) / rischio;\n mae = Math.max(mae, contro);\n mfe = Math.max(mfe, favore);\n\n const stopColpito = long ? b.l <= stop : b.h >= stop;\n\n // convenzione pessimistica: se stop e target cadono nella stessa\n // barra, vale sempre lo stop\n if (stopColpito) {\n for (\n const nome of [\"pool_vicina\", \"pool_scelta\", ...Object.keys(multipli)]\n ) {\n chiudi(nome, \"STOP\", -1, i);\n }\n esitoPrincipale = {\n ...base,\n esito: \"STOP\",\n uscitaIndice: i,\n uscitaPrezzo: stop,\n r: -1,\n mae,\n mfe,\n durata: i - entrata,\n uscite,\n };\n break;\n }\n\n for (const [nome, mult] of Object.entries(multipli)) {\n const liv = long ? prezzo + mult * rischio : prezzo - mult * rischio;\n if (long ? b.h >= liv : b.l <= liv) chiudi(nome, \"TARGET\", mult, i);\n }\n if (poolVicina !== null && (long ? b.h >= poolVicina : b.l <= poolVicina)) {\n chiudi(\n \"pool_vicina\",\n \"TARGET\",\n +(Math.abs(poolVicina - prezzo) / rischio).toFixed(3),\n i,\n );\n }\n if (s.target1 !== null && (long ? b.h >= s.target1 : b.l <= s.target1)) {\n chiudi(\n \"pool_scelta\",\n \"TARGET\",\n +(Math.abs(s.target1 - prezzo) / rischio).toFixed(3),\n i,\n );\n }\n\n // esito ufficiale: multiplo fisso se richiesto, altrimenti la pool\n const bersaglio = uscitaFissaR !== null\n ? (long\n ? prezzo + uscitaFissaR * rischio\n : prezzo - uscitaFissaR * rischio)\n : s.target1;\n if (\n bersaglio !== null && !esitoPrincipale &&\n (long ? b.h >= bersaglio : b.l <= bersaglio)\n ) {\n esitoPrincipale = {\n ...base,\n esito: \"TARGET1\",\n uscitaIndice: i,\n uscitaPrezzo: bersaglio,\n r: uscitaFissaR ?? +(Math.abs(bersaglio - prezzo) / rischio).toFixed(3),\n mae,\n mfe,\n durata: i - entrata,\n uscite,\n };\n break;\n }\n }\n\n for (const nome of [\"pool_vicina\", \"pool_scelta\", ...Object.keys(multipli)]) {\n if (!uscite[nome]) {\n uscite[nome] = { esito: \"SCADUTA\", r: null, barre: null };\n }\n }\n\n return esitoPrincipale ?? { ...base, mae, mfe, uscite };\n}\n\n/**\n * Confronta le regole di uscita sugli STESSI ingressi.\n *\n * È la domanda che un tasso di successo nullo non può rispondere da\n * solo: gli ingressi sono sbagliati, o è il target a essere irraggiungibile?\n * Se una regola a 2R fissi produce risultati decenti sugli stessi\n * ingressi, il problema è l'uscita. Se perdono tutte, sono gli ingressi.\n */\nexport function confrontaUscite(operazioni: Operazione[]) {\n const nomi = [\n \"pool_vicina\",\n \"pool_scelta\",\n \"fisso_1R\",\n \"fisso_2R\",\n \"fisso_3R\",\n \"fisso_5R\",\n ];\n return nomi.map((nome) => {\n const esiti = operazioni.map((o) => o.uscite?.[nome]).filter(\n Boolean,\n ) as any[];\n const chiuse = esiti.filter((x) => x.r !== null);\n if (!chiuse.length) return { regola: nome, operazioni: 0 };\n const r = chiuse.map((x) => x.r as number);\n const vinte = r.filter((x) => x > 0);\n return {\n regola: nome,\n operazioni: chiuse.length,\n scadute: esiti.length - chiuse.length,\n winRate: +(vinte.length / chiuse.length).toFixed(3),\n expectancyR: +(r.reduce((a, x) => a + x, 0) / chiuse.length).toFixed(3),\n totaleR: +r.reduce((a, x) => a + x, 0).toFixed(1),\n durataMedia: +(chiuse.reduce((a, x) =>\n a + (x.barre ?? 0), 0) / chiuse.length).toFixed(1),\n };\n });\n}\n\n/**\n * Ricalcola le metriche usando una regola di uscita diversa da quella\n * principale. Non risimula nulla: le uscite alternative sono già state\n * registrate nella stessa passata, quindi il confronto è sugli identici\n * ingressi e sugli identici dati.\n */\nexport function metricheConRegola(\n operazioni: Operazione[],\n regola: string,\n barreTotali: number,\n) {\n const conv = operazioni\n .map((o) => ({\n ...o,\n r: o.uscite?.[regola]?.r ?? null,\n durata: o.uscite?.[regola]?.barre ?? null,\n }))\n .filter((o) => o.r !== null);\n return metriche(conv as Operazione[], barreTotali);\n}\n\n/**\n * Quanto resta dell'aspettativa togliendo l'attrito.\n *\n * Con stop sotto l'ATR lo slippage è una frazione grande del rischio:\n * un sistema che guadagna 0.5R lordi può finire a zero se ogni\n * operazione ne perde 0.15 fra spread ed esecuzione. È la verifica che\n * separa un vantaggio reale da uno che esiste solo senza costi.\n */\nexport function sensibilitaCosti(operazioni: Operazione[], regola: string) {\n const r = operazioni.map((o) => o.uscite?.[regola]?.r).filter((x) =>\n x !== null && x !== undefined\n ) as number[];\n if (!r.length) return null;\n const lordo = r.reduce((a, x) => a + x, 0) / r.length;\n const conAttrito = (f: number) =>\n +(r.reduce((a, x) => a + x - f, 0) / r.length).toFixed(3);\n return {\n lordo: +lordo.toFixed(3),\n attrito005R: conAttrito(0.05),\n attrito010R: conAttrito(0.10),\n attrito015R: conAttrito(0.15),\n attrito025R: conAttrito(0.25),\n puntoDiPareggio: +lordo.toFixed(3),\n nota:\n \"l'attrito è espresso in frazione di R per operazione: spread, commissioni e slippage insieme\",\n };\n}\n\n/** Distribuzione dell'escursione favorevole: quanto il prezzo percorre davvero. */\nexport function distribuzioneMfe(operazioni: Operazione[]) {\n const v = operazioni.map((o) => o.mfe).filter((x) => isFinite(x)).sort((\n a,\n b,\n ) => a - b);\n if (!v.length) return null;\n const q = (p: number) =>\n +v[Math.min(v.length - 1, Math.floor(v.length * p))].toFixed(2);\n return {\n operazioni: v.length,\n mediana: q(0.5),\n q25: q(0.25),\n q75: q(0.75),\n q90: q(0.9),\n massimo: q(0.999),\n oltre1R: +(v.filter((x) => x >= 1).length / v.length).toFixed(3),\n oltre2R: +(v.filter((x) => x >= 2).length / v.length).toFixed(3),\n oltre3R: +(v.filter((x) => x >= 3).length / v.length).toFixed(3),\n };\n}\n\n/* ------------------------------ imbuto ----------------------------- */\n\n/**\n * Quanti setup sopravvivono a ogni stadio. Serve più delle metriche\n * quando le operazioni sono poche: dice DOVE il sistema si ferma, e\n * quindi quale gate sta davvero governando la frequenza.\n *\n * Un motore che produce zero segnali non è necessariamente rotto — può\n * essere giustamente severo — ma la differenza si vede solo qui.\n */\nexport function imbuto(barre: Barra[], opzioni: any = {}) {\n const r = simula(barre, opzioni);\n const conta: Record = {};\n for (const s of r.scartate) conta[s.motivo] = (conta[s.motivo] ?? 0) + 1;\n\n const sweeps = r.eventi.filter((e) => /^SWEEP_/.test(e.tipo)).length;\n const mss = r.eventi.filter((e) => /^MSS_/.test(e.tipo)).length;\n\n const stadi = [\n { stadio: \"sweep rilevate\", superstiti: sweeps, persi: 0 },\n {\n stadio: \"con MSS nella finestra\",\n superstiti: sweeps - (conta[\"nessun MSS entro la finestra\"] ?? 0),\n persi: conta[\"nessun MSS entro la finestra\"] ?? 0,\n },\n {\n stadio: \"con zona creata\",\n superstiti: sweeps - (conta[\"nessun MSS entro la finestra\"] ?? 0) -\n (conta[\"nessuna zona dopo il MSS\"] ?? 0),\n persi: conta[\"nessuna zona dopo il MSS\"] ?? 0,\n },\n {\n stadio: \"con rientro in zona\",\n superstiti: sweeps - (conta[\"nessun MSS entro la finestra\"] ?? 0) -\n (conta[\"nessuna zona dopo il MSS\"] ?? 0) -\n (conta[\"nessun rientro in zona\"] ?? 0),\n persi: conta[\"nessun rientro in zona\"] ?? 0,\n },\n {\n stadio: \"con zona utilizzabile\",\n superstiti: sweeps - (conta[\"nessun MSS entro la finestra\"] ?? 0) -\n (conta[\"nessuna zona dopo il MSS\"] ?? 0) -\n (conta[\"nessun rientro in zona\"] ?? 0) -\n (conta[\"bias non concorde all'ingresso\"] ?? 0) -\n (conta[\"zona troppo larga\"] ?? 0),\n persi: conta[\"zona troppo larga\"] ?? 0,\n },\n {\n stadio: \"con stop fuori dal rumore\",\n superstiti: sweeps - (conta[\"nessun MSS entro la finestra\"] ?? 0) -\n (conta[\"nessuna zona dopo il MSS\"] ?? 0) -\n (conta[\"nessun rientro in zona\"] ?? 0) -\n (conta[\"bias non concorde all'ingresso\"] ?? 0) -\n (conta[\"zona troppo larga\"] ?? 0) -\n (conta[\"stop dentro il rumore\"] ?? 0),\n persi: conta[\"stop dentro il rumore\"] ?? 0,\n },\n {\n stadio: \"con bias concorde\",\n superstiti: r.operazioni.length + Object.entries(conta)\n .filter(([k]) => k.startsWith(\"R:R\") || k.includes(\"target\"))\n .reduce((a, [, v]) => a + v, 0),\n persi: conta[\"bias non concorde all'ingresso\"] ?? 0,\n },\n {\n stadio: \"con R:R sufficiente\",\n superstiti: r.operazioni.length,\n persi: Object.entries(conta).filter(([k]) =>\n k.startsWith(\"R:R\") || k.includes(\"target\")\n )\n .reduce((a, [, v]) => a + v, 0),\n },\n ];\n\n // Il collo va misurato in percentuale di ciò che ENTRA nello stadio:\n // in valore assoluto vince sempre il primo filtro, che parte dal\n // numero più grande, e nasconde uno stadio che respinge il 100%.\n const conTasso = stadi.map((st, k) => {\n const entrati = k === 0 ? st.superstiti : stadi[k - 1].superstiti;\n return {\n ...st,\n entrati,\n tassoScarto: entrati > 0 ? +(st.persi / entrati).toFixed(3) : null,\n };\n });\n\n return {\n barre: barre.length,\n eventiSweep: sweeps,\n eventiMss: mss,\n stadi: conTasso,\n motiviScarto: conta,\n operazioni: r.operazioni.length,\n collo:\n conTasso.reduce(\n (a, x) => ((x.tassoScarto ?? 0) > (a.tassoScarto ?? 0) ? x : a),\n conTasso[0],\n ).stadio,\n colloAssoluto:\n stadi.reduce((a, x) => (x.persi > a.persi ? x : a), stadi[0]).stadio,\n };\n}\n\n/* ----------------------------- metriche ---------------------------- */\n\nexport function metriche(operazioni: Operazione[], barreTotali: number) {\n const chiuse = operazioni.filter((o) => o.r !== null);\n if (!chiuse.length) {\n return { operazioni: 0, nota: \"nessuna operazione chiusa\" };\n }\n\n const r = chiuse.map((o) => o.r!);\n const vinte = r.filter((x) => x > 0), perse = r.filter((x) => x <= 0);\n const somma = (v: number[]) => v.reduce((s, x) => s + x, 0);\n\n // drawdown sulla curva cumulata in R\n let picco = 0, cum = 0, dd = 0;\n for (const x of r) {\n cum += x;\n picco = Math.max(picco, cum);\n dd = Math.min(dd, cum - picco);\n }\n\n return {\n operazioni: chiuse.length,\n aperte: operazioni.length - chiuse.length,\n winRate: +(vinte.length / chiuse.length).toFixed(4),\n expectancyR: +(somma(r) / chiuse.length).toFixed(4),\n mediaRVinte: vinte.length\n ? +(somma(vinte) / vinte.length).toFixed(3)\n : null,\n profitFactor: perse.length\n ? +(somma(vinte) / Math.abs(somma(perse))).toFixed(3)\n : null,\n totaleR: +somma(r).toFixed(2),\n drawdownMaxR: +dd.toFixed(2),\n maeMedia: +(somma(chiuse.map((o) => o.mae)) / chiuse.length).toFixed(3),\n mfeMedia: +(somma(chiuse.map((o) => o.mfe)) / chiuse.length).toFixed(3),\n durataMedia: +(somma(chiuse.map((o) => o.durata ?? 0)) / chiuse.length)\n .toFixed(1),\n frequenzaPer1000Barre: +((chiuse.length / barreTotali) * 1000).toFixed(2),\n rrAttesoMedio: +(somma(chiuse.map((o) => o.rrAtteso ?? 0)) / chiuse.length)\n .toFixed(2),\n };\n}\n\n/** Il punteggio più alto corrisponde davvero a risultati migliori? */\nexport function perFascia(\n operazioni: Operazione[],\n punteggi: Map,\n) {\n const fasce = [[0, 60], [60, 70], [70, 80], [80, 90], [90, 101]];\n return fasce.map(([da, a]) => {\n const gruppo = operazioni.filter((o) => {\n const p = punteggi.get(o.entrataIndice);\n return p !== undefined && p >= da && p < a && o.r !== null;\n });\n const r = gruppo.map((o) => o.r!);\n return {\n fascia: `${da}-${a - 1}`,\n operazioni: gruppo.length,\n expectancyR: r.length\n ? +(r.reduce((s, x) => s + x, 0) / r.length).toFixed(3)\n : null,\n winRate: r.length\n ? +(r.filter((x) => x > 0).length / r.length).toFixed(3)\n : null,\n };\n });\n}\n\n/* --------------------------- walk-forward -------------------------- */\n\n/**\n * 60% in-sample, 20% out-of-sample, 20% walk-forward.\n * I tre segmenti non si sovrappongono e vengono simulati separatamente:\n * un parametro tarato sul primo deve reggere sugli altri due.\n */\nexport function segmenti(barre: Barra[]) {\n const n = barre.length;\n const a = Math.floor(n * 0.6), b = Math.floor(n * 0.8);\n return {\n inSample: barre.slice(0, a),\n outOfSample: barre.slice(a, b),\n walkForward: barre.slice(b),\n };\n}\n\nexport function walkForward(barre: Barra[], opzioni: any = {}) {\n const s = segmenti(barre);\n const esegui = (b: Barra[]) => {\n if (b.length < 60) return { operazioni: 0, nota: \"segmento troppo corto\" };\n const r = simula(b, opzioni);\n return metriche(r.operazioni, b.length);\n };\n const risultati = {\n inSample: esegui(s.inSample),\n outOfSample: esegui(s.outOfSample),\n walkForward: esegui(s.walkForward),\n };\n\n const e = (\n x: any,\n ) => (typeof x?.expectancyR === \"number\" ? x.expectancyR : null);\n const tutti = [\n e(risultati.inSample),\n e(risultati.outOfSample),\n e(risultati.walkForward),\n ];\n const misurabili = tutti.filter((x) => x !== null) as number[];\n\n return {\n ...risultati,\n verdetto: misurabili.length < 3\n ? \"dati insufficienti su almeno un segmento: nessuna conclusione\"\n : misurabili.every((x) => x > 0)\n ? \"positivo su tutti e tre i segmenti\"\n : misurabili[0] > 0 && misurabili.slice(1).some((x) => x <= 0)\n ? \"positivo solo in-sample: sospetto adattamento ai dati\"\n : \"non positivo in modo consistente\",\n degrado: misurabili.length === 3 && misurabili[0] !== 0\n ? +(1 - misurabili[2] / misurabili[0]).toFixed(3)\n : null,\n };\n}\n\n/* -------------------------- sensibilità ---------------------------- */\n\nconst CONTENITORI: Record = {\n pivotN: PARAMETRI,\n bufferAtr: PARAMETRI,\n dispMinAtr: PARAMETRI,\n dispBodyRange: PARAMETRI,\n mssFinestra: PARAMETRI,\n tolleranzaEq: PARAMETRI_LIQ,\n profonditaMax: PARAMETRI_LIQ,\n wickBody: PARAMETRI_LIQ,\n fvgMinAtr: PARAMETRI_ZONE,\n rrMinimo: PARAMETRI_OP,\n finestraSweepMss: PARAMETRI_SMC,\n};\n\n/**\n * Varia UN parametro alla volta e misura sui tre segmenti.\n *\n * Non fa ricerca esaustiva di proposito: dieci parametri con tre valori\n * fanno cinquantanovemila combinazioni, e la migliore su un dataset è\n * quasi sempre rumore. Qui si guarda la stabilità di un parametro, non\n * il suo valore ottimo.\n */\nexport function sensibilita(barre: Barra[], parametro: string, valori: any[]) {\n const contenitore = CONTENITORI[parametro];\n if (!contenitore) throw new Error(`parametro non registrato: ${parametro}`);\n const originale = contenitore[parametro];\n const esiti: any[] = [];\n\n for (const v of valori) {\n contenitore[parametro] = v;\n try {\n const wf = walkForward(\n barre,\n parametro === \"finestraSweepMss\" ? { finestraSweepMss: v } : {},\n );\n esiti.push({\n valore: v,\n inSample: (wf.inSample as any).expectancyR ?? null,\n outOfSample: (wf.outOfSample as any).expectancyR ?? null,\n walkForward: (wf.walkForward as any).expectancyR ?? null,\n operazioni: ((wf.inSample as any).operazioni ?? 0) +\n ((wf.outOfSample as any).operazioni ?? 0) +\n ((wf.walkForward as any).operazioni ?? 0),\n verdetto: wf.verdetto,\n });\n } catch (e) {\n esiti.push({\n valore: v,\n errore: String((e as Error)?.message ?? e).slice(0, 80),\n });\n }\n }\n contenitore[parametro] = originale;\n\n // Un candidato deve migliorare ovunque, non in media\n const validi = esiti.filter((x) =>\n [x.inSample, x.outOfSample, x.walkForward]\n .every((y) => typeof y === \"number\")\n );\n const base = validi.find((x) => x.valore === originale);\n const migliori = base\n ? validi.filter((x) =>\n x.valore !== originale &&\n x.inSample > base.inSample && x.outOfSample > base.outOfSample &&\n x.walkForward > base.walkForward\n )\n : [];\n\n return {\n parametro,\n originale,\n esiti,\n raccomandazione: !base\n ? \"il valore corrente non è misurabile su tutti i segmenti\"\n : migliori.length === 0\n ? `nessun valore batte ${originale} su tutti e tre i segmenti: tenerlo`\n : `${\n migliori.map((x) => x.valore).join(\", \")\n } migliora ovunque, ma servono più dati prima di cambiare`,\n };\n}",[252],"pulls","branches",1,"forks","envVars",{"_266":158,"_268":62},"connections",{"_266":62,"_267":62},"count","unfilledCount","emptyCount",{"_42":251,"_32":252,"_30":253,"_145":-5,"_40":41,"_39":254,"_147":48,"_37":327,"_13":248,"_33":34,"_35":256,"_24":48,"_151":-5,"_285":328,"_27":329},{"_42":243,"_32":244,"_30":245,"_145":-5,"_40":41,"_39":246,"_147":25,"_37":324,"_13":248,"_33":34,"_35":249,"_24":48,"_151":-5,"_285":325,"_27":326},{"_42":236,"_32":237,"_30":238,"_145":-5,"_40":41,"_39":239,"_147":25,"_37":321,"_13":149,"_33":34,"_35":241,"_24":48,"_151":-5,"_285":322,"_27":323},{"_42":228,"_32":229,"_30":230,"_145":-5,"_40":41,"_39":231,"_147":25,"_37":318,"_13":204,"_33":233,"_35":234,"_24":48,"_151":-5,"_285":319,"_27":320},{"_42":221,"_32":222,"_30":223,"_145":-5,"_40":41,"_39":224,"_147":25,"_37":315,"_13":173,"_33":34,"_35":226,"_24":48,"_151":-5,"_285":316,"_27":317},{"_42":214,"_32":215,"_30":216,"_145":-5,"_40":41,"_39":217,"_147":25,"_37":312,"_13":173,"_33":34,"_35":219,"_24":48,"_151":-5,"_285":313,"_27":314},{"_42":207,"_32":208,"_30":209,"_145":-5,"_40":41,"_39":210,"_147":25,"_37":309,"_13":149,"_33":34,"_35":212,"_24":48,"_151":-5,"_285":310,"_27":311},{"_42":199,"_32":200,"_30":201,"_145":-5,"_40":41,"_39":202,"_147":25,"_37":306,"_13":204,"_33":34,"_35":205,"_24":48,"_151":-5,"_285":307,"_27":308},{"_42":191,"_32":192,"_30":57,"_145":-5,"_40":41,"_39":193,"_147":48,"_37":303,"_13":195,"_33":196,"_35":197,"_24":48,"_151":-5,"_285":304,"_27":305},{"_42":184,"_32":185,"_30":186,"_145":-5,"_40":41,"_39":187,"_147":25,"_37":300,"_13":149,"_33":34,"_35":189,"_24":48,"_151":-5,"_285":301,"_27":302},{"_42":176,"_32":177,"_30":178,"_145":-5,"_40":41,"_39":179,"_147":48,"_37":297,"_13":181,"_33":34,"_35":182,"_24":48,"_151":-5,"_285":298,"_27":299},{"_42":168,"_32":169,"_30":170,"_145":-5,"_40":41,"_39":171,"_147":48,"_37":294,"_13":173,"_33":34,"_35":174,"_24":48,"_151":-5,"_285":295,"_27":296},{"_42":161,"_32":162,"_30":163,"_145":-5,"_40":41,"_39":164,"_147":48,"_37":291,"_13":158,"_33":34,"_35":166,"_24":48,"_151":-5,"_285":292,"_27":293},{"_42":153,"_32":154,"_30":155,"_145":-5,"_40":41,"_39":156,"_147":48,"_37":288,"_13":158,"_33":34,"_35":159,"_24":48,"_151":-5,"_285":289,"_27":290},{"_42":142,"_32":143,"_30":144,"_145":-5,"_40":41,"_39":146,"_147":25,"_37":284,"_13":149,"_33":34,"_35":150,"_24":48,"_151":-5,"_285":286,"_27":287},["D",1788901092981],"children",[],[143],["D",1788901488510],[],[154],["D",1789024355161],[],[162],["D",1788901499568],[],[169],["D",1789063795088],[],[177],["D",1788901455880],[],[185],["D",1789071906578],[],[192],["D",1788900908496],[],[200],["D",1788900591280],[],[208],["D",1788879199392],[],[215],["D",1788901174031],[],[222],["D",1788900300372],[],[229],["D",1788894870909],[],[237],["D",1788950057578],[],[244],["D",1789063784138],[],[252],["D",1788877625254],["D",1789485645684],{"_99":98,"_105":53},{"_99":98,"_100":53,"_101":53,"_18":55,"_102":103,"_104":48},{"_13":88,"_32":89,"_42":41,"_90":43,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":44,"_97":98},"ctx",{"_81":-5,"_124":368,"_369":370,"_371":372,"_373":48,"_374":48,"_375":48,"_376":25,"_377":-5,"_378":-7,"_379":-7,"_380":62,"_381":48,"_382":48,"_383":-5,"_384":48,"_385":48,"_386":48,"_387":-5},"ENV",{"_339":340,"_341":342,"_343":89,"_344":345,"_346":347,"_348":349,"_350":351,"_352":353,"_354":355,"_356":357,"_358":359,"_360":361,"_362":363,"_364":365,"_366":367},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","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 · v118