Le mensonge de la frontière, ou d'où viennent les any The boundary's lie, or where the anys come from

L'annotation sur une donnée du dehors est un vœu, pas une preuve.The annotation on outside data is a wish, not a proof.

Tout ce qui entre dans le programme — réseau, JSON.parse, localStorage, process.env, formulaires — arrive non typé. Mais les signatures le cachent : on écrit const config: Config = JSON.parse(raw), le compilateur sourit, et l'on croit tenir un Config. On ne tient rien. Le type s'est effacé bien avant que les octets n'arrivent (Vol 2), et l'annotation n'a fait que blanchir un any (Vol 4). Ce volume paie la dette des deux : il nomme la frontière, et le seul endroit où la donnée devient vraiment typée.Everything entering the program — network, JSON.parse, localStorage, process.env, forms — arrives untyped. But the signatures hide it: you write const config: Config = JSON.parse(raw), the compiler smiles, and you think you hold a Config. You hold nothing. The type erased long before the bytes arrived (Vol 2), and the annotation merely laundered an any (Vol 4). This volume pays both debts: it names the boundary, and the one place where data truly becomes typed.

interface Config { port: number; host: string }

const config: Config = JSON.parse(raw);   // ✗ annoté Config — mais RIEN ne l'a vérifié
config.port.toFixed();                     // 💥 si le JSON n'a pas 'port' : crash, loin d'ici
// JSON.parse renvoie 'any' : l'annotation est un vœu, pas une preuve (Vol 2 + Vol 4)

const data: unknown = JSON.parse(raw);   // la vérité : on ne SAIT pas ce que c'est

// impossible de toucher data.port sans prouver d'abord (Vol 4.2) :
if (isConfig(data)) data.port.toFixed();  // ✓ typé seulement APRÈS la preuve
// (le validateur en un geste, c'est le 7.2 — ici, on cesse de se mentir)

Les any qui te plombent, tu ne les as pas écrits. Ils entrent par les bords.The anys that sink you, you didn't write. They enter through the edges.

strict activé, noImplicitAny en place, jamais un any sous tes doigts — et pourtant ton programme en grouille. Ils sont injectés par les fonctions de frontière elles-mêmes : JSON.parse rend any, fetch().json() rend Promise<any>, localStorage et les URLSearchParams rendent des chaînes brutes. Le mensonge est dans les définitions de types fournies. Ce sont là les vraies sources des bugs de type à l'exécution — pas le any qu'on s'interdit, mais ceux qu'on ne voit pas entrer.strict on, noImplicitAny in place, never an any under your fingers — and yet your program teems with them. They're injected by the boundary functions themselves: JSON.parse returns any, fetch().json() returns Promise<any>, localStorage and URLSearchParams return raw strings. The lie is in the supplied type definitions. These are the real sources of runtime type bugs — not the any you forbid yourself, but the ones you don't see come in.

JSON.parse(raw)               // : any
await res.json()              // : any         (Promise<any>)
localStorage.getItem("k")     // : string | null   → JSON.parse → any
process.env.PORT              // : string | undefined  (traité comme string sûr)
new URLSearchParams(s).get()  // : string | null
(e.target as HTMLInputElement).value  // un 'as' pour deviner la cible

Chacune de ces entrées arrive any ou en chaîne brute — c'est fidèle au runtime (le réseau ne transporte pas de types, Vol 2), mais TypeScript a choisi any plutôt qu'unknown par confort. Résultat : la porte d'entrée est grande ouverte, et c'est la définition de type elle-même qui la tient ouverte.Each of these entries arrives as any or a raw string — that's faithful to runtime (the network carries no types, Vol 2), but TypeScript chose any over unknown for convenience. Result: the front door is wide open, and it's the type definition itself holding it open.

Le type ne traverse pas le fil. À la frontière, il est inventé, pas reçu.The type doesn't cross the wire. At the boundary, it's invented, not received.

La mécanique découle du Vol 2. À l'exécution, il n'y a que des octets : une chaîne JSON, un corps de réponse, une valeur de localStorage. Aucun type ne voyage avec eux — il s'est effacé à la compilation, de l'autre côté du fil. Donc quand JSON.parse rend une valeur, TypeScript ne peut pas connaître sa forme : il l'invente (any). Le système de types s'arrête net au bord. Dedans, tout est preuve et inférence ; dehors, c'est du runtime nu. La couture entre les deux, c'est la frontière.The mechanic follows from Vol 2. At runtime there are only bytes: a JSON string, a response body, a localStorage value. No type travels with them — it erased at compile time, on the other side of the wire. So when JSON.parse returns a value, TypeScript can't know its shape: it invents one (any). The type system stops dead at the edge. Inside, all is proof and inference; outside, it's bare runtime. The seam between the two is the boundary.

// À l'exécution, la frontière ne transporte que des octets / des chaînes :
//
//   réseau ──▶ une chaîne brute ──▶ JSON.parse ──▶ valeur JS ──▶ TON code
//                                       ▲
//                         ICI le type est INVENTÉ (any) :
//                         il n'a jamais voyagé avec la donnée (Vol 2)
//
// Le système de types s'arrête au bord. Dedans : preuve. Dehors : runtime nu.

// Le type FOURNI ment ; le type HONNÊTE est unknown.
function parseJSON(raw: string): unknown {   // au lieu d'any
  return JSON.parse(raw);
}
// On retype la frontière en unknown → le mur du Vol 4.2 force la validation.

« On est typés, donc on est sûrs. » Le build vert ne parle pas des données du dehors."We're typed, so we're safe." The green build says nothing about outside data.

Le piège n'est pas une ligne, c'est une fausse équation : couverture de types = sûreté à l'exécution. On active strict, on bannit any, on dessine de belles interfaces — et l'on conclut qu'on est protégé. Mais chaque point d'entrée reste une supposition non vérifiée. Le compilateur vert ne certifie que la cohérence interne du code ; il ne sait rien des octets qui franchiront la frontière en production. La vraie question n'est pas « ai-je des types ? » mais « où la donnée du dehors est-elle prouvée ? ».The trap isn't a line, it's a false equation: type coverage = runtime safety. You turn on strict, ban any, draw fine interfaces — and conclude you're protected. But every entry point stays an unchecked assumption. The green compiler only certifies the code's internal consistency; it knows nothing of the bytes that will cross the boundary in production. The real question isn't 'do I have types?' but 'where is outside data proven?'.

// strict: true, zéro 'any' explicite, des interfaces partout — et pourtant :
const user   = await fetch("/me").then(r => r.json());   // any
const draft  = JSON.parse(localStorage.getItem("draft")!); // any
const port   = Number(process.env.PORT);                  // NaN si absent/invalide

// trois frontières non gardées = trois crashs latents.
// Le build est vert. Il ne dit RIEN sur les octets qui arrivent.

Le pire offenseur : fetch().json() as ApiResponse — une interface + un as qui rebaptisent un any en mensonge typé. Zéro vérification ; le crash est seulement reporté au premier champ manquant, à des écrans de la cause. Le strict: true n'y change rien : il garde l'intérieur, pas la porte.The worst offender: fetch().json() as ApiResponse — an interface + an as that rename an any into a typed lie. Zero verification; the crash is merely deferred to the first missing field, screens from the cause. strict: true changes nothing: it guards the inside, not the door.