@open3cl/engine 1.11.1 → 1.11.3

package/3.3_baie_vitree.spec.js

@@ -234,6 +234,16 @@ describe('tv_uw - coefficient de transmission de la fenêtre', () => {
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Pas de valeur forfaitaire uw'));
   });
 
+  test('Ug exactement tabulé sans ligne uw : uw indéfini et erreur émise', () => {
+    // delta_ug = 0 (bornes identiques) mais aucune ligne uw pour ce Ug
+    rows.uw = null;
+    const bv = baseBv();
+    calc_bv(bv, 1);
+
+    expect(bv.donnee_intermediaire.uw).toBeUndefined();
+    expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Pas de valeur forfaitaire uw'));
+  });
+
   test('interpolation entre deux Ug tabulés (delta_ug ≠ 0)', () => {
     rows.ug = { ug: '3', tv_ug_id: '5' };
     getRange.mockReturnValue([2.8, 4]);

package/3.4_pont_thermique.spec.js

@@ -810,6 +810,33 @@ describe('calc_pont_thermique - récupération du mur via la baie vitrée (compa
     expect(errorSpy).toHaveBeenCalled();
   });
 
+  test('hors compatibilité bug : la baie vitrée n’est pas consultée pour retrouver le mur', () => {
+    state.bug = false;
+    tv.mockReturnValue({ k: '0.5', tv_pont_thermique_id: '42' });
+    const mur = [
+      {
+        donnee_entree: { reference: 'M1', enum_type_adjacence_id: '1', type_isolation: 'iti' },
+        donnee_utilisateur: {}
+      }
+    ];
+    // Même configuration que le cas bug_for_bug : reference_paroi = index du mur (0)
+    const bv = [{ donnee_entree: { reference: 'BV1', reference_paroi: '0' } }];
+    const pt = pontThermique({
+      type_liaison: 'refend / mur',
+      reference_1: 'BV1',
+      description: 'refend'
+    });
+
+    calc_pont_thermique(pt, '1', logement({ mur, bv }));
+
+    // Mur non retrouvé via la baie : isolation ITI par défaut, aucun message de récupération
+    expect(tv).toHaveBeenCalledWith('pont_thermique', {
+      enum_type_liaison_id: '12',
+      isolation_mur: '^iti'
+    });
+    expect(errorSpy).not.toHaveBeenCalledWith(expect.stringContaining('Aucun mur trouvé'));
+  });
+
   test('reference_paroi ne correspondant pas à l’index du mur : aucun mur retrouvé (isolation ITI par défaut)', () => {
     state.bug = true;
     tv.mockReturnValue({ k: '0.5', tv_pont_thermique_id: '42' });

package/4_ventilation.spec.js

@@ -146,6 +146,18 @@ describe('calc_ventilation - orchestration', () => {
     );
   });
 
+  test('surface ventilée égale à Sh : conservée sans application de clé de répartition', () => {
+    const vt = ventilation({
+      surface_ventile: 100,
+      cle_repartition_ventilation: 2,
+      q4pa_conv_saisi: 1.3
+    });
+    calc_ventilation(vt, CG, 'th', 80, 100, [], [], [], []);
+
+    // surface_ventile = Sh = 100 (clé ignorée) => Hvent = 0,34 * 1,2 * 100
+    expect(vt.donnee_intermediaire.hvent).toBeCloseTo(40.8, 9);
+  });
+
   test('surface ventilée différente de Sh sans clé de répartition : divisée par 1', () => {
     // Branche `de.cle_repartition_ventilation || 1` : surface_ventile conservée telle quelle
     const vt = ventilation({ surface_ventile: 50, q4pa_conv_saisi: 1.3 });

package/7_inertie.spec.js

@@ -54,6 +54,16 @@ describe('Inertie unit tests', () => {
     }
   );
 
+  test('plancher haut non lourd (type 9) isolé par ITE ou non isolé : inertie 0', () => {
+    expect(
+      inertie.calculateInertiePhLourd({ enum_type_isolation_id: 2, enum_type_plancher_haut_id: 9 })
+    ).toBe(0);
+  });
+
+  test('type de plancher haut inconnu avec isolation ITE : considéré lourd, inertie 1', () => {
+    expect(inertie.calculateInertiePhLourd({ enum_type_isolation_id: 4 })).toBe(1);
+  });
+
   test.each([
     [1, 1, 0, 2, 0],
     [1, 1, 0, 3, 0],

package/9_besoin_ch.spec.js

@@ -93,6 +93,10 @@ describe('calc_Fj - fraction des besoins de chauffage couverte par les apports',
     expect(lourde).not.toBeCloseTo(legere, 9);
   });
 
+  test('une inertie inconnue ne définit pas alpha : le résultat n’est pas un nombre', () => {
+    expect(calc_Fj(100, 2000, 5000, 1000, 'inconnue')).toBeNaN();
+  });
+
   test('les inerties "très lourde" et "lourde" partagent le même alpha', () => {
     expect(calc_Fj(100, 2000, 5000, 1000, 'très lourde')).toBeCloseTo(
       calc_Fj(100, 2000, 5000, 1000, 'lourde'),

package/9_conso_ch.js

@@ -289,7 +289,7 @@ function calc_ch_base_appoint(
 
     di.conso_ch = 0;
     for (const mois of mois_liste) {
-      let bch_base_j = 0;
+      let bch_base_j;
 
       if (pe > 0) {
         // Nombre d’heures de chauffage sur le mois j

package/9_emetteur_ch.spec.js

@@ -23,7 +23,9 @@ vi.mock('./utils.js', () => ({
 }));
 
 vi.mock('./core/tv/infrastructure/tvs.store.js', () => ({
-  TvsStore: vi.fn(() => mockTvsStore)
+  TvsStore: vi.fn(function () {
+    return mockTvsStore;
+  })
 }));
 
 const { rendement_emission, calc_emetteur_ch, isIntermittenceCollectiveSaisie } =

package/9_generateur_ch.spec.js

@@ -342,6 +342,17 @@ describe('checkForGeneratorType - classification du générateur', () => {
     expect(de.enum_type_generateur_ch_id).toBe('119');
   });
 
+  test('cas 119 par défaut avec ligne de rendement sans type de générateur : aucune réécriture', () => {
+    vi.mocked(requestInputID).mockReturnValue('119');
+    vi.mocked(tv).mockReturnValue({ enum_type_generateur_ch_id: undefined });
+    const de = { tv_rendement_generation_id: 3, enum_type_generateur_ch_id: '119' };
+    const du = {};
+    checkForGeneratorType({}, de, {}, du);
+    expect(de.enum_type_generateur_ch_id).toBe('119');
+    expect(du.isPacGenerator).toBe(false);
+    expect(du.isCombustionGenerator).toBe(false);
+  });
+
   /**
    * Chaudière fioul par défaut : chaudière standard datant de la construction du bâtiment.
    * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §17.2.1.1

package/README.md

@@ -383,7 +383,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.10.0`** · branche `main` · généré le 2026-10-29
+> **Version `1.11.2`** · à publier · branche `main` · généré le 2026-10-30
 > Seuil de tolérance **5%**
 
 <table>
@@ -416,24 +416,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,64 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,87 ms</strong><br/><sub>médiane</sub></td>
+<td align="center"><strong>5,99 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>5,23 ms</strong><br/><sub>médiane</sub></td>
 <td align="center"><strong>0,11 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>957,0 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>641,5 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Appartement · chauffage individuel (2025)**  | 4,00 ms | 3,58 ms | 1,42 ms |  34,6 ms | 6,99 ms | 9,30 ms |
-| **Appartement · chauffage collectif (2025)**   | 4,46 ms | 4,04 ms | 1,62 ms |  42,4 ms | 7,33 ms | 9,33 ms |
-| **Logement individuel (2025)**                 | 5,20 ms | 4,57 ms | 1,74 ms |  56,0 ms | 9,72 ms | 13,5 ms |
-| **Maison individuelle (2025)**                 | 6,01 ms | 5,41 ms | 2,04 ms |  51,8 ms | 10,7 ms | 14,3 ms |
-| **Maison individuelle (2026)**                 | 6,16 ms | 5,47 ms | 2,09 ms |  46,7 ms | 11,1 ms | 15,1 ms |
-| **Immeuble · chauffage collectif**             | 5,81 ms | 4,91 ms | 0,14 ms | 126,7 ms | 10,9 ms | 17,7 ms |
-| **Immeuble · chauffage individuel**            | 7,07 ms | 5,99 ms | 0,11 ms | 123,4 ms | 14,5 ms | 22,6 ms |
-| **Immeuble · chauffage mixte**                 | 5,73 ms | 4,63 ms | 0,20 ms | 957,0 ms | 11,9 ms | 19,7 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 6,33 ms | 5,26 ms | 1,79 ms |  79,2 ms | 12,0 ms | 19,1 ms |
+| **Appartement · chauffage individuel (2025)**  | 4,09 ms | 3,70 ms | 1,56 ms |  47,5 ms | 7,05 ms | 9,52 ms |
+| **Appartement · chauffage collectif (2025)**   | 4,98 ms | 4,64 ms | 1,66 ms |  41,1 ms | 8,18 ms | 10,7 ms |
+| **Logement individuel (2025)**                 | 5,36 ms | 4,70 ms | 1,75 ms |  61,9 ms | 10,0 ms | 14,0 ms |
+| **Maison individuelle (2025)**                 | 6,37 ms | 5,70 ms | 1,93 ms |  58,0 ms | 11,5 ms | 15,4 ms |
+| **Maison individuelle (2026)**                 | 6,43 ms | 5,76 ms | 2,16 ms |  48,3 ms | 11,7 ms | 15,7 ms |
+| **Immeuble · chauffage collectif**             | 5,75 ms | 4,90 ms | 0,11 ms | 102,7 ms | 10,6 ms | 17,6 ms |
+| **Immeuble · chauffage individuel**            | 7,49 ms | 6,40 ms | 0,11 ms | 127,0 ms | 15,3 ms | 23,9 ms |
+| **Immeuble · chauffage mixte**                 | 6,57 ms | 5,44 ms | 0,19 ms | 641,5 ms | 13,8 ms | 23,4 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 6,88 ms | 5,83 ms | 1,86 ms |  79,6 ms | 12,9 ms | 21,8 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

package/apport_et_besoin.spec.js

@@ -22,7 +22,11 @@ vi.mock('./6.2_surface_sud_equivalente.js', () => ({ calc_sse: vi.fn() }));
 vi.mock('./10_besoin_fr.js', () => ({ default: vi.fn() }));
 vi.mock('./11_besoin_ecs.js', () => ({ default: vi.fn() }));
 vi.mock('./6.1_apport_gratuit.js', () => ({ calc_ai: vi.fn(), calc_as: vi.fn() }));
-vi.mock('./11_nadeq.js', () => ({ Nadeq: vi.fn(() => ({ calculateNadeq })) }));
+vi.mock('./11_nadeq.js', () => ({
+  Nadeq: vi.fn(function () {
+    return { calculateNadeq };
+  })
+}));
 
 const { default: calc_apport_et_besoin } = await import('./apport_et_besoin.js');
 const { calc_sse } = await import('./6.2_surface_sud_equivalente.js');

package/core/assets/domain/add-additionnal-ue-values-tables.js

@@ -4,25 +4,6 @@ import { UPB_ADDITIONAL_VALUES } from '../../tv/infrastructure/assets/additional
  * Add additional values for ue
  */
 export class AddAdditionnalUeValuesTables {
-  /**
-   * @type {FileStore}
-   */
-  #fileStore;
-
-  /**
-   * @type {ApplicationConfig}
-   */
-  #appConfig;
-
-  /**
-   * @param fileStore {FileStore}
-   * @param appConfig {ApplicationConfig}
-   */
-  constructor(fileStore, appConfig) {
-    this.#fileStore = fileStore;
-    this.#appConfig = appConfig;
-  }
-
   /**
    * Ajout de valeurs supplémentaires pour le calcul du facteur Ue pour les déperditions plancher_bas
    * @param tableValues

package/core/assets/domain/add-additionnal-ue-values-tables.spec.js

@@ -3,12 +3,11 @@ import { AddAdditionnalUeValuesTables } from './add-additionnal-ue-values-tables
 import { UPB_ADDITIONAL_VALUES } from '../../tv/infrastructure/assets/additional-ue-values.js';
 
 /**
- * `execute` n'utilise ni le fileStore ni l'appConfig : on les passe en doubles
- * vides pour isoler la logique d'aplatissement des valeurs Ue additionnelles
- * dans la table `ue`.
+ * Le service n'a aucune dépendance : on vérifie la logique d'aplatissement des
+ * valeurs Ue additionnelles dans la table `ue`.
  */
 describe('AddAdditionnalUeValuesTables', () => {
-  const buildService = () => new AddAdditionnalUeValuesTables({}, {});
+  const buildService = () => new AddAdditionnalUeValuesTables();
 
   test('ajoute toutes les valeurs additionnelles dans la table ue', () => {
     const nbAttendu = UPB_ADDITIONAL_VALUES.reduce((acc, entree) => acc + entree.values.length, 0);

package/core/assets/domain/synchronize-dpe-ges-limit-values-tables.spec.js

@@ -69,4 +69,29 @@ describe('SynchronizeDpeGesLimitValuesTables unit tests', () => {
       });
     });
   });
+  test('regroupe plusieurs surfaces sous une même classe d’altitude', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+
+    vi.spyOn(fileStore, 'readLocalOdsFileAndConvertToJson').mockResolvedValue({
+      dpe_class_limit: [
+        { classe_altitude: '400-800m', surface: '10', A: '124' },
+        { classe_altitude: '400-800m', surface: '20', A: '100' }
+      ]
+    });
+    vi.spyOn(ApplicationConfig.prototype, 'solicitationsExtFilePath', 'get').mockReturnValue(
+      'src/file.ods'
+    );
+
+    return synchronizeDpeGesLimitValuesTables.execute().then((output) => {
+      // Le groupe d'altitude n'est créé qu'une fois : la 1ʳᵉ surface n'est pas écrasée
+      expect(output).toStrictEqual({
+        dpe_class_limit: { '400-800m': { 10: { A: 124 }, 20: { A: 100 } } }
+      });
+    });
+  });
 });

package/core/assets/domain/synchronize-valeur-tables.spec.js

@@ -99,4 +99,47 @@ describe('SynchronizeValeurTables unit tests', () => {
       expect(contenu).toContain('valeurs-ue-completees');
     });
   });
+  test('force isolation_surfaces à "0" uniquement lorsque la valeur est absente dans q4pa_conv', () => {
+    const fileStore = new FileStore();
+    const appConfig = new ApplicationConfig();
+    const synchronizeC1Tables = new SynchronizeC1Tables(fileStore, appConfig);
+    const synchronizeSolicitationTables = new SynchronizeSolicitationsTables(fileStore, appConfig);
+    const synchronizeDpeGesLimitValuesTables = new SynchronizeDpeGesLimitValuesTables(
+      fileStore,
+      appConfig
+    );
+    const addAdditionnalUeValuesTables = new AddAdditionnalUeValuesTables(fileStore, appConfig);
+    const synchronizeValeurTables = new SynchronizeValeurTables(
+      fileStore,
+      appConfig,
+      synchronizeSolicitationTables,
+      synchronizeDpeGesLimitValuesTables,
+      addAdditionnalUeValuesTables,
+      synchronizeC1Tables
+    );
+
+    vi.spyOn(ApplicationConfig.prototype, 'ademeValeurTablesFileUrl', 'get').mockReturnValue(
+      'http://localhost/file.xlsx'
+    );
+    vi.spyOn(ApplicationConfig.prototype, 'assetsOutputFolder', 'get').mockReturnValue(
+      'src/assets'
+    );
+
+    // Le parsing Excel ignore les valeurs à 0 : la 1ʳᵉ ligne n'a pas de isolation_surfaces,
+    // la 2ᵉ en possède déjà une qui doit être conservée.
+    vi.spyOn(fileStore, 'downloadXlsxFileAndConvertToJson').mockResolvedValue({
+      q4pa_conv: [{ q4pa_conv: 'a' }, { q4pa_conv: 'b', isolation_surfaces: 'oui' }]
+    });
+    vi.spyOn(fileStore, 'writeFileToLocalSystem').mockResolvedValue(null);
+    vi.spyOn(synchronizeC1Tables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeSolicitationTables, 'execute').mockResolvedValue({});
+    vi.spyOn(synchronizeDpeGesLimitValuesTables, 'execute').mockResolvedValue({});
+    vi.spyOn(addAdditionnalUeValuesTables, 'execute').mockResolvedValue({});
+
+    return synchronizeValeurTables.execute().then(() => {
+      const contenu = vi.mocked(fileStore.writeFileToLocalSystem).mock.calls[0][1];
+      const tvs = JSON.parse(contenu.match(/tvs = (\{[\s\S]*\});\n export/)[1]);
+      expect(tvs.q4pa_conv.map((l) => l.isolation_surfaces)).toEqual(['0', 'oui']);
+    });
+  });
 });

package/core/util/logger/log-service.spec.js

@@ -58,6 +58,17 @@ describe('Service de logs (log-service)', () => {
     expect(console.error).toBe(consoleOrigine.error);
   });
 
+  test('setLoggerOn sans option conserve console.error neutralisé', () => {
+    setLoggerOff(true);
+    const erreurNeutralisee = console.error;
+    setLoggerOn();
+
+    expect(logger.silent).toBe(false);
+    expect(console.log).toBe(consoleOrigine.log);
+    expect(console.error).toBe(erreurNeutralisee);
+    expect(console.error).not.toBe(consoleOrigine.error);
+  });
+
   test('les méthodes console neutralisées sont des fonctions no-op', () => {
     setLoggerOff();
 

package/dpe-sanitizer.service.spec.js

@@ -77,6 +77,15 @@ describe('DpeSanitizerService.execute - collections manquantes', () => {
   });
 });
 
+describe('DpeSanitizerService - transformation des clés', () => {
+  test('conserve les clés inchangées (transformation identité)', () => {
+    vi.mocked(has).mockReturnValue(true);
+    service.execute({});
+    const keyTransform = vi.mocked(ObjectUtil.deepObjectTransform).mock.calls[0][1];
+    expect(keyTransform('generateur_ecs')).toBe('generateur_ecs');
+  });
+});
+
 /**
  * Récupère la fonction de transformation des valeurs passée en 3e argument de
  * `deepObjectTransform` après un appel à `execute`.

package/engine.js

@@ -34,9 +34,12 @@ import getFicheTechnique from './ficheTechnique.js';
 import { ProductionENR, ratioProrataPvLogement } from './16.2_production_enr.js';
 import DpeSanitizerService from './dpe-sanitizer.service.js';
 import { reconstituerRdimDpeGenereImmeuble } from './17.2_rdim_dpe_genere_immeuble.js';
-import { reconstituerRdimEcsIndividuelleUnique } from './11_rdim_ecs_individuelle_unique.js';
+import {
+  reconstituerRdimEcsIndividuelleUnique,
+  reconstituerRdimEcsIndividuellesMultiples
+} from './11_rdim_ecs_individuelle_unique.js';
 
-const LIB_VERSION = '1.11.1';
+const LIB_VERSION = '1.11.3';
 
 const dpeSanitizerService = new DpeSanitizerService();
 
@@ -305,6 +308,11 @@ export function calcul_3cl(inputDpe, options) {
    * @see https://github.com/Open3CL/engine/issues/288
    */
   reconstituerRdimEcsIndividuelleUnique(th, ecs, cg.surface_habitable_immeuble);
+  /**
+   * Immeuble avec plusieurs installations ECS individuelles décrites chacune pour un logement type
+   * (Σ Sh_i × nombre_logement_i ≈ SH, sans rdim) : rdim_i = nombre_logement_i.
+   */
+  reconstituerRdimEcsIndividuellesMultiples(th, ecs, cg.surface_habitable_immeuble);
   const Nb_lgt = cg.nombre_appartement || 1;
 
   /**

package/engine.spec.js

@@ -75,7 +75,8 @@ vi.mock('./17.2_rdim_dpe_genere_immeuble.js', () => ({
   reconstituerRdimDpeGenereImmeuble: vi.fn()
 }));
 vi.mock('./11_rdim_ecs_individuelle_unique.js', () => ({
-  reconstituerRdimEcsIndividuelleUnique: vi.fn()
+  reconstituerRdimEcsIndividuelleUnique: vi.fn(),
+  reconstituerRdimEcsIndividuellesMultiples: vi.fn()
 }));
 
 // Les instances Inertie / ProductionENR sont créées au chargement du module.
@@ -83,9 +84,15 @@ vi.mock('./11_rdim_ecs_individuelle_unique.js', () => ({
 const calculateInertie = vi.fn();
 const calculateEnr = vi.fn();
 const ratioProrataPvLogement = vi.fn();
-vi.mock('./7_inertie.js', () => ({ Inertie: vi.fn(() => ({ calculateInertie })) }));
+vi.mock('./7_inertie.js', () => ({
+  Inertie: vi.fn(function () {
+    return { calculateInertie };
+  })
+}));
 vi.mock('./16.2_production_enr.js', () => ({
-  ProductionENR: vi.fn(() => ({ calculateEnr })),
+  ProductionENR: vi.fn(function () {
+    return { calculateEnr };
+  }),
   ratioProrataPvLogement: (...args) => ratioProrataPvLogement(...args)
 }));
 
@@ -93,7 +100,9 @@ vi.mock('./16.2_production_enr.js', () => ({
 // renvoie l'entrée telle quelle.
 const sanitizeExecute = vi.fn((dpe) => dpe);
 vi.mock('./dpe-sanitizer.service.js', () => ({
-  default: vi.fn(() => ({ execute: sanitizeExecute }))
+  default: vi.fn(function () {
+    return { execute: sanitizeExecute };
+  })
 }));
 
 const { getVersion, get_conso_coeff_1_7_2027, get_classe_ges_dpe, calcul_3cl, calcul_3cl_xml } =
@@ -121,7 +130,7 @@ const calc_confort_ete = (await import('./2021_04_13_confort_ete.js')).default;
 const calc_qualite_isolation = (await import('./2021_04_13_qualite_isolation.js')).default;
 const getFicheTechnique = (await import('./ficheTechnique.js')).default;
 const { reconstituerRdimDpeGenereImmeuble } = await import('./17.2_rdim_dpe_genere_immeuble.js');
-const { reconstituerRdimEcsIndividuelleUnique } =
+const { reconstituerRdimEcsIndividuelleUnique, reconstituerRdimEcsIndividuellesMultiples } =
   await import('./11_rdim_ecs_individuelle_unique.js');
 
 /** Objet conso renvoyé par le mock de `calc_conso` (mêmes réf pour les 3 appels). */
@@ -650,6 +659,20 @@ describe('calcul_3cl - collections vidables (poursuite du calcul)', () => {
 });
 
 describe('calcul_3cl - surfaces immeuble / appartement et prorata', () => {
+  test('méthode application inconnue : surface habitable indéterminée transmise à la déperdition', () => {
+    enums.methode_application_dpe_log = { 1: 'méthode farfelue' };
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    const dpe = makeDpe();
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    // th null => aucune surface retenue (ni logement ni immeuble)
+    expect(calc_deperdition.mock.calls[0][2]).toBeNull();
+    expect(calc_deperdition.mock.calls[0][5]).toBeUndefined();
+    expect(errSpy).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
+
   test('immeuble : Sh = surface immeuble ; ECS collective individualisée non divisée', () => {
     enums.methode_application_dpe_log = { 1: 'dpe immeuble collectif' };
     const dpe = makeDpe();
@@ -1304,6 +1327,26 @@ describe('calcul_3cl - rdim de l’installation ECS individuelle unique d’un i
   });
 });
 
+describe('calcul_3cl - rdim des installations ECS individuelles multiples d’un immeuble', () => {
+  test('reconstitution appelée avec le type de bâtiment, les installations ECS et SH, avant le calcul ECS', () => {
+    const dpe = makeDpe();
+    dpe.logement.caracteristique_generale.surface_habitable_immeuble = 566.16;
+    vi.mocked(reconstituerRdimEcsIndividuellesMultiples).mockImplementationOnce(() => {
+      expect(calc_ecs).not.toHaveBeenCalled();
+      return false;
+    });
+
+    calcul_3cl(dpe, { sanitize: false });
+
+    expect(reconstituerRdimEcsIndividuellesMultiples).toHaveBeenCalledWith(
+      'maison',
+      dpe.logement.installation_ecs_collection.installation_ecs,
+      566.16
+    );
+    expect(calc_ecs).toHaveBeenCalled();
+  });
+});
+
 describe('get_conso_coeff_1_7_2027', () => {
   test('projette la conso EP 2027 pour une maison', () => {
     vi.mocked(classe_bilan_dpe).mockReturnValue('C');
@@ -1340,4 +1383,22 @@ describe('get_conso_coeff_1_7_2027', () => {
     expect(res.ep_conso_5_usages_2027).toBeCloseTo(ep, 6);
     expect(classe_bilan_dpe).toHaveBeenCalledWith(Math.floor(ep / 200), 'zc1', 'ca1', 200);
   });
+
+  test('méthode application inconnue : surface indéterminée, aucune surface ne lui est substituée', () => {
+    enums.methode_application_dpe_log = { 1: 'méthode farfelue' };
+    const errSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+    vi.mocked(classe_bilan_dpe).mockReturnValue('G');
+    const dpe = makeDpe();
+    dpe.logement.sortie = {
+      ep_conso: { ep_conso_5_usages: 10000 },
+      ef_conso: { conso_5_usages: 6000 }
+    };
+
+    get_conso_coeff_1_7_2027(dpe);
+
+    // th null => ni surface logement ni surface immeuble
+    expect(classe_bilan_dpe.mock.calls[0][3]).toBeUndefined();
+    expect(errSpy).toHaveBeenCalled();
+    errSpy.mockRestore();
+  });
 });

package/features/dpe/domain/models/baie-ets.model.ts

@@ -1,12 +1,9 @@
-import { DE } from './dpe.model';
+// Alias des types générés depuis le XSD DPE (voir dpe-xsd.generated.ts). Les extensions propres
+// à Open3CL se déclarent ici (hors fichier généré) pour survivre à la régénération.
+import type {
+  XsdLogementEnveloppeEtsBaieEts,
+  XsdLogementEnveloppeEtsBaieEtsDonneeEntree
+} from './dpe-xsd.generated';
 
-export interface BaieEts {
-  donnee_entree?: BaieEtsDE;
-}
-
-export interface BaieEtsDE extends DE {
-  enum_orientation_id?: number;
-  enum_inclinaison_vitrage_id?: number; // ENUM inclinaison_vitrage
-  surface_totale_baie?: number;
-  nb_baie?: number;
-}
+export type BaieEts = XsdLogementEnveloppeEtsBaieEts;
+export type BaieEtsDE = XsdLogementEnveloppeEtsBaieEtsDonneeEntree;

package/features/dpe/domain/models/baie-vitree.model.ts

@@ -1,97 +1,25 @@
-import { DE } from './dpe.model';
+// Alias des types générés depuis le XSD DPE (voir dpe-xsd.generated.ts). Les extensions propres
+// à Open3CL se déclarent ici (hors fichier généré) pour survivre à la régénération.
+import type {
+  XsdLogementEnveloppeBaieVitree,
+  XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetre,
+  XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetreDonneeEntree,
+  XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetreDonneeIntermediaire,
+  XsdLogementEnveloppeBaieVitreeDonneeEntree,
+  XsdLogementEnveloppeBaieVitreeDonneeEntreeMasqueLointainNonHomogene,
+  XsdLogementEnveloppeBaieVitreeDonneeIntermediaire
+} from './dpe-xsd.generated';
 
-export interface BaieVitree {
-  donnee_entree?: BaieVitreeDE;
-  donnee_intermediaire?: BaieVitreeDI;
-  baie_vitree_double_fenetre?: BaieVitreeDoubleFenetre;
-}
-
-export interface BaieVitreeDE extends DE {
-  reference_paroi?: string;
-  reference_lnc?: string;
-  tv_coef_reduction_deperdition_id?: string; // TV
-  surface_aiu?: number;
-  surface_aue?: number;
-  enum_cfg_isolation_lnc_id?: string; // ENUM cfg_isolation_lnc
-  enum_type_adjacence_id?: string; // ENUM type_adjacence
-  surface_totale_baie?: number;
-  nb_baie?: number;
-  tv_ug_id?: string; // TV
-  enum_type_vitrage_id?: string; // ENUM type_vitrage
-  enum_inclinaison_vitrage_id?: string; // ENUM inclinaison_vitrage
-  enum_type_gaz_lame_id?: string; // ENUM type_gaz_lame
-  epaisseur_lame?: number;
-  vitrage_vir?: boolean;
-  enum_methode_saisie_perf_vitrage_id?: string; // ENUM methode_saisie_perf_vitrage
-  ug_saisi?: number;
-  tv_uw_id?: string;
-  enum_type_materiaux_menuiserie_id?: string; // ENUM type_materiaux_menuiserie
-  enum_type_baie_id?: string; // ENUM type_baie
-  uw_saisi?: number;
-  double_fenetre?: number;
-  uw_1?: number;
-  sw_1?: number;
-  uw_2?: number;
-  sw_2?: number;
-  tv_deltar_id?: string;
-  tv_ujn_id?: string;
-  enum_type_fermeture_id?: string;
-  presence_protection_solaire_hors_fermeture?: boolean;
-  ujn_saisi?: number;
-  presence_retour_isolation?: boolean;
-  presence_joint?: boolean;
-  largeur_dormant?: number;
-  tv_sw_id?: string;
-  sw_saisi?: number;
-  enum_type_pose_id?: string; // ENUM type_pose
-  enum_orientation_id?: string;
-  tv_coef_masque_proche_id?: number;
-  tv_coef_masque_lointain_homogene_id?: number;
-  masque_lointain_non_homogene_collection: {
-    masque_lointain_non_homogene: MasqueLointainNonHomogene;
-  }[];
-}
-
-export interface BaieVitreeDI {
-  b: number;
-  ug?: number;
-  uw: number;
-  ujn?: number;
-  u_menuiserie: number;
-  sw: number;
-  fe1: number;
-  fe2: number;
-}
-
-export interface BaieVitreeDoubleFenetre {
-  donnee_entree?: BaieVitreeDoubleFenetreDE;
-  donnee_intermediaire?: BaieVitreeDoubleFenetreDI;
-}
-
-export interface BaieVitreeDoubleFenetreDE {
-  tv_ug_id?: string;
-  enum_type_vitrage_id: string;
-  enum_inclinaison_vitrage_id: string;
-  enum_type_gaz_lame_id?: string;
-  epaisseur_lame?: number;
-  vitrage_vir?: boolean;
-  enum_methode_saisie_perf_vitrage_id: string;
-  ug_saisi?: number;
-  tv_uw_id?: string;
-  enum_type_materiaux_menuiserie_id: string;
-  enum_type_baie_id: string;
-  uw_saisi?: number;
-  tv_sw_id?: string;
-  sw_saisi?: number;
-  enum_type_pose_id: string;
-}
-
-export interface BaieVitreeDoubleFenetreDI {
-  ug?: number;
-  uw: number;
-  sw: number;
-}
-
-export interface MasqueLointainNonHomogene {
-  tv_coef_masque_lointain_non_homogene_id?: string;
-}
+/** + `donnee_utilisateur` Open3CL hors XSD. */
+export type BaieVitree = XsdLogementEnveloppeBaieVitree & {
+  donnee_utilisateur?: Record<string, any>;
+};
+export type BaieVitreeDE = XsdLogementEnveloppeBaieVitreeDonneeEntree;
+export type BaieVitreeDI = XsdLogementEnveloppeBaieVitreeDonneeIntermediaire;
+export type BaieVitreeDoubleFenetre = XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetre;
+export type BaieVitreeDoubleFenetreDE =
+  XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetreDonneeEntree;
+export type BaieVitreeDoubleFenetreDI =
+  XsdLogementEnveloppeBaieVitreeBaieVitreeDoubleFenetreDonneeIntermediaire;
+export type MasqueLointainNonHomogene =
+  XsdLogementEnveloppeBaieVitreeDonneeEntreeMasqueLointainNonHomogene;