@open3cl/engine 1.8.6 → 1.8.8

package/6.2_surface_sud_equivalente.js

@@ -14,11 +14,6 @@ export function calc_sse_j(bv_list, ets, ca, zc, mois) {
     return sseBaiesExt;
   }
 
-  // Certaines vérandas sont dupliqués dans les DPE.
-  if (Array.isArray(ets)) {
-    ets = ets[0];
-  }
-
   /**
    * 6.3 Traitement des espaces tampons solarisés
    * Sse_ver n'est calculée que pour les baies vitrées qui séparent le logement de l'espace tampon
@@ -28,6 +23,82 @@ export function calc_sse_j(bv_list, ets, ca, zc, mois) {
     return sseBaiesExt;
   }
 
+  /**
+   * Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+   * véranda. Sse = Sse_ext + Σ(v) Sse_veranda_v, chaque baie adjacence 10 n'étant comptée que dans
+   * la véranda sur laquelle elle donne (baie.reference_lnc = ets.reference).
+   */
+  const etsList = dedoublonnerEts(Array.isArray(ets) ? ets : [ets]);
+  const baiesParEts = rattacherBaiesAuxEts(baiesAdjVeranda, etsList);
+
+  return etsList.reduce(
+    (acc, etsItem, idx) => acc + calc_sse_veranda_j(etsItem, baiesParEts[idx], zc, mois),
+    sseBaiesExt
+  );
+}
+
+/**
+ * Certaines vérandas sont dupliquées dans les DPE : une même véranda (même référence, ou à défaut
+ * même contenu) ne doit être comptée qu'une seule fois.
+ *
+ * @param etsList {EtsItem[]}
+ * @returns {EtsItem[]}
+ */
+export function dedoublonnerEts(etsList) {
+  const vues = new Set();
+  return etsList.filter((etsItem) => {
+    if (!etsItem) return false;
+    const reference = etsItem.donnee_entree?.reference;
+    const cle = reference ? `ref:${reference}` : `json:${JSON.stringify(etsItem)}`;
+    if (vues.has(cle)) return false;
+    vues.add(cle);
+    return true;
+  });
+}
+
+/**
+ * Rattache chaque baie vitrée adjacence 10 à l'espace tampon sur lequel elle donne
+ * (baie.donnee_entree.reference_lnc = ets.donnee_entree.reference).
+ *
+ * Une baie sans lien exploitable (reference_lnc absente ou ne correspondant à aucune véranda) est
+ * rattachée à la première véranda : c'est le comportement historique, et le seul possible quand le
+ * DPE ne comporte qu'une véranda. La méthode ne permet pas de faire mieux pour une donnée manquante.
+ *
+ * @param baiesAdjVeranda {BaieVitreeItem[]}
+ * @param etsList {EtsItem[]}
+ * @returns {BaieVitreeItem[][]} baies par véranda, dans l'ordre de etsList
+ */
+export function rattacherBaiesAuxEts(baiesAdjVeranda, etsList) {
+  const baiesParEts = etsList.map(() => []);
+  // Aucune véranda exploitable : les baies adjacence 10 ne peuvent être rattachées à aucun ETS
+  if (etsList.length === 0) {
+    return baiesParEts;
+  }
+  baiesAdjVeranda.forEach((bv) => {
+    const referenceLnc = bv.donnee_entree.reference_lnc;
+    const idx = referenceLnc
+      ? etsList.findIndex((etsItem) => etsItem.donnee_entree?.reference === referenceLnc)
+      : -1;
+    baiesParEts[idx === -1 ? 0 : idx].push(bv);
+  });
+  return baiesParEts;
+}
+
+/**
+ * Surface sud équivalente apportée par une véranda sur le mois j (§6.3).
+ *
+ * @param ets {EtsItem}
+ * @param baiesAdjVeranda {BaieVitreeItem[]} baies séparant le logement de cette véranda
+ * @param zc {string}
+ * @param mois {string}
+ * @returns {number}
+ */
+function calc_sse_veranda_j(ets, baiesAdjVeranda, zc, mois) {
+  // Véranda sans baie vitrée vers le logement : aucun apport solaire
+  if (baiesAdjVeranda.length === 0) {
+    return 0;
+  }
+
   const bver = ets.donnee_intermediaire.bver;
   const T = ets.donnee_intermediaire.coef_transparence_ets;
 
@@ -80,7 +151,7 @@ export function calc_sse_j(bv_list, ets, ca, zc, mois) {
    */
   const SseVerandaj = Ssdj + ssIndj * bver;
 
-  return sseBaiesExt + SseVerandaj;
+  return SseVerandaj;
 }
 
 /**

package/6.2_surface_sud_equivalente.spec.js

@@ -8,7 +8,7 @@ import { describe, expect, test, vi } from 'vitest';
  */
 vi.mock('./enums.js', () => ({
   default: {
-    orientation: { 1: 'sud', 2: 'horizontal' },
+    orientation: { 1: 'sud', 2: 'horizontal', 3: 'est', 4: 'nord' },
     inclinaison_vitrage: { 3: 'verticale', 4: 'horizontal' }
   }
 }));
@@ -18,6 +18,11 @@ vi.mock('./tv.js', () => ({
     c1: {
       h1a: {
         Janvier: { 'sud verticale': 0.5, horizontal: 0.3 }
+      },
+      // Coefficients C1 de janvier en h1a (sud = 1, est = 0,40, nord = 0,31) pour les cas
+      // de test d'Olivier (issue #101)
+      h1b: {
+        Janvier: { 'sud verticale': 1, 'est verticale': 0.4, 'nord verticale': 0.31 }
       }
     }
   }
@@ -28,7 +33,8 @@ vi.mock('./utils.js', () => ({
   mois_liste: ['Janvier']
 }));
 
-const { calc_sse_j, calc_sse } = await import('./6.2_surface_sud_equivalente.js');
+const { calc_sse_j, calc_sse, dedoublonnerEts, rattacherBaiesAuxEts } =
+  await import('./6.2_surface_sud_equivalente.js');
 
 /** Fabrique une baie vitrée avec les données d'entrée/intermédiaires utiles au calcul. */
 function baie({ adjacence, surface, orientationId = '1', inclinaisonId = '3', sw = 1 }) {
@@ -212,3 +218,133 @@ describe('calc_sse - surface sud équivalente annuelle', () => {
     expect(calc_sse('ca1', 'h1a', bvList, null)).toBeCloseTo(0.4, 10);
   });
 });
+
+/**
+ * 6.3 Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+ * véranda ; Sse = Sse_ext + Σ(v) Sse_veranda_v. Une baie adjacence 10 n'entre que dans la véranda
+ * sur laquelle elle donne (reference_lnc = ets.reference).
+ * Cas de test fournis par Olivier (thermicien), zone h1b mockée avec C1 sud = 1, est = 0,40,
+ * nord = 0,31 ; Fe = 1.
+ * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §6.3
+ */
+describe('calc_sse_j - plusieurs espaces tampons solarisés (issue #101)', () => {
+  const SUD = '1';
+  const EST = '3';
+  const NORD = '4';
+
+  function baieInt(surface, orientationId, referenceLnc) {
+    const bv = baie({ adjacence: '10', surface, orientationId, sw: 0.47 });
+    if (referenceLnc !== undefined) bv.donnee_entree.reference_lnc = referenceLnc;
+    return bv;
+  }
+
+  function veranda(reference, T, bver, baiesExt) {
+    return {
+      donnee_entree: { reference },
+      donnee_intermediaire: { bver, coef_transparence_ets: T },
+      baie_ets_collection: {
+        baie_ets: baiesExt.map(([surface, orientationId]) =>
+          baie({ adjacence: '1', surface, orientationId })
+        )
+      }
+    };
+  }
+
+  // Baie extérieure 10 m² sud, Sw = 0,5 => Sse_ext = 5
+  const baieExt = baie({ adjacence: '1', surface: 10, orientationId: SUD, sw: 0.5 });
+  // V1 : T = 0,62, bver = 0,55, baies vers l'extérieur 8 m² sud + 4 m² est
+  const V1 = veranda('V1', 0.62, 0.55, [
+    [8, SUD],
+    [4, EST]
+  ]);
+  // V2 : T = 0,45, bver = 0,85, baie vers l'extérieur 6 m² nord
+  const V2 = veranda('V2', 0.45, 0.85, [[6, NORD]]);
+  const baiesV1 = [baieInt(4, SUD, 'V1'), baieInt(2, SUD, 'V1')];
+  const baiesV2 = [baieInt(2, NORD, 'V2'), baieInt(1, NORD, 'V2')];
+
+  // SseV1 = 1,7484 + (4,992 - 1,7484) * 0,55 = 3,53238
+  const SSE_V1 = 3.53238;
+  // SseV2 = 0,196695 + (0,71424 - 0,196695) * 0,85 = 0,63660825
+  const SSE_V2 = 0.63660825;
+
+  test('CT1 - cas de l’issue : Sse = Sse_ext + SseV1 + SseV2 avec T et bver propres', () => {
+    const bvList = [baieExt, ...baiesV1, ...baiesV2];
+    expect(calc_sse_j(bvList, [V1, V2], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(
+      5 + SSE_V1 + SSE_V2,
+      9
+    );
+  });
+
+  test('CT2 - seules les baies de V2 : le Sst de V1 n’est pas appliqué', () => {
+    const bvList = [baieExt, ...baiesV2];
+    expect(calc_sse_j(bvList, [V1, V2], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(5 + SSE_V2, 9);
+  });
+
+  test('CT3 - seules les baies de V1 : V2 sans baie vers le logement apporte 0', () => {
+    const bvList = [baieExt, ...baiesV1];
+    expect(calc_sse_j(bvList, [V1, V2], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+  });
+
+  test('CT4 - véranda dupliquée : pas de double comptage', () => {
+    const bvList = [baieExt, ...baiesV1];
+    expect(calc_sse_j(bvList, [V1, structuredClone(V1)], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(
+      5 + SSE_V1,
+      9
+    );
+  });
+
+  test('baies sans reference_lnc : rattachées à la première véranda (comportement historique)', () => {
+    const bvList = [baieExt, baieInt(4, SUD), baieInt(2, SUD)];
+    expect(calc_sse_j(bvList, [V1, V2], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+  });
+
+  test('l’ordre des vérandas dans la collection est sans effet', () => {
+    const bvList = [baieExt, ...baiesV1, ...baiesV2];
+    expect(calc_sse_j(bvList, [V2, V1], 'ca1', 'h1b', 'Janvier')).toBeCloseTo(
+      5 + SSE_V1 + SSE_V2,
+      9
+    );
+  });
+});
+
+describe('dedoublonnerEts / rattacherBaiesAuxEts', () => {
+  test('dédoublonnage par référence, à défaut par contenu identique ; éléments vides ignorés', () => {
+    const a = { donnee_entree: { reference: 'A' }, x: 1 };
+    const aBis = { donnee_entree: { reference: 'A' }, x: 2 };
+    const sansRef = { donnee_intermediaire: { bver: 1 } };
+    const autreSansRef = { donnee_intermediaire: { bver: 2 } };
+    expect(
+      dedoublonnerEts([a, aBis, sansRef, structuredClone(sansRef), autreSansRef, null])
+    ).toEqual([a, sansRef, autreSansRef]);
+  });
+
+  test('rattachement par reference_lnc ; référence inconnue => première véranda', () => {
+    const ets = [{ donnee_entree: { reference: 'A' } }, { donnee_entree: { reference: 'B' } }];
+    const bA = { donnee_entree: { reference_lnc: 'A' } };
+    const bB = { donnee_entree: { reference_lnc: 'B' } };
+    const bInconnue = { donnee_entree: { reference_lnc: 'Z' } };
+    const bSans = { donnee_entree: {} };
+    expect(rattacherBaiesAuxEts([bA, bB, bInconnue, bSans], ets)).toEqual([
+      [bA, bInconnue, bSans],
+      [bB]
+    ]);
+  });
+
+  test('aucune véranda exploitable (ets = [null]) : baies non rattachées, seules les baies extérieures comptent', () => {
+    const bA = { donnee_entree: { reference_lnc: 'A' } };
+    expect(rattacherBaiesAuxEts([bA], [])).toEqual([]);
+    const bvList = [
+      baie({ adjacence: '1', surface: 10, sw: 0.5 }),
+      baie({ adjacence: '10', surface: 4 })
+    ];
+    // c1 h1a janvier sud = 0,5 => 10 × 0,5 × 0,5
+    expect(calc_sse_j(bvList, [null], 'ca1', 'h1a', 'Janvier')).toBeCloseTo(2.5, 9);
+  });
+
+  test('véranda sans donnee_entree : seules les baies sans lien lui sont rattachées', () => {
+    const ets = [{}, { donnee_entree: { reference: 'B' } }];
+    const bB = { donnee_entree: { reference_lnc: 'B' } };
+    const bSans = { donnee_entree: {} };
+    expect(rattacherBaiesAuxEts([bB, bSans], ets)).toEqual([[bSans], [bB]]);
+  });
+});

package/README.md

@@ -370,7 +370,7 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <!-- CORPUS:START -->
 
-> **Version `1.8.5`** · à publier · branche `main` · généré le 2026-10-01
+> **Version `1.8.7`** · branche `main` · généré le 2026-10-02
 > Seuil de tolérance **5%**
 
 <table>
@@ -403,24 +403,24 @@ Ces résultats sont **générés automatiquement** à la fin de `npm run test:co
 
 <table>
 <tr>
-<td align="center"><strong>5,01 ms</strong><br/><sub>moyenne</sub></td>
-<td align="center"><strong>4,31 ms</strong><br/><sub>médiane</sub></td>
-<td align="center"><strong>0,13 ms</strong><br/><sub>min</sub></td>
-<td align="center"><strong>567,2 ms</strong><br/><sub>max</sub></td>
+<td align="center"><strong>4,80 ms</strong><br/><sub>moyenne</sub></td>
+<td align="center"><strong>4,20 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>518,4 ms</strong><br/><sub>max</sub></td>
 </tr>
 </table>
 
 | Corpus                                         | Moyenne | Médiane |     Min |      Max |     p95 |     p99 |
 | :--------------------------------------------- | ------: | ------: | ------: | -------: | ------: | ------: |
-| **Généraliste**                                | 4,04 ms | 3,63 ms | 0,21 ms |  24,9 ms | 7,45 ms | 10,8 ms |
-| **Appartement · chauffage individuel (2025)**  | 3,20 ms | 2,93 ms | 1,18 ms |  28,6 ms | 5,51 ms | 7,45 ms |
-| **Logement individuel (2025)**                 | 4,73 ms | 4,22 ms | 1,38 ms |  33,1 ms | 8,88 ms | 12,4 ms |
-| **Maison individuelle (2025)**                 | 5,37 ms | 4,79 ms | 1,68 ms |  52,5 ms | 9,69 ms | 13,3 ms |
-| **Immeuble · chauffage individuel**            | 7,43 ms | 6,08 ms | 0,19 ms | 137,8 ms | 16,0 ms | 28,0 ms |
-| **Appartement · chauffage collectif (2025)**   | 3,82 ms | 3,40 ms | 1,24 ms |  31,6 ms | 6,52 ms | 8,64 ms |
-| **Immeuble · chauffage collectif**             | 5,47 ms | 4,55 ms | 0,13 ms | 104,3 ms | 10,4 ms | 19,2 ms |
-| **Immeuble · chauffage mixte**                 | 5,31 ms | 4,38 ms | 0,22 ms | 567,2 ms | 10,9 ms | 17,8 ms |
-| **Individuel généré depuis l'immeuble (2026)** | 5,72 ms | 4,85 ms | 1,75 ms |  61,2 ms | 11,0 ms | 17,3 ms |
+| **Généraliste**                                | 4,33 ms | 3,90 ms | 0,20 ms |  36,9 ms | 7,87 ms | 11,1 ms |
+| **Appartement · chauffage individuel (2025)**  | 3,48 ms | 3,15 ms | 1,06 ms |  34,8 ms | 6,09 ms | 7,83 ms |
+| **Logement individuel (2025)**                 | 4,86 ms | 4,30 ms | 1,30 ms |  29,8 ms | 9,41 ms | 13,1 ms |
+| **Maison individuelle (2025)**                 | 5,48 ms | 4,96 ms | 1,65 ms |  35,8 ms | 9,87 ms | 12,8 ms |
+| **Immeuble · chauffage individuel**            | 5,89 ms | 5,04 ms | 0,11 ms |  75,0 ms | 11,9 ms | 18,7 ms |
+| **Appartement · chauffage collectif (2025)**   | 3,86 ms | 3,58 ms | 1,18 ms |  31,7 ms | 6,29 ms | 7,87 ms |
+| **Immeuble · chauffage collectif**             | 5,21 ms | 4,43 ms | 0,11 ms | 110,0 ms | 9,58 ms | 16,9 ms |
+| **Immeuble · chauffage mixte**                 | 4,89 ms | 4,01 ms | 0,20 ms | 518,4 ms | 10,0 ms | 17,0 ms |
+| **Individuel généré depuis l'immeuble (2026)** | 5,22 ms | 4,47 ms | 1,61 ms |  40,6 ms | 9,86 ms | 15,4 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/core/file/infrastructure/adapter/file.store.js

@@ -10,7 +10,11 @@ export class FileStore {
    * @return {Promise<any>}
    */
   async downloadXlsxFileAndConvertToJson(url) {
-    return fetch(url)
+    const parsedUrl = new URL(url);
+    if (!['http:', 'https:'].includes(parsedUrl.protocol)) {
+      throw new Error(`Unsupported protocol for url: ${url}`);
+    }
+    return fetch(parsedUrl)
       .then((res) => res.arrayBuffer())
       .then((buffer) =>
         this.#excelWorkBookToJson(XLSX.read(buffer, { type: 'string', raw: false }))

package/core/file/infrastructure/adapter/file.store.spec.js

@@ -39,6 +39,7 @@ describe('FileStore', () => {
     vi.mocked(XLSX.utils.sheet_to_json).mockReset();
     vi.mocked(XLSX.utils.encode_col).mockClear();
     vi.mocked(XLSX.utils.encode_row).mockClear();
+    vi.mocked(global.fetch).mockClear();
 
     // Comportements par défaut « nominaux ».
     vi.mocked(readFile).mockImplementation((path, cb) => cb(null, Buffer.from(new ArrayBuffer(1))));
@@ -57,13 +58,44 @@ describe('FileStore', () => {
       const output = await fileStore.downloadXlsxFileAndConvertToJson('http://localhost:8080');
 
       expect(output).toEqual({ Sheet1: [] });
-      // Le buffer téléchargé est lu par XLSX avec les bonnes options.
-      expect(fetch).toHaveBeenCalledWith('http://localhost:8080');
+      // La protection CWE-918 construit une véritable instance `URL` (validée) avant l'appel à
+      // `fetch` : on vérifie le type et le `href` réel plutôt qu'une égalité de chaîne, car
+      // `new URL()` normalise l'URL (ajout du `/` final).
+      expect(fetch).toHaveBeenCalledTimes(1);
+      const [urlArgument] = vi.mocked(fetch).mock.calls[0];
+      expect(urlArgument).toBeInstanceOf(URL);
+      expect(urlArgument.href).toBe('http://localhost:8080/');
       expect(XLSX.read).toHaveBeenCalledWith(expect.anything(), {
         type: 'string',
         raw: false
       });
     });
+
+    describe('validation du protocole (CWE-918)', () => {
+      test.each(['http://localhost:8080', 'https://localhost:8080'])(
+        'accepte les URLs avec le protocole %s',
+        async (url) => {
+          const fileStore = new FileStore();
+
+          await expect(fileStore.downloadXlsxFileAndConvertToJson(url)).resolves.toEqual({
+            Sheet1: []
+          });
+
+          expect(fetch).toHaveBeenCalledTimes(1);
+        }
+      );
+
+      test("rejette une URL avec un protocole non http/https (ex. file://) et n'appelle pas fetch", async () => {
+        const fileStore = new FileStore();
+        const url = 'file:///etc/passwd';
+
+        await expect(fileStore.downloadXlsxFileAndConvertToJson(url)).rejects.toThrow(
+          `Unsupported protocol for url: ${url}`
+        );
+
+        expect(fetch).not.toHaveBeenCalled();
+      });
+    });
   });
 
   describe('readLocalOdsFileAndConvertToJson', () => {

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.8.6';
+const LIB_VERSION = '1.8.8';
 
 const dpeSanitizerService = new DpeSanitizerService();
 

package/features/engine/domain/apport_et_besoin/surface-sud-equivalente.service.js

@@ -42,88 +42,154 @@ export class SurfaceSudEquivalenteService {
    */
   ssdMois(ctx, enveloppe, mois) {
     const baiesVitrees = enveloppe.baie_vitree_collection?.baie_vitree || [];
-    let ets = enveloppe.ets_collection?.ets || [];
+    const zc = ctx.zoneClimatique.id;
 
-    let SseVerandaj = 0;
+    /**
+     * Baies vitrées donnant directement sur l'extérieur
+     */
+    const sseBaiesExt = baiesVitrees
+      .filter((bv) => parseInt(bv.donnee_entree.enum_type_adjacence_id) === 1)
+      .reduce((acc, bv) => acc + this.ssdBaieMois(bv, zc, mois), 0);
 
     /**
-     * Si une véranda est présente, on calcul l'mpact de l’espace tampon solarisé sur les apports solaires à travers
-     * les baies vitrées qui séparent le logement de l'espace tampon
-     *
      * 6.3 Traitement des espaces tampons solarisés
      * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
+     *
+     * Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+     * véranda. Sse = Sse_ext + Σ(v) Sse_veranda_v, chaque baie adjacence 10 n'étant comptée que dans
+     * la véranda sur laquelle elle donne (baie.reference_lnc = ets.reference).
+     * Sse_ver n'est calculée que pour les baies vitrées qui séparent le logement de l'espace tampon :
+     * sans aucune de ces baies, les apports de l'espace tampon n'entrent pas dans le logement.
      */
-    if (ets) {
-      // Certaines vérandas sont dupliqués dans les DPE.
-      if (Array.isArray(ets)) {
-        ets = ets[0];
-      }
-
-      if (ets) {
-        const bver = ets.donnee_intermediaire.bver;
-        const T = ets.donnee_intermediaire.coef_transparence_ets;
-
-        /**
-         * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
-         * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
-         * Calculés pour les baies vitrées qui séparent le logement de l'espace tampon
-         * @type {number}
-         */
-        const Ssdj = this.getBaiesSurEspaceTampon(baiesVitrees).reduce((acc, bv) => {
-          return acc + T * this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois);
-        }, 0);
-
-        /**
-         * Surface sud équivalente représentant les apports solaires indirects dans le logement
-         */
-        let baies = ets.baie_ets_collection.baie_ets;
-
-        if (!Array.isArray(baies)) {
-          baies = [baies];
-        }
-
-        /**
-         * Apports totaux à travers l'espace tampon
-         * @type {number}
-         */
-        const Sstj = baies.reduce((acc, bv) => {
-          return acc + this.ssdBaieMois(bv, ctx.zoneClimatique.id, mois, 0.8 * T + 0.024);
-        }, 0);
-
-        /**
-         * Surface sud équivalente représentant l’impact des apports solaires indirects associés au rayonnement
-         * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
-         * @type {number}
-         */
-        const Ssindj = Sstj - Ssdj;
-
-        /**
-         * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
-         * de l'espace tampon
-         * @type {number}
-         */
-        SseVerandaj = Ssdj + Ssindj * bver;
-      }
+    const etsList = this.dedoublonnerEts(this.getEtsList(enveloppe));
+    const baiesParEts = this.rattacherBaiesAuxEts(
+      this.getBaiesSurEspaceTampon(baiesVitrees),
+      etsList
+    );
+
+    return etsList.reduce(
+      (acc, ets, idx) => acc + this.sseVerandaMois(ets, baiesParEts[idx], zc, mois),
+      sseBaiesExt
+    );
+  }
+
+  /**
+   * Surface sud équivalente apportée par une véranda sur un mois donné (§6.3)
+   *
+   * @param ets {Ets}
+   * @param baiesAdjVeranda {BaieVitree[]} baies vitrées séparant le logement de cette véranda
+   * @param zc {string} zone climatique du logement
+   * @param mois {string}
+   * @returns {number}
+   */
+  sseVerandaMois(ets, baiesAdjVeranda, zc, mois) {
+    // Véranda sans baie vitrée vers le logement : aucun apport solaire
+    if (baiesAdjVeranda.length === 0) {
+      return 0;
     }
 
-    return baiesVitrees.reduce((acc, baieVitree) => {
-      const typeAdjacence = parseInt(baieVitree.donnee_entree.enum_type_adjacence_id);
+    const bver = ets.donnee_intermediaire.bver;
+    const T = ets.donnee_intermediaire.coef_transparence_ets;
+
+    /**
+     * Surface sud équivalente représentant l’impact des apports solaires associés au rayonnement solaire
+     * traversant directement l’espace tampon pour arriver dans la partie habitable du logement
+     * Calculés pour les baies vitrées qui séparent le logement de cet espace tampon
+     * @type {number}
+     */
+    const Ssdj = baiesAdjVeranda.reduce((acc, bv) => acc + T * this.ssdBaieMois(bv, zc, mois), 0);
 
-      /**
-       * 6.3 Traitement des espaces tampons solarisés
-       * 10 - 'espace tampon solarisé (véranda,loggia fermée)'
-       */
-      if (typeAdjacence === 10 && ets) {
-        return acc + SseVerandaj;
-      }
+    /**
+     * Baies de l'espace tampon donnant sur l'extérieur (propres à chaque véranda)
+     */
+    let baies = ets.baie_ets_collection?.baie_ets || [];
 
-      // Pour les fenêtres qui ne donnent pas sur l'extérieur, pas de surface sud équivalente
-      if (typeAdjacence !== 1) {
-        return acc;
-      }
+    if (!Array.isArray(baies)) {
+      baies = [baies];
+    }
 
-      return acc + this.ssdBaieMois(baieVitree, ctx.zoneClimatique.id, mois);
+    /**
+     * Apports totaux à travers l'espace tampon
+     * @type {number}
+     */
+    const Sstj = baies.reduce((acc, bv) => {
+      return acc + this.ssdBaieMois(bv, zc, mois, 0.8 * T + 0.024);
     }, 0);
+
+    /**
+     * Surface sud équivalente représentant l’impact des apports solaires indirects associés au rayonnement
+     * solaire entrant dans la partie habitable du logement après de multiples réflexions dans l’espace tampon solarisé
+     * @type {number}
+     */
+    const Ssindj = Sstj - Ssdj;
+
+    /**
+     * Impact de l’espace tampon solarisé sur les apports solaires à travers les baies vitrées qui séparent le logement
+     * de l'espace tampon
+     */
+    return Ssdj + Ssindj * bver;
+  }
+
+  /**
+   * Liste des espaces tampons solarisés du logement (la collection peut contenir un objet unique,
+   * un tableau, ou être absente selon les DPE)
+   *
+   * @param enveloppe {Enveloppe}
+   * @returns {Ets[]}
+   */
+  getEtsList(enveloppe) {
+    const ets = enveloppe.ets_collection?.ets;
+    if (!ets) {
+      return [];
+    }
+    return Array.isArray(ets) ? ets : [ets];
+  }
+
+  /**
+   * Certaines vérandas sont dupliquées dans les DPE : une même véranda (même référence, ou à défaut
+   * même contenu) ne doit être comptée qu'une seule fois.
+   *
+   * @param etsList {Ets[]}
+   * @returns {Ets[]}
+   */
+  dedoublonnerEts(etsList) {
+    const vues = new Set();
+    return etsList.filter((ets) => {
+      if (!ets) return false;
+      const reference = ets.donnee_entree?.reference;
+      const cle = reference ? `ref:${reference}` : `json:${JSON.stringify(ets)}`;
+      if (vues.has(cle)) return false;
+      vues.add(cle);
+      return true;
+    });
+  }
+
+  /**
+   * Rattache chaque baie vitrée adjacence 10 à l'espace tampon sur lequel elle donne
+   * (baie.donnee_entree.reference_lnc = ets.donnee_entree.reference).
+   *
+   * Une baie sans lien exploitable (reference_lnc absente ou ne correspondant à aucune véranda) est
+   * rattachée à la première véranda : c'est le comportement historique, et le seul possible quand le
+   * DPE ne comporte qu'une véranda.
+   *
+   * @param baiesAdjVeranda {BaieVitree[]}
+   * @param etsList {Ets[]}
+   * @returns {BaieVitree[][]} baies par véranda, dans l'ordre de etsList
+   */
+  rattacherBaiesAuxEts(baiesAdjVeranda, etsList) {
+    const baiesParEts = etsList.map(() => []);
+    // Aucune véranda exploitable : les baies adjacence 10 ne peuvent être rattachées à aucun ETS
+    if (etsList.length === 0) {
+      return baiesParEts;
+    }
+    baiesAdjVeranda.forEach((bv) => {
+      const referenceLnc = bv.donnee_entree.reference_lnc;
+      const idx = referenceLnc
+        ? etsList.findIndex((ets) => ets.donnee_entree?.reference === referenceLnc)
+        : -1;
+      baiesParEts[idx === -1 ? 0 : idx].push(bv);
+    });
+    return baiesParEts;
   }
 
   /**

package/features/engine/domain/apport_et_besoin/surface-sud-equivalente.service.spec.js

@@ -0,0 +1,280 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { SurfaceSudEquivalenteService } from './surface-sud-equivalente.service.js';
+
+/**
+ * Orientations utilisées dans les tests (identifiants arbitraires : le store est un double de test)
+ */
+const SUD = '1';
+const NORD = '2';
+const EST = '3';
+const HORIZONTAL = '5';
+
+/**
+ * Coefficients C1 de janvier (sud = 1, est = 0,40, nord = 0,31, horizontal = 0,3) utilisés pour les
+ * cas de test d'Olivier (issue #101). Indexés par orientation.
+ */
+const C1 = { [SUD]: 1, [NORD]: 0.31, [EST]: 0.4, [HORIZONTAL]: 0.3 };
+
+/** @type {{ getCoefficientBaieVitree: import('vitest').Mock }} */
+let tvStore;
+
+/** @type {SurfaceSudEquivalenteService} */
+let service;
+
+/** @type {Contexte} */
+const ctx = { zoneClimatique: { id: '2', value: 'h1b' } };
+
+/** Fabrique une baie vitrée avec les données d'entrée/intermédiaires utiles au calcul. */
+function baie({ adjacence = '1', surface, orientationId = SUD, sw = 1, referenceLnc }) {
+  const bv = {
+    donnee_entree: {
+      enum_type_adjacence_id: adjacence,
+      enum_orientation_id: orientationId,
+      enum_inclinaison_vitrage_id: '3',
+      surface_totale_baie: surface
+    },
+    donnee_intermediaire: { sw }
+  };
+  if (referenceLnc !== undefined) bv.donnee_entree.reference_lnc = referenceLnc;
+  return bv;
+}
+
+/** Fabrique une baie de l'espace tampon donnant sur l'extérieur (pas de donnée intermédiaire). */
+function baieEts(surface, orientationId) {
+  return {
+    donnee_entree: {
+      enum_orientation_id: orientationId,
+      enum_inclinaison_vitrage_id: '3',
+      surface_totale_baie: surface
+    }
+  };
+}
+
+/** Fabrique une véranda avec ses propres T, bver et baies extérieures. */
+function veranda(reference, T, bver, baiesExt) {
+  return {
+    donnee_entree: { reference },
+    donnee_intermediaire: { bver, coef_transparence_ets: T },
+    baie_ets_collection: {
+      baie_ets: baiesExt.map(([surface, orientationId]) => baieEts(surface, orientationId))
+    }
+  };
+}
+
+function enveloppe(baiesVitrees, ets) {
+  return {
+    baie_vitree_collection: { baie_vitree: baiesVitrees },
+    ets_collection: ets === undefined ? {} : { ets }
+  };
+}
+
+describe('Calcul de la surface sud équivalente (§6.2 / §6.3)', () => {
+  beforeEach(() => {
+    tvStore = {
+      getCoefficientBaieVitree: vi.fn((orientation) => C1[orientation])
+    };
+    service = new SurfaceSudEquivalenteService(tvStore);
+  });
+
+  describe('ssdBaieMois', () => {
+    test('interroge la table C1 avec orientation, inclinaison, zone climatique et mois', () => {
+      const bv = baie({ surface: 10, orientationId: EST, sw: 0.5 });
+      // 10 * 0,40 * 0,5
+      expect(service.ssdBaieMois(bv, '2', 'Janvier')).toBeCloseTo(2, 9);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(3, 3, 2, 'Janvier');
+    });
+
+    test('inclinaison absente : vitrage vertical (3) par défaut ; facteurs fe1/fe2 appliqués', () => {
+      const bv = baie({ surface: 10, sw: 0.5 });
+      delete bv.donnee_entree.enum_inclinaison_vitrage_id;
+      bv.donnee_intermediaire.fe1 = 0.8;
+      bv.donnee_intermediaire.fe2 = 0.5;
+      expect(service.ssdBaieMois(bv, '2', 'Janvier')).toBeCloseTo(10 * 0.5 * 0.8 * 0.5, 9);
+      expect(tvStore.getCoefficientBaieVitree).toHaveBeenCalledWith(1, 3, 2, 'Janvier');
+    });
+
+    test('un coefficient explicite remplace le facteur solaire sw de la baie', () => {
+      expect(service.ssdBaieMois(baieEts(10, SUD), '2', 'Janvier', 0.3)).toBeCloseTo(3, 9);
+    });
+  });
+
+  describe('ssdMois - sans espace tampon solarisé', () => {
+    test('somme des baies donnant sur l’extérieur ; les autres adjacences sont ignorées', () => {
+      const bvList = [
+        baie({ surface: 10, sw: 0.5 }),
+        baie({ adjacence: '10', surface: 4 }),
+        baie({ adjacence: '3', surface: 4 })
+      ];
+      expect(service.ssdMois(ctx, enveloppe(bvList), 'Janvier')).toBeCloseTo(5, 9);
+    });
+
+    test('ets_collection vide (tableau) ou absente : seules les baies extérieures comptent', () => {
+      const bvList = [baie({ surface: 10, sw: 0.5 }), baie({ adjacence: '10', surface: 4 })];
+      expect(service.ssdMois(ctx, enveloppe(bvList, []), 'Janvier')).toBeCloseTo(5, 9);
+      expect(
+        service.ssdMois(ctx, { baie_vitree_collection: { baie_vitree: bvList } }, 'Janvier')
+      ).toBeCloseTo(5, 9);
+    });
+
+    test('aucune baie vitrée : surface sud équivalente nulle', () => {
+      expect(service.ssdMois(ctx, {}, 'Janvier')).toBe(0);
+    });
+  });
+
+  describe('ssdMois - un espace tampon solarisé', () => {
+    test('apports directs + indirects : Sse = Sse_ext + Ssd + (Sst - Ssd) × bver', () => {
+      // T = 0,5, bver = 0,8, baie extérieure ETS 10 m² sud (unique, non tableau)
+      const ets = {
+        donnee_entree: {},
+        donnee_intermediaire: { bver: 0.8, coef_transparence_ets: 0.5 },
+        baie_ets_collection: { baie_ets: baieEts(10, SUD) }
+      };
+      const bvList = [baie({ surface: 10, sw: 0.5 }), baie({ adjacence: '10', surface: 2 })];
+      // Ssd = 0,5 × 2 × 1 × 1 = 1 ; Sst = 10 × (0,8 × 0,5 + 0,024) = 4,24
+      // Sse_ver = 1 + (4,24 - 1) × 0,8 = 3,592
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(5 + 3.592, 9);
+    });
+
+    test('ETS sans baie adjacence 10 : bver et T sans effet, Sse_ver non ajoutée', () => {
+      const ets = veranda('V', 0.5, 0.8, [[10, SUD]]);
+      const bvList = [baie({ surface: 10, sw: 0.5 })];
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(5, 9);
+    });
+
+    test('ETS sans baie extérieure : Sst = 0', () => {
+      const ets = {
+        donnee_entree: {},
+        donnee_intermediaire: { bver: 0.5, coef_transparence_ets: 0.5 }
+      };
+      const bvList = [baie({ adjacence: '10', surface: 2 })];
+      // Ssd = 1 ; Sse_ver = 1 + (0 - 1) × 0,5 = 0,5
+      expect(service.ssdMois(ctx, enveloppe(bvList, ets), 'Janvier')).toBeCloseTo(0.5, 9);
+    });
+
+    test('la Sse_ver n’est comptée qu’une fois quel que soit le nombre de baies adjacence 10', () => {
+      const ets = veranda('V', 0.5, 0.8, [[10, SUD]]);
+      const uneBaie = [baie({ adjacence: '10', surface: 2 })];
+      const deuxBaies = [
+        baie({ adjacence: '10', surface: 1 }),
+        baie({ adjacence: '10', surface: 1 })
+      ];
+      expect(service.ssdMois(ctx, enveloppe(deuxBaies, ets), 'Janvier')).toBeCloseTo(
+        service.ssdMois(ctx, enveloppe(uneBaie, ets), 'Janvier'),
+        9
+      );
+    });
+  });
+
+  /**
+   * 6.3 Plusieurs espaces tampons solarisés (issue #101) : T, bver, Sst et Ssd sont propres à chaque
+   * véranda ; Sse = Sse_ext + Σ(v) Sse_veranda_v. Une baie adjacence 10 n'entre que dans la véranda
+   * sur laquelle elle donne (reference_lnc = ets.reference).
+   * Cas de test fournis par Olivier (thermicien) : C1 sud = 1, est = 0,40, nord = 0,31 ; Fe = 1.
+   * @see : Methode_de_calcul_3CL_DPE_2021-338.pdf - §6.3
+   */
+  describe('ssdMois - plusieurs espaces tampons solarisés (issue #101)', () => {
+    // Baie extérieure 10 m² sud, Sw = 0,5 => Sse_ext = 5
+    const baieExt = baie({ surface: 10, sw: 0.5 });
+    // V1 : T = 0,62, bver = 0,55, baies vers l'extérieur 8 m² sud + 4 m² est
+    const V1 = veranda('V1', 0.62, 0.55, [
+      [8, SUD],
+      [4, EST]
+    ]);
+    // V2 : T = 0,45, bver = 0,85, baie vers l'extérieur 6 m² nord
+    const V2 = veranda('V2', 0.45, 0.85, [[6, NORD]]);
+    const baiesV1 = [
+      baie({ adjacence: '10', surface: 4, sw: 0.47, referenceLnc: 'V1' }),
+      baie({ adjacence: '10', surface: 2, sw: 0.47, referenceLnc: 'V1' })
+    ];
+    const baiesV2 = [
+      baie({ adjacence: '10', surface: 2, orientationId: NORD, sw: 0.47, referenceLnc: 'V2' }),
+      baie({ adjacence: '10', surface: 1, orientationId: NORD, sw: 0.47, referenceLnc: 'V2' })
+    ];
+
+    // SseV1 = 1,7484 + (4,992 - 1,7484) × 0,55 = 3,53238
+    const SSE_V1 = 3.53238;
+    // SseV2 = 0,196695 + (0,71424 - 0,196695) × 0,85 = 0,63660825
+    const SSE_V2 = 0.63660825;
+
+    test('CT1 - cas de l’issue : Sse = Sse_ext + SseV1 + SseV2 avec T et bver propres', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1 + SSE_V2, 9);
+    });
+
+    test('CT2 - seules les baies de V2 : le Sst de V1 n’est pas appliqué', () => {
+      const env = enveloppe([baieExt, ...baiesV2], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V2, 9);
+    });
+
+    test('CT3 - seules les baies de V1 : V2 sans baie vers le logement apporte 0', () => {
+      const env = enveloppe([baieExt, ...baiesV1], [V1, V2]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('CT4 - véranda dupliquée : pas de double comptage', () => {
+      const env = enveloppe([baieExt, ...baiesV1], [V1, structuredClone(V1)]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('baies sans reference_lnc : rattachées à la première véranda (comportement historique)', () => {
+      const env = enveloppe(
+        [
+          baieExt,
+          baie({ adjacence: '10', surface: 4, sw: 0.47 }),
+          baie({ adjacence: '10', surface: 2, sw: 0.47 })
+        ],
+        [V1, V2]
+      );
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1, 9);
+    });
+
+    test('l’ordre des vérandas dans la collection est sans effet', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V2, V1]);
+      expect(service.ssdMois(ctx, env, 'Janvier')).toBeCloseTo(5 + SSE_V1 + SSE_V2, 9);
+    });
+
+    test('execute somme la surface sud équivalente de chaque mois', () => {
+      const env = enveloppe([baieExt, ...baiesV1, ...baiesV2], [V1, V2]);
+      // C1 indépendant du mois dans le double de test : 12 × valeur de janvier
+      expect(service.execute(ctx, env)).toBeCloseTo(12 * (5 + SSE_V1 + SSE_V2), 9);
+    });
+  });
+
+  describe('dedoublonnerEts / rattacherBaiesAuxEts / getEtsList', () => {
+    test('getEtsList : objet unique, tableau ou absence', () => {
+      const ets = { donnee_entree: {} };
+      expect(service.getEtsList({ ets_collection: { ets } })).toEqual([ets]);
+      expect(service.getEtsList({ ets_collection: { ets: [ets] } })).toEqual([ets]);
+      expect(service.getEtsList({})).toEqual([]);
+    });
+
+    test('dédoublonnage par référence, à défaut par contenu identique ; éléments vides ignorés', () => {
+      const a = { donnee_entree: { reference: 'A' }, x: 1 };
+      const aBis = { donnee_entree: { reference: 'A' }, x: 2 };
+      const sansRef = { donnee_intermediaire: { bver: 1 } };
+      const autreSansRef = { donnee_intermediaire: { bver: 2 } };
+      expect(
+        service.dedoublonnerEts([a, aBis, sansRef, structuredClone(sansRef), autreSansRef, null])
+      ).toEqual([a, sansRef, autreSansRef]);
+    });
+
+    test('rattachement par reference_lnc ; référence inconnue ou absente => première véranda', () => {
+      const ets = [{ donnee_entree: { reference: 'A' } }, { donnee_entree: { reference: 'B' } }];
+      const bA = { donnee_entree: { reference_lnc: 'A' } };
+      const bB = { donnee_entree: { reference_lnc: 'B' } };
+      const bInconnue = { donnee_entree: { reference_lnc: 'Z' } };
+      const bSans = { donnee_entree: {} };
+      expect(service.rattacherBaiesAuxEts([bA, bB, bInconnue, bSans], ets)).toEqual([
+        [bA, bInconnue, bSans],
+        [bB]
+      ]);
+    });
+
+    test('véranda sans donnee_entree : seules les baies sans lien lui sont rattachées', () => {
+      const ets = [{}, { donnee_entree: { reference: 'B' } }];
+      const bB = { donnee_entree: { reference_lnc: 'B' } };
+      const bSans = { donnee_entree: {} };
+      expect(service.rattacherBaiesAuxEts([bB, bSans], ets)).toEqual([[bSans], [bB]]);
+    });
+  });
+});

package/features/engine/domain/engine.service.js

@@ -138,7 +138,10 @@ export class EngineService {
       delete m.baie_vitree_double_fenetre?.donnee_intermediaire;
       delete m.donnee_intermediaire;
     });
-    delete dpe.logement.enveloppe.ets_collection.ets?.donnee_intermediaire;
+    // Un DPE peut comporter un ou plusieurs espaces tampons solarisés (objet ou tableau)
+    [dpe.logement.enveloppe.ets_collection.ets]
+      .flat()
+      .forEach((ets) => delete ets?.donnee_intermediaire);
     dpe.logement.enveloppe.plancher_bas_collection.plancher_bas?.map(
       (m) => delete m.donnee_intermediaire
     );

package/features/engine/domain/engine.service.spec.js

@@ -227,4 +227,18 @@ describe('EngineService (orchestration de la méthode 3CL)', () => {
     // Aucun tableau interne ni production_elec_enr : les `?.` court-circuitent
     expect(() => service.execute(dpeMinimal())).not.toThrow();
   });
+
+  test('nettoie les données intermédiaires de chaque espace tampon solarisé (issue #101)', () => {
+    const dpe = dpeComplet();
+    dpe.logement.enveloppe.ets_collection.ets = [
+      { donnee_intermediaire: { bver: 0.55 } },
+      { donnee_intermediaire: { bver: 0.85 } },
+      null
+    ];
+    const resultat = service.execute(dpe);
+    const [v1, v2, vide] = resultat.logement.enveloppe.ets_collection.ets;
+    expect(v1.donnee_intermediaire).toBeUndefined();
+    expect(v2.donnee_intermediaire).toBeUndefined();
+    expect(vide).toBeNull();
+  });
 });

package/features/engine/domain/enveloppe/deperdition-enveloppe.service.js

@@ -258,14 +258,15 @@ export class DeperditionEnveloppeService {
       }
     });
 
-    let ets = enveloppe.ets_collection?.ets;
+    /**
+     * Un DPE peut comporter plusieurs espaces tampons solarisés (issue #101) : bver et le coefficient
+     * de transparence sont propres à chacun d'eux.
+     */
+    const ets = enveloppe.ets_collection?.ets;
     if (ets) {
-      // Certaines vérandas sont dupliqués dans les DPE.
-      if (Array.isArray(ets)) {
-        ets = ets[0];
-      }
-
-      ets.donnee_intermediaire = this.#espaceTamponService.execute(ctx, ets);
+      (Array.isArray(ets) ? ets : [ets]).forEach((e) => {
+        e.donnee_intermediaire = this.#espaceTamponService.execute(ctx, e);
+      });
     }
 
     enveloppe.pont_thermique_collection.pont_thermique?.forEach((pt) => {

package/features/engine/domain/enveloppe/deperdition-enveloppe.service.spec.js

@@ -0,0 +1,230 @@
+import { beforeEach, describe, expect, test, vi } from 'vitest';
+import { DeperditionEnveloppeService } from './deperdition-enveloppe.service.js';
+
+/**
+ * Tests unitaires isolés de `DeperditionEnveloppeService`.
+ *
+ * Les services de déperdition par type de paroi sont remplacés par des doubles de test
+ * (spies `vi.fn`) : seule la logique d'agrégation propre au service est vérifiée
+ * (sommes b × S × U, surfaces déperditives / isolées / menuiseries, espaces tampons).
+ */
+
+let murService;
+let porteService;
+let plancherBasService;
+let plancherHautService;
+let baieVitreeService;
+let espaceTamponService;
+let pontThermiqueService;
+let ventilationService;
+
+/** @type {DeperditionEnveloppeService} */
+let service;
+
+const ctx = { zoneClimatique: { value: 'h1b' } };
+
+/** Logement sans aucun élément d'enveloppe ni ventilation. */
+function logementVide() {
+  return {
+    enveloppe: {
+      mur_collection: {},
+      porte_collection: {},
+      plancher_bas_collection: {},
+      plancher_haut_collection: {},
+      baie_vitree_collection: {},
+      ets_collection: {},
+      pont_thermique_collection: {}
+    },
+    ventilation_collection: {}
+  };
+}
+
+describe('DeperditionEnveloppeService (§3 déperditions de l’enveloppe)', () => {
+  beforeEach(() => {
+    murService = { execute: vi.fn() };
+    porteService = { execute: vi.fn() };
+    plancherBasService = { execute: vi.fn() };
+    plancherHautService = { execute: vi.fn() };
+    baieVitreeService = { execute: vi.fn() };
+    espaceTamponService = { execute: vi.fn() };
+    pontThermiqueService = { execute: vi.fn() };
+    ventilationService = { execute: vi.fn() };
+    service = new DeperditionEnveloppeService(
+      murService,
+      porteService,
+      plancherBasService,
+      plancherHautService,
+      baieVitreeService,
+      espaceTamponService,
+      pontThermiqueService,
+      ventilationService
+    );
+  });
+
+  test('logement sans aucun élément : toutes les déperditions sont nulles', () => {
+    const logement = logementVide();
+    expect(service.deperditions(ctx, logement)).toEqual({
+      deperdition_mur: 0,
+      deperdition_plancher_bas: 0,
+      deperdition_plancher_haut: 0,
+      deperdition_baie_vitree: 0,
+      deperdition_pont_thermique: 0,
+      deperdition_porte: 0,
+      hperm: 0,
+      hvent: 0,
+      deperdition_enveloppe: 0
+    });
+    expect(espaceTamponService.execute).not.toHaveBeenCalled();
+  });
+
+  test('agrège b × S × U par paroi et transmet les surfaces à la ventilation', () => {
+    const logement = logementVide();
+    const env = logement.enveloppe;
+    env.mur_collection.mur = [
+      // déperditif, non isolé (type 2)
+      { donnee_entree: { surface_paroi_opaque: 10, enum_type_isolation_id: '2' } },
+      // déperditif, isolé, mais sur local non déperditif (22) : hors surface déperditive
+      {
+        donnee_entree: {
+          surface_paroi_opaque: 5,
+          enum_type_isolation_id: '3',
+          enum_type_adjacence_id: '22'
+        }
+      },
+      // b = 0 : ni surface déperditive, ni isolée
+      { donnee_entree: { surface_paroi_opaque: 100, enum_type_isolation_id: '3' } }
+    ];
+    murService.execute
+      .mockReturnValueOnce({ b: 1, umur: 2 })
+      .mockReturnValueOnce({ b: 0.5, umur: 1 })
+      .mockReturnValueOnce({ b: 0, umur: 1 });
+
+    env.porte_collection.porte = [
+      { donnee_entree: { surface_porte: 2, presence_joint: true } },
+      { donnee_entree: { surface_porte: 3, presence_joint: false } }
+    ];
+    porteService.execute
+      .mockReturnValueOnce({ b: 1, uporte: 3 })
+      .mockReturnValueOnce({ b: 0, uporte: 3 });
+
+    env.plancher_bas_collection.plancher_bas = [{ donnee_entree: { surface_paroi_opaque: 20 } }];
+    plancherBasService.execute.mockReturnValue({ b: 1, upb_final: 0.5 });
+
+    env.plancher_haut_collection.plancher_haut = [
+      { donnee_entree: { surface_paroi_opaque: 30, enum_type_isolation_id: '1' } },
+      {
+        donnee_entree: {
+          surface_paroi_opaque: 7,
+          enum_type_isolation_id: '4',
+          enum_type_adjacence_id: '22'
+        }
+      },
+      { donnee_entree: { surface_paroi_opaque: 50, enum_type_isolation_id: '4' } }
+    ];
+    plancherHautService.execute
+      .mockReturnValueOnce({ b: 1, uph: 1 })
+      .mockReturnValueOnce({ b: 1, uph: 1 })
+      .mockReturnValueOnce({ b: 0, uph: 1 });
+
+    env.baie_vitree_collection.baie_vitree = [
+      { donnee_entree: { surface_totale_baie: 4, presence_joint: true } },
+      { donnee_entree: { surface_totale_baie: 6 } }
+    ];
+    baieVitreeService.execute
+      .mockReturnValueOnce({ b: 1, u_menuiserie: 2 })
+      .mockReturnValueOnce({ b: 0, u_menuiserie: 2 });
+
+    env.pont_thermique_collection.pont_thermique = [
+      { donnee_entree: { l: 10, pourcentage_valeur_pont_thermique: 0.5 } },
+      { donnee_entree: { l: 4 } }
+    ];
+    pontThermiqueService.execute.mockReturnValue({ k: 0.5 });
+
+    logement.ventilation_collection.ventilation = [{ donnee_entree: { id: 'v' } }];
+    ventilationService.execute.mockReturnValue({ hvent: 10, hperm: 5 });
+
+    const resultat = service.deperditions(ctx, logement);
+
+    expect(resultat).toEqual({
+      deperdition_mur: 10 * 2 + 0.5 * 5 * 1,
+      deperdition_porte: 2 * 3,
+      deperdition_plancher_bas: 20 * 0.5,
+      deperdition_plancher_haut: 30 + 7,
+      deperdition_baie_vitree: 4 * 2,
+      deperdition_pont_thermique: 10 * 0.5 * 0.5 + 4 * 0.5,
+      hvent: 10,
+      hperm: 5,
+      deperdition_enveloppe: 22.5 + 6 + 10 + 37 + 8 + 4.5 + 10 + 5
+    });
+
+    // Délégation aux services de paroi
+    expect(plancherBasService.execute).toHaveBeenCalledWith(
+      ctx,
+      env.plancher_bas_collection.plancher_bas[0].donnee_entree,
+      env.plancher_bas_collection.plancher_bas
+    );
+    expect(pontThermiqueService.execute).toHaveBeenCalledWith(
+      ctx,
+      env,
+      env.pont_thermique_collection.pont_thermique[0].donnee_entree
+    );
+
+    // Surfaces transmises à la ventilation :
+    // déperditive = mur 10 + porte 2 + plancher haut 30 + baie 4 = 46
+    // isolée = mur 5 + plancher haut 7 = 12 ; non isolée = mur 10 + plancher haut 30 = 40
+    // menuiseries avec joint = porte 2 + baie 4 = 6 ; sans joint = porte 3 + baie 6 = 9
+    expect(ventilationService.execute).toHaveBeenCalledWith(ctx, { id: 'v' }, 46, 12, 40, 6, 9);
+  });
+
+  test('les surfaces sont réinitialisées à chaque calcul', () => {
+    const logement = logementVide();
+    logement.enveloppe.porte_collection.porte = [{ donnee_entree: { surface_porte: 2 } }];
+    porteService.execute.mockReturnValue({ b: 1, uporte: 1 });
+    logement.ventilation_collection.ventilation = [{ donnee_entree: {} }];
+    ventilationService.execute.mockReturnValue({ hvent: 0, hperm: 0 });
+
+    service.deperditions(ctx, logement);
+    service.deperditions(ctx, logement);
+
+    expect(ventilationService.execute).toHaveBeenLastCalledWith(ctx, {}, 2, 0, 0, 0, 2);
+  });
+
+  describe('espaces tampons solarisés', () => {
+    test('un ETS unique (objet) reçoit ses données intermédiaires', () => {
+      const logement = logementVide();
+      const ets = { donnee_entree: { tv_coef_transparence_ets_id: '2' } };
+      logement.enveloppe.ets_collection.ets = ets;
+      espaceTamponService.execute.mockReturnValue({ bver: 0.55, coef_transparence_ets: 0.62 });
+
+      service.deperditions(ctx, logement);
+
+      expect(espaceTamponService.execute).toHaveBeenCalledWith(ctx, ets);
+      expect(ets.donnee_intermediaire).toEqual({ bver: 0.55, coef_transparence_ets: 0.62 });
+    });
+
+    test('plusieurs ETS : bver et T calculés pour chacun d’eux (issue #101)', () => {
+      const logement = logementVide();
+      const V1 = { donnee_entree: { reference: 'V1' } };
+      const V2 = { donnee_entree: { reference: 'V2' } };
+      logement.enveloppe.ets_collection.ets = [V1, V2];
+      espaceTamponService.execute
+        .mockReturnValueOnce({ bver: 0.55, coef_transparence_ets: 0.62 })
+        .mockReturnValueOnce({ bver: 0.85, coef_transparence_ets: 0.45 });
+
+      service.deperditions(ctx, logement);
+
+      expect(espaceTamponService.execute).toHaveBeenCalledTimes(2);
+      expect(espaceTamponService.execute).toHaveBeenNthCalledWith(1, ctx, V1);
+      expect(espaceTamponService.execute).toHaveBeenNthCalledWith(2, ctx, V2);
+      expect(V1.donnee_intermediaire).toEqual({ bver: 0.55, coef_transparence_ets: 0.62 });
+      expect(V2.donnee_intermediaire).toEqual({ bver: 0.85, coef_transparence_ets: 0.45 });
+    });
+
+    test('sans ets_collection : aucun calcul d’espace tampon', () => {
+      const logement = logementVide();
+      delete logement.enveloppe.ets_collection;
+      service.deperditions(ctx, logement);
+      expect(espaceTamponService.execute).not.toHaveBeenCalled();
+    });
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open3cl/engine",
-  "version": "1.8.6",
+  "version": "1.8.8",
   "description": "Open Source 3CL-DPE engine",
   "main": "index.js",
   "directories": {