@open3cl/engine 1.7.1 → 1.7.3

package/13.2_generateur_combustion.js

@@ -4,7 +4,7 @@ import { updateGenerateurBouilleurs } from './13.2_generateur_combustion_bouille
 import { updateGenerateurChaudieres } from './13.2_generateur_combustion_chaudiere.js';
 import { updateGenerateurPacs } from './13.2_generateur_pac.js';
 import getFicheTechnique from './ficheTechnique.js';
-import { evaluate } from 'mathjs';
+import { evaluateFormula as evaluateTvFormula } from './formula.js';
 
 function criterePn(Pn, matcher) {
   let critere_list = tvColumnLines('generateur_combustion', 'critere_pn', matcher);
@@ -38,15 +38,7 @@ const F_tab = {
 };
 
 function evaluateFormula(formulaOrValue, pn, E, F) {
-  const pnVariable = pn / 1000;
-  if (!isNaN(formulaOrValue)) {
-    return Number(formulaOrValue);
-  }
-  const variables = new Map();
-  variables.set('Pn', pnVariable);
-  variables.set('E', E);
-  variables.set('F', F);
-  return evaluate(formulaOrValue, variables);
+  return evaluateTvFormula(formulaOrValue, pn, E, F);
 }
 
 /**

package/3.1_b.js

@@ -1,8 +1,47 @@
 import enums from './enums.js';
 import { tv, requestInput, requestInputID, bug_for_bug_compat } from './utils.js';
 
+const RANGES = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+
+/**
+ * Identifiants de type d'adjacence pour lesquels le ratio aiu/aue est pris en compte.
+ */
+const ADJACENCE_AIU_AUE_IDS = new Set([
+  '8',
+  '9',
+  '11',
+  '12',
+  '13',
+  '14',
+  '15',
+  '16',
+  '17',
+  '18',
+  '19',
+  '21'
+]);
+
+const TYPE_ADJACENCE_IDS = Object.keys(enums.type_adjacence);
+
+/**
+ * Formate une borne du ratio aiu/aue au format des tables de valeurs (`0,25`, `1,00`…).
+ *
+ * `toLocaleString(undefined, { minimumFractionDigits: 2, … })` construisait un
+ * `Intl.NumberFormat` à chaque appel (~29 µs), ce qui représentait l'essentiel du
+ * temps CPU de `b()`. `toFixed(2)` produit exactement les mêmes chaînes pour toutes
+ * les valeurs de `RANGES`, en ~0,2 µs, et sans dépendre de la locale de la machine —
+ * le `.replace('.', ',')` qui suivait était d'ailleurs un no-op sur une machine en
+ * locale française et une vraie conversion ailleurs.
+ *
+ * @param borne {number}
+ * @returns {string}
+ */
+function formatBorneAiuAue(borne) {
+  return borne.toFixed(2).replace('.', ',');
+}
+
 export function findRanges(inputNumber) {
-  const ranges = [0.25, 0.5, 0.75, 1, 1.25, 2, 2.5, 3, 3.5, 4, 6, 8, 10, 25, 50];
+  const ranges = RANGES;
   const result = [];
 
   if (inputNumber < ranges[0]) {
@@ -28,7 +67,7 @@ export function findRanges(inputNumber) {
 export default function b(di, de, du, zc_id) {
   const zc = enums.zone_climatique[zc_id].slice(0, 2);
 
-  du.enum_type_adjacence_id = Object.keys(enums.type_adjacence);
+  du.enum_type_adjacence_id = TYPE_ADJACENCE_IDS;
   const matcher = {
     enum_type_adjacence_id: requestInputID(de, du, 'type_adjacence')
   };
@@ -37,11 +76,7 @@ export default function b(di, de, du, zc_id) {
     matcher.zone_climatique = zc;
     matcher.enum_cfg_isolation_lnc_id = requestInputID(de, du, 'cfg_isolation_lnc');
     /* du.enum_cfg_isolation_lnc_id = ['6', '7', '8', '9', '10', '11'] */
-  } else if (
-    ['8', '9', '11', '12', '13', '14', '15', '16', '17', '18', '19', '21'].includes(
-      de.enum_type_adjacence_id.toString()
-    )
-  ) {
+  } else if (ADJACENCE_AIU_AUE_IDS.has(de.enum_type_adjacence_id.toString())) {
     if (de.surface_aue === 0) {
       // cf page 10
       // NOTE: bizarre de regarder aue pour un local chauffé non accessible
@@ -96,36 +131,13 @@ export default function b(di, de, du, zc_id) {
           // Si le rapport des surfaces est égale à la borne inférieure, utilisation de la borne supérieure
           // et prise en compte de l'égalité
           if (ranges[0] === de.surface_aiu / de.surface_aue) {
-            matcher.aiu_aue_max =
-              '≤ ' +
-              ranges[0]
-                .toLocaleString(undefined, {
-                  minimumFractionDigits: 2,
-                  maximumFractionDigits: 2,
-                  useGrouping: false
-                })
-                .replace('.', ',');
+            matcher.aiu_aue_max = '≤ ' + formatBorneAiuAue(ranges[0]);
           } else {
-            matcher.aiu_aue_min =
-              ranges[0]
-                .toLocaleString(undefined, {
-                  minimumFractionDigits: 2,
-                  maximumFractionDigits: 2,
-                  useGrouping: false
-                })
-                .replace('.', ',') + ' <';
+            matcher.aiu_aue_min = formatBorneAiuAue(ranges[0]) + ' <';
           }
         }
         if (ranges[1]) {
-          matcher.aiu_aue_max =
-            '≤ ' +
-            ranges[1]
-              .toLocaleString(undefined, {
-                minimumFractionDigits: 2,
-                maximumFractionDigits: 2,
-                useGrouping: false
-              })
-              .replace('.', ',');
+          matcher.aiu_aue_max = '≤ ' + formatBorneAiuAue(ranges[1]);
         }
       }
     }

package/3.2.1_mur.js

@@ -122,7 +122,7 @@ function tv_umur(di, de, du, pc_id, zc, effetJoule) {
   }
 }
 
-function calc_umur0(di, de, du) {
+function calc_umur0(di, de, du, versionDpe) {
   const umur0_avant = du.umur0_avant;
   const umur_avant = du.umur_avant;
 
@@ -166,8 +166,17 @@ function calc_umur0(di, de, du) {
     }
   }
 
-  // Si présence d'un doublage
-  if (type_doublage > 2) {
+  /**
+   * Le doublage NE doit PAS être cumulé à une isolation ITE ou ITI.
+   * Il doit uniquement être pris en compte en l'absence d'isolation ITE/ITI (ex: ITR seule, non isolé, inconnu).
+   * Types avec ITE ou ITI : 3 (iti), 4 (ite), 6 (iti+ite), 7 (iti+itr), 8 (ite+itr)
+   * @see https://github.com/Open3CL/engine/issues/146
+   */
+  const type_isolation = parseInt(de.enum_type_isolation_id) || 1;
+  const hasIteOrIti = versionDpe >= 2.4 && [3, 4, 6, 7, 8].includes(type_isolation);
+
+  // Si présence d'un doublage et pas d'isolation ITE/ITI
+  if (type_doublage > 2 && !hasIteOrIti) {
     let umur0Doublage;
 
     // 3 - doublage indéterminé ou lame d'air inf 15 mm
@@ -212,7 +221,7 @@ function calc_umur0(di, de, du) {
   di.umur0 = Math.min(2.5, di.umur0);
 }
 
-export default function calc_mur(mur, zc, pc_id, effetJoule) {
+export default function calc_mur(mur, zc, pc_id, effetJoule, versionDpe) {
   const de = mur.donnee_entree;
   const du = {};
   const di = {};
@@ -228,12 +237,12 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
   const methode_saisie_u = requestInput(de, du, 'methode_saisie_u');
   switch (methode_saisie_u) {
     case 'non isolé':
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       di.umur = Math.min(di.umur0, 2.5);
       break;
     case 'epaisseur isolation saisie justifiée par mesure ou observation':
     case 'epaisseur isolation saisie justifiée à partir des documents justificatifs autorisés': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const epaisseurIsolation = requestInput(de, du, 'epaisseur_isolation', 'int') * 0.01;
 
       if (epaisseurIsolation) {
@@ -251,7 +260,7 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
     }
     case "resistance isolation saisie justifiée observation de l'isolant installé et mesure de son épaisseur":
     case 'resistance isolation saisie justifiée  à partir des documents justificatifs autorisés': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const resistanceIsolation = requestInput(de, du, 'resistance_isolation', 'float');
 
       if (resistanceIsolation) {
@@ -268,19 +277,19 @@ export default function calc_mur(mur, zc, pc_id, effetJoule) {
       break;
     }
     case 'isolation inconnue  (table forfaitaire)':
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       tv_umur(di, de, du, pc_id, zc, effetJoule);
       di.umur = Math.min(di.umur, di.umur0);
       break;
     case "année d'isolation différente de l'année de construction saisie justifiée (table forfaitaire)": {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       const pi_id = requestInputID(de, du, 'periode_isolation') || pc_id;
       tv_umur(di, de, du, pi_id, zc, effetJoule);
       di.umur = Math.min(di.umur, di.umur0);
       break;
     }
     case 'année de construction saisie (table forfaitaire)': {
-      calc_umur0(di, de, du);
+      calc_umur0(di, de, du, versionDpe);
       // Si l'année d'isolation est connue, il faut l'utiliser et pas l'année de construction
       let pi_id = de.enum_periode_isolation_id || pc_id;
       if (!de.enum_periode_isolation_id) {

package/3.2.1_mur.spec.js

@@ -819,3 +819,108 @@ describe('calc_mur - méthode de saisie de U inconnue', () => {
     warn.mockRestore();
   });
 });
+
+/**
+ * Le doublage n'est plus cumulé à une isolation ITE ou ITI à partir de la version 2.4 du DPE.
+ * Les DPE antérieurs (2 à 2.3) ont été établis avec le cumul : on conserve ce comportement.
+ * @see https://github.com/Open3CL/engine/issues/146
+ */
+describe('calc_mur - doublage et isolation ITE/ITI (#146)', () => {
+  /** Umur0 issu de la table forfaitaire mockée. */
+  const UMUR0_TABLE = 2;
+  /** Umur0 avec doublage type 4 ou 5 cumulé : 1 / (1/2 + 0,21). */
+  const UMUR0_AVEC_DOUBLAGE = 1.4084507042253522;
+
+  /**
+   * @param enum_type_isolation_id {string}
+   * @param enum_type_doublage_id {string}
+   * @return {object}
+   */
+  const murIsoleAvecDoublage = (enum_type_isolation_id, enum_type_doublage_id = '5') => ({
+    donnee_entree: {
+      methode_saisie_u: 'epaisseur isolation saisie justifiée par mesure ou observation',
+      methode_saisie_u0:
+        'déterminé selon le matériau et épaisseur à partir de la table de valeur forfaitaire',
+      enum_materiaux_structure_mur_id: '5',
+      epaisseur_structure: 30,
+      epaisseur_isolation: 10,
+      enum_type_doublage_id,
+      enum_type_isolation_id
+    }
+  });
+
+  describe('DPE en version 2.4 et supérieure', () => {
+    test.each([
+      ['iti', '3'],
+      ['ite', '4'],
+      ['iti+ite', '6'],
+      ['iti+itr', '7'],
+      ['ite+itr', '8']
+    ])("isolation %s : le doublage n'est pas cumulé", (_label, typeIsolation) => {
+      const mur = murIsoleAvecDoublage(typeIsolation);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_TABLE, 9);
+    });
+
+    test.each([
+      ['inconnu', '1'],
+      ['non isolé', '2'],
+      ['itr', '5'],
+      ["isolé mais type d'isolation inconnu", '9']
+    ])('isolation %s : le doublage est cumulé', (_label, typeIsolation) => {
+      const mur = murIsoleAvecDoublage(typeIsolation);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+
+    test('type_isolation absent : le doublage est cumulé', () => {
+      const mur = murIsoleAvecDoublage(undefined);
+
+      calc_mur(mur, 'h1a', '1', '0', 2.5);
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+  });
+
+  describe('DPE antérieurs à la version 2.4', () => {
+    test.each([[2], [2.1], [2.2], [2.3]])(
+      'version %s : le doublage reste cumulé à une isolation ITI',
+      (versionDpe) => {
+        const mur = murIsoleAvecDoublage('3');
+
+        calc_mur(mur, 'h1a', '1', '0', versionDpe);
+
+        expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+      }
+    );
+
+    test('version absente : le doublage reste cumulé à une isolation ITE', () => {
+      const mur = murIsoleAvecDoublage('4');
+
+      calc_mur(mur, 'h1a', '1', '0');
+
+      expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_AVEC_DOUBLAGE, 9);
+    });
+  });
+
+  test.each([
+    ['isolation inconnue  (table forfaitaire)'],
+    [
+      "année d'isolation différente de l'année de construction saisie justifiée (table forfaitaire)"
+    ],
+    ['année de construction saisie (table forfaitaire)'],
+    ['resistance isolation saisie justifiée  à partir des documents justificatifs autorisés']
+  ])('methode_saisie_u "%s" : la version du DPE est prise en compte', (methode_saisie_u) => {
+    const mur = murIsoleAvecDoublage('3');
+    mur.donnee_entree.methode_saisie_u = methode_saisie_u;
+    mur.donnee_entree.resistance_isolation = 2.5;
+
+    calc_mur(mur, 'h1a', '1', '0', 2.4);
+
+    expect(mur.donnee_intermediaire.umur0).toBeCloseTo(UMUR0_TABLE, 9);
+  });
+});

package/3.3_baie_vitree.js

@@ -23,6 +23,37 @@ function tv_ug(di, de, du) {
   }
 }
 
+/**
+ * Valeurs de Ug tabulées dans `uw`, indexées par (type de baie, matériau de menuiserie).
+ *
+ * Le scan des 723 lignes de `tvs.uw` — avec un `split('|')` par ligne — était refait
+ * pour chaque baie vitrée de chaque DPE, alors que la table est statique.
+ *
+ * Le tableau est partagé et `getRange()` le trie sur place : le tri par défaut de
+ * `Array#sort` étant déterministe, la première mise en cache le laisse trié et les
+ * appels suivants produisent exactement le même résultat qu'avec un tableau reconstruit.
+ */
+const uwUgValuesCache = new Map();
+
+function uwUgValues(enum_type_baie_id, enum_type_materiaux_menuiserie_id) {
+  const cacheKey = `${enum_type_baie_id}
${enum_type_materiaux_menuiserie_id}`;
+  let values = uwUgValuesCache.get(cacheKey);
+  if (values === undefined) {
+    values = tvs.uw
+      .filter((row) => {
+        return (
+          row.enum_type_baie_id.split('|').includes(enum_type_baie_id) &&
+          row.enum_type_materiaux_menuiserie_id
+            .split('|')
+            .includes(enum_type_materiaux_menuiserie_id)
+        );
+      })
+      .map((row) => parseFloat(row.ug));
+    uwUgValuesCache.set(cacheKey, values);
+  }
+  return values;
+}
+
 function tv_uw(di, de) {
   const enum_type_baie_id = de.enum_type_baie_id;
   const matcher = { enum_type_baie_id };
@@ -46,16 +77,7 @@ function tv_uw(di, de) {
     matcher.enum_type_materiaux_menuiserie_id = enum_type_materiaux_menuiserie_id;
 
     // Récupération de toutes les valeurs de Ug présentes dans les tables Uw pour le type de baie et matériaux de la baie vitrée
-    const ugValues = tvs.uw
-      .filter((row) => {
-        return (
-          row.enum_type_baie_id.split('|').includes(enum_type_baie_id) &&
-          row.enum_type_materiaux_menuiserie_id
-            .split('|')
-            .includes(enum_type_materiaux_menuiserie_id)
-        );
-      })
-      .map((row) => parseFloat(row.ug));
+    const ugValues = uwUgValues(enum_type_baie_id, enum_type_materiaux_menuiserie_id);
 
     /**
      * 3.3.2 Coefficients Uw des fenêtres / portes-fenêtres

package/3.4_pont_thermique.js

@@ -1,6 +1,6 @@
 import enums from './enums.js';
 import { isNil } from 'lodash-es';
-import { tv, requestInput, compareReferences, bug_for_bug_compat } from './utils.js';
+import { tv, requestInput, cleanReference, bug_for_bug_compat } from './utils.js';
 
 function defaultValue(type_liaison, pt_di, de) {
   if (pt_di.k === 0) {
@@ -115,10 +115,20 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
     }
   }
 
+  /**
+   * Références du pont thermique nettoyées une seule fois : elles sont confrontées à toutes les
+   * parois de plusieurs listes ci-dessous, et `compareReferences` les renettoyait à chaque
+   * comparaison. Les affectations de `de.reference_1` / `de.reference_2` ont toutes eu lieu
+   * au-dessus, dans le bloc de récupération par description.
+   */
+  const cleaned_reference_1 = cleanReference(de.reference_1);
+  const cleaned_reference_2 = cleanReference(de.reference_2);
+
   let mur = mur_list.find((mur, murIndex) => {
+    const cleaned_mur_reference = cleanReference(mur.donnee_entree.reference);
     if (
-      compareReferences(mur.donnee_entree.reference, de.reference_1) ||
-      compareReferences(mur.donnee_entree.reference, de.reference_2)
+      cleaned_mur_reference === cleaned_reference_1 ||
+      cleaned_mur_reference === cleaned_reference_2
     ) {
       return true;
     }
@@ -190,11 +200,10 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
     case 'plancher bas / mur':
     case 'plancher haut lourd / mur': {
       const plancher_list = ph_list.concat(pb_list);
-      const plancher = plancher_list.find(
-        (plancher) =>
-          compareReferences(plancher.donnee_entree.reference, de.reference_1) ||
-          compareReferences(plancher.donnee_entree.reference, de.reference_2)
-      );
+      const plancher = plancher_list.find((plancher) => {
+        const cleaned = cleanReference(plancher.donnee_entree.reference);
+        return cleaned === cleaned_reference_1 || cleaned === cleaned_reference_2;
+      });
       if (!plancher) {
         di.k = defaultValue(type_liaison, pt_di, de);
         console.error(
@@ -331,11 +340,10 @@ function tv_k(pt_di, di, de, du, pc_id, logement) {
       }
 
       const menuiserie_list = bv_list.concat(porte_list);
-      const menuiserie = menuiserie_list.find(
-        (men) =>
-          compareReferences(men.donnee_entree.reference, de.reference_1) ||
-          compareReferences(men.donnee_entree.reference, de.reference_2)
-      );
+      const menuiserie = menuiserie_list.find((men) => {
+        const cleaned = cleanReference(men.donnee_entree.reference);
+        return cleaned === cleaned_reference_1 || cleaned === cleaned_reference_2;
+      });
       if (!menuiserie) {
         di.k = defaultValue(type_liaison, pt_di, de);
         console.error(

package/3.4_pont_thermique.spec.js

@@ -30,7 +30,7 @@ vi.mock('./utils.js', () => ({
   set_bug_for_bug_compat: vi.fn(),
   tv: vi.fn(),
   requestInput: (de, du, field) => de[field],
-  compareReferences: (a, b) => a === b,
+  cleanReference: (reference) => reference,
   get bug_for_bug_compat() {
     return state.bug;
   }

package/3_deperdition.js

@@ -224,7 +224,12 @@ export default function calc_deperdition(cg, zc, th, effetJoule, dpe, Sh) {
   const declaredPontsThermiques = structuredClone(pt_list);
   const vt_list = logement.ventilation_collection.ventilation || [];
 
-  mur_list.forEach((mur) => calc_mur(mur, zc, pc, effetJoule));
+  /**
+   * Version de la méthode appliquée au DPE. Absente des DPE partiels : les calculs qui en
+   * dépendent retombent alors sur le comportement historique.
+   */
+  const versionDpe = parseFloat(dpe.administratif?.enum_version_id);
+  mur_list.forEach((mur) => calc_mur(mur, zc, pc, effetJoule, versionDpe));
   pb_list.forEach((pb) => calc_pb(pb, zc, pc, effetJoule, pb_list));
   ph_list.forEach((ph) => calc_ph(ph, zc, pc, effetJoule));
   bv_list.forEach((bv) => calc_bv(bv, zc));

package/3_deperdition.spec.js

@@ -125,6 +125,7 @@ describe('Upt - déperdition linéique des ponts thermiques', () => {
 
 /** Fabrique un DPE minimal avec une enveloppe pré-calculée. */
 function makeDpe({
+  enum_version_id = '2.4',
   mur = [],
   pb = [],
   ph = [],
@@ -141,6 +142,7 @@ function makeDpe({
   }
   return {
     numero_dpe: 'TEST',
+    administratif: enum_version_id === null ? undefined : { enum_version_id },
     logement: {
       sortie: { deperdition },
       enveloppe: {
@@ -239,6 +241,51 @@ describe("calc_deperdition - agrégation des déperditions de l'enveloppe", () =
     expect(calc_ventilation).toHaveBeenCalledTimes(1);
   });
 
+  /**
+   * Certains calculs de Umur dépendent de la version de la méthode appliquée au DPE
+   * (cumul du doublage avec une isolation ITE/ITI avant la version 2.4).
+   * @see https://github.com/Open3CL/engine/issues/146
+   */
+  describe('version du DPE transmise au calcul des murs', () => {
+    /** @return {object[]} */
+    const murCollection = () => [
+      {
+        donnee_entree: { surface_paroi_opaque: 10, enum_type_adjacence_id: '1' },
+        donnee_intermediaire: { umur: 0.5, b: 1 }
+      }
+    ];
+
+    test.each([
+      ['2.3', 2.3],
+      ['2.4', 2.4],
+      ['2.5', 2.5]
+    ])('enum_version_id "%s" transmis à calc_mur', (enum_version_id, expected) => {
+      const dpe = makeDpe({
+        enum_version_id,
+        mur: murCollection(),
+        ventilation: [{ donnee_intermediaire: { hvent: 0, hperm: 0 } }],
+        deperdition_mur: 5
+      });
+
+      calc_deperdition({ enum_periode_construction_id: '1' }, 'h1a', 'th', '0', dpe, 100);
+
+      expect(calc_mur).toHaveBeenCalledWith(expect.anything(), 'h1a', '1', '0', expected);
+    });
+
+    test('bloc administratif absent : calc_mur reçoit NaN et conserve le comportement historique', () => {
+      const dpe = makeDpe({
+        enum_version_id: null,
+        mur: murCollection(),
+        ventilation: [{ donnee_intermediaire: { hvent: 0, hperm: 0 } }],
+        deperdition_mur: 5
+      });
+
+      calc_deperdition({ enum_periode_construction_id: '1' }, 'h1a', 'th', '0', dpe, 100);
+
+      expect(calc_mur).toHaveBeenCalledWith(expect.anything(), 'h1a', '1', '0', NaN);
+    });
+  });
+
   /**
    * calc_Sdep (surface déperditive transmise à la ventilation) exclut les parois à coefficient
    * b nul et les parois adjacentes à un local non déperditif. Les parois à déperdition nulle

package/README.md

@@ -385,32 +385,62 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.6.2`** · branche `main` · généré le 2026-09-11
+> **Version `1.6.2`** · branche `pr-174` · généré le 2026-09-20
 > Seuil de tolérance **5%**
 
 <table>
 <tr>
 <td align="center"><strong>9</strong><br/><sub>corpus</sub></td>
 <td align="center"><strong>89 996</strong><br/><sub>DPE analysés</sub></td>
-<td align="center"><strong>59 497</strong><br/><sub>DPE conformes</sub></td>
-<td align="center"><strong>66,11 %</strong><br/><sub>réussite globale</sub></td>
+<td align="center"><strong>59 522</strong><br/><sub>DPE conformes</sub></td>
+<td align="center"><strong>66,14 %</strong><br/><sub>réussite globale</sub></td>
 </tr>
 </table>
 
 |     | Corpus                                                                                                                  |    Réussite |                        |  DPE conformes |
 | :-: | :---------------------------------------------------------------------------------------------------------------------- | ----------: | :--------------------- | -------------: |
 | 🔴  | **Généraliste**<br/><sub>`corpus_dpe.csv`</sub>                                                                         | **45,97 %** | `█████████░░░░░░░░░░░` | 4 597 / 10 000 |
-| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **91,55 %** | `██████████████████░░` | 9 155 / 10 000 |
-| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **88,14 %** | `██████████████████░░` |  8 812 / 9 998 |
-| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **87,93 %** | `██████████████████░░` | 8 793 / 10 000 |
-| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **73,76 %** | `███████████████░░░░░` |  7 375 / 9 999 |
-| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **69,47 %** | `██████████████░░░░░░` | 6 947 / 10 000 |
-| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,27 %** | `████████████░░░░░░░░` |  6 226 / 9 999 |
-| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **48,37 %** | `██████████░░░░░░░░░░` | 4 837 / 10 000 |
+| 🟢  | **Appartement · chauffage individuel (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_individuel_2025.csv`</sub> | **91,62 %** | `██████████████████░░` | 9 162 / 10 000 |
+| 🟢  | **Logement individuel (2025)**<br/><sub>`dpe_logement_individuel_2025.csv`</sub>                                        | **88,16 %** | `██████████████████░░` |  8 814 / 9 998 |
+| 🟢  | **Maison individuelle (2025)**<br/><sub>`dpe_maison_individuelle_2025.csv`</sub>                                        | **87,99 %** | `██████████████████░░` | 8 799 / 10 000 |
+| 🟡  | **Immeuble · chauffage individuel**<br/><sub>`dpe_immeuble_chauffage_individuel.csv`</sub>                              | **73,78 %** | `███████████████░░░░░` |  7 377 / 9 999 |
+| 🟡  | **Appartement · chauffage collectif (2025)**<br/><sub>`dpe_appartement_individuel_chauffage_collectif_2025.csv`</sub>   | **69,51 %** | `██████████████░░░░░░` | 6 951 / 10 000 |
+| 🟡  | **Immeuble · chauffage collectif**<br/><sub>`dpe_immeuble_chauffage_collectif.csv`</sub>                                | **62,30 %** | `████████████░░░░░░░░` |  6 229 / 9 999 |
+| 🔴  | **Immeuble · chauffage mixte**<br/><sub>`dpe_immeuble_chauffage_mixte.csv`</sub>                                        | **48,38 %** | `██████████░░░░░░░░░░` | 4 838 / 10 000 |
 | 🔴  | **Individuel généré depuis l'immeuble (2026)**<br/><sub>`dpe_individuel_a_partir_dpe_immeuble_2026.csv`</sub>           | **27,55 %** | `██████░░░░░░░░░░░░░░` | 2 755 / 10 000 |
 
 <sub>🟢 ≥ 85 % · 🟡 ≥ 60 % · 🔴 < 60 %</sub>
 
+#### Temps d’exécution
+
+> Durée de l’appel à `calcul_3cl` par DPE, sur 89 956 calculs.
+> La copie défensive de l’entrée et la lecture du fichier sont exclues de la mesure.
+
+<table>
+<tr>
+<td align="center"><strong>5,23 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,61 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>0,10 ms</strong><br/><sub>min</sub></td>
+<td align="center"><strong>577,0 ms</strong><br/><sub>max</sub></td>
+</tr>
+</table>
+
+| Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
+| :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
+| **Généraliste**                                | 4,37 ms | 3,96 ms | 0,22 ms |  35,5 ms | 7,93 ms | 10,8 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,49 ms | 3,20 ms | 1,13 ms |  30,2 ms | 6,09 ms | 7,79 ms |
+| **Logement individuel (2025)**                 | 4,96 ms | 4,38 ms | 1,34 ms |  43,1 ms | 9,48 ms | 12,9 ms |
+| **Maison individuelle (2025)**                 | 5,88 ms | 5,34 ms | 1,68 ms |  47,0 ms | 10,5 ms | 14,2 ms |
+| **Immeuble · chauffage individuel**            | 6,66 ms | 5,73 ms | 0,10 ms |  83,7 ms | 13,6 ms | 21,0 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,09 ms | 3,75 ms | 1,26 ms |  37,7 ms | 6,88 ms | 9,51 ms |
+| **Immeuble · chauffage collectif**             | 6,04 ms | 5,23 ms | 0,15 ms | 148,9 ms | 11,5 ms | 21,3 ms |
+| **Immeuble · chauffage mixte**                 | 5,79 ms | 4,77 ms | 0,18 ms | 577,0 ms | 12,4 ms | 20,2 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,82 ms | 5,08 ms | 1,65 ms |  71,8 ms | 11,1 ms | 16,9 ms |
+
+<sub>La moyenne est tirée vers le haut par les DPE collectifs, dont le coût atteint plusieurs
+dizaines de fois la médiane : c’est la médiane qui décrit le cas courant, et p95/p99 le cas
+défavorable réel.</sub>
+
 <!-- CORPUS:END -->
 
 📈 Historique complet des versions : [docs/CORPUS-HISTORY.md](docs/CORPUS-HISTORY.md)

package/engine.js

@@ -33,7 +33,7 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 
-const LIB_VERSION = '1.7.1';
+const LIB_VERSION = '1.7.3';
 
 const dpeSanitizerService = new DpeSanitizerService();