@piecemaker-legal/piecemaker 1.0.0

package/server/piecemaker/vendor/websocket-server/lib/doc-generate.cjs

@@ -0,0 +1,229 @@
+/**
+ * Rendu d'un export PieceMaker (HTML produit par `export-render.cjs`) en PDF
+ * ou DOCX — chronologie, feuille de temps.
+ *
+ * À ne pas confondre avec `office-to-pdf.cjs` (`convertToPdf`), qui convertit
+ * les PIÈCES DU CLIENT (.xlsx, .doc, .ppt, .rtf, .odt) avant tamponnage.
+ * Là-bas, LibreOffice est obligatoire et le reste : pandoc *re-compose* le
+ * document (il perd largeurs de colonnes, fusions, zones d'impression), là où
+ * LibreOffice le *reproduit* — et pour une pièce versée aux débats, la
+ * fidélité à ce que le client voit à l'écran est l'objet même du tamponnage.
+ * NE PAS brancher le tamponnage sur ce module.
+ *
+ * Ici c'est l'inverse : le HTML est produit par PieceMaker lui-même, pas
+ * apporté par le client. pandoc y est meilleur — vrais styles Word natifs,
+ * PDF composé par typst (rapide, pas de profil LibreOffice jetable à créer/
+ * détruire à chaque export) — quand il est disponible. Le repli LibreOffice
+ * (`officeToPdf`) reste le comportement actuel pour les postes qui n'ont pas
+ * pandoc : aucune régression n'est acceptable sur ce chemin.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const JSZip = require('jszip');
+
+const { execFilePromise, officeToPdf } = require('./office-to-pdf.cjs');
+
+// Pas d'équivalent de `SOFFICE_HINT` ici, et c'est volontaire : ce message
+// existe là-bas parce que `officeToPdf` LÈVE quand LibreOffice manque. Ici,
+// l'absence de pandoc ou de typst ne produit jamais d'erreur — elle change
+// seulement de chaîne. Un message d'installation n'aurait donc aucun endroit
+// où s'afficher ; c'est l'étape `installer/steps/10-pandoc.mjs` qui le porte.
+
+/** Sonde un binaire selon la même logique que `findSoffice` : variable
+ * d'environnement, chemins usuels, puis nom nu sondé par `--version`. */
+function findBinary(candidates) {
+  for (const candidate of candidates.filter(Boolean)) {
+    const isPathLike = candidate.includes('/') || candidate.includes('\\');
+    if (isPathLike) {
+      if (fs.existsSync(candidate)) return candidate;
+      continue;
+    }
+    const probe = spawnSync(candidate, ['--version'], { encoding: 'utf8', timeout: 30000 });
+    if (probe.status === 0) return candidate;
+  }
+  return null;
+}
+
+function findPandoc() {
+  return findBinary([
+    process.env.PANDOC_PATH,
+    '/opt/homebrew/bin/pandoc',
+    '/usr/local/bin/pandoc',
+    'C:\\Program Files\\Pandoc\\pandoc.exe',
+    'pandoc',
+  ]);
+}
+
+function findTypst() {
+  return findBinary([
+    process.env.TYPST_PATH,
+    '/opt/homebrew/bin/typst',
+    '/usr/local/bin/typst',
+    'typst',
+  ]);
+}
+
+/**
+ * Choix de chaîne, PUR (aucun accès disque/process) : `pandoc`/`typst` sont
+ * les valeurs déjà résolues par `findPandoc`/`findTypst` (chemin ou falsy).
+ */
+function chooseChain({ pandoc, typst, format }) {
+  if (format === 'docx') return pandoc ? 'pandoc' : 'soffice';
+  if (format === 'pdf') {
+    if (pandoc && typst) return 'pandoc-typst';
+    if (pandoc) return 'pandoc-soffice';
+    return 'soffice';
+  }
+  throw new Error(`Format d'export inconnu : ${format}`);
+}
+
+/**
+ * Le lecteur HTML de pandoc jette intégralement le CSS : le `@page { size:
+ * A4; margin: 2cm }` du gabarit (`export-render.cjs`) n'atteint donc jamais
+ * typst. La mise en page passe forcément par ces métadonnées, consommées via
+ * `--metadata-file` plutôt que `-V margin:x=...` (syntaxe ambiguë : x/y au
+ * même niveau que les autres clés prête à confusion). Clés du gabarit typst
+ * par défaut de pandoc 3.8 (`pandoc --print-default-template=typst`).
+ */
+function metadataYaml() {
+  return `papersize: a4
+margin:
+  x: 2cm
+  y: 2cm
+lang: fr
+fontsize: 10pt
+page-numbering: "1"
+`;
+}
+
+/**
+ * Force chaque section Word en A4 portrait avec des marges de 2 cm. Le writer
+ * DOCX de pandoc n'applique pas les métadonnées `papersize`/`margin` (elles
+ * servent au gabarit typst) et son document de référence par défaut est en
+ * Letter. La correction se fait donc directement dans `word/document.xml`,
+ * sans dépendre de LibreOffice ni du poste utilisateur.
+ */
+function applyA4PageLayoutXml(xml) {
+  return String(xml || '').replace(/<w:sectPr\b[^>]*>[\s\S]*?<\/w:sectPr>/g, (section) => {
+    const pageSize = '<w:pgSz w:w="11906" w:h="16838"/>';
+    const pageMargins = '<w:pgMar w:top="1134" w:right="1134" w:bottom="1134" w:left="1134" w:header="567" w:footer="567" w:gutter="0"/>';
+    let updated = /<w:pgSz\b[^>]*\/>/.test(section)
+      ? section.replace(/<w:pgSz\b[^>]*\/>/, pageSize)
+      : section.replace(/(<w:sectPr\b[^>]*>)/, `$1${pageSize}`);
+    updated = /<w:pgMar\b[^>]*\/>/.test(updated)
+      ? updated.replace(/<w:pgMar\b[^>]*\/>/, pageMargins)
+      : updated.replace(/(<w:pgSz\b[^>]*\/>)/, `$1${pageMargins}`);
+    return updated;
+  });
+}
+
+async function applyA4PageLayout(docxPath) {
+  const zip = await JSZip.loadAsync(fs.readFileSync(docxPath));
+  const documentPart = zip.file('word/document.xml');
+  if (!documentPart) throw new Error('DOCX pandoc invalide : word/document.xml est absent.');
+  const documentXml = await documentPart.async('string');
+  zip.file('word/document.xml', applyA4PageLayoutXml(documentXml));
+  const normalized = await zip.generateAsync({
+    type: 'nodebuffer',
+    compression: 'DEFLATE',
+    compressionOptions: { level: 6 },
+  });
+  fs.writeFileSync(docxPath, normalized);
+}
+
+/**
+ * PURE : ne fait qu'assembler les arguments. `typst`, si fourni, doit être le
+ * CHEMIN RÉSOLU du binaire (pas seulement `'typst'`) — trouvé via
+ * `TYPST_PATH`, il n'est pas forcément sur le PATH que pandoc utilisera.
+ * Jamais de guillemets : `spawn` ne passe pas par un shell (même piège que
+ * `sofficeArgs`, office-to-pdf.cjs:88).
+ *
+ * `--metadata title=` neutralise un doublon vérifié à l'exécution : le gabarit
+ * de `export-render.cjs` porte le titre DEUX fois, dans `<title>` (pour
+ * l'onglet du navigateur et les propriétés du document) et dans le `<h1>` du
+ * corps. pandoc lit le `<title>` comme métadonnée et, en sortie autonome
+ * (toujours le cas en DOCX et en PDF), le compose en tête sous le style
+ * `Title` — juste avant le `<h1>` devenu `Heading1`. Sans ce drapeau, le titre
+ * du document apparaît donc deux fois de suite. On garde le `<h1>` (seul
+ * visible par le repli LibreOffice) et on supprime la métadonnée : le gabarit
+ * typst, lui, teste `#if title != none` et n'imprime alors aucun bloc de titre.
+ */
+function pandocArgs(htmlPath, outPath, { metadataPath, typst } = {}) {
+  const ext = path.extname(outPath).toLowerCase();
+  const sansTitreDouble = ['--metadata', 'title='];
+  if (ext === '.docx') {
+    return ['--from=html', '--to=docx', ...sansTitreDouble, '--metadata-file', metadataPath, '--output', outPath, htmlPath];
+  }
+  if (ext === '.pdf') {
+    const args = ['--from=html', '--to=pdf'];
+    if (typst) args.push(`--pdf-engine=${typst}`);
+    args.push(...sansTitreDouble, '--metadata-file', metadataPath, '--output', outPath, htmlPath);
+    return args;
+  }
+  throw new Error(`Extension de sortie non prise en charge pour pandoc : ${ext}`);
+}
+
+/**
+ * Rend `html` en PDF ou DOCX dans `workDir`.
+ * @returns {Promise<{path: string, engine: string}>}
+ */
+async function generateDocument(html, workDir, { format = 'pdf', timeout = 120000 } = {}) {
+  if (format !== 'pdf' && format !== 'docx') {
+    throw new Error(`Format d'export inconnu : ${format} (attendu 'pdf' ou 'docx')`);
+  }
+
+  fs.mkdirSync(workDir, { recursive: true });
+  const htmlPath = path.join(workDir, 'export.html');
+  fs.writeFileSync(htmlPath, html, 'utf8');
+
+  const pandoc = findPandoc();
+  const typst = findTypst();
+  const chain = chooseChain({ pandoc, typst, format });
+
+  if (chain === 'soffice') {
+    const pdfPath = await officeToPdf(htmlPath, workDir, { format, timeout });
+    return { path: pdfPath, engine: 'libreoffice' };
+  }
+
+  // Chaînes pandoc : le fichier de métadonnées est requis dans les deux cas.
+  const metadataPath = path.join(workDir, 'export-meta.yaml');
+  fs.writeFileSync(metadataPath, metadataYaml(), 'utf8');
+
+  if (chain === 'pandoc-soffice') {
+    const docxPath = path.join(workDir, 'export.docx');
+    await runPandoc(pandoc, pandocArgs(htmlPath, docxPath, { metadataPath }), timeout);
+    await applyA4PageLayout(docxPath);
+    const pdfPath = await officeToPdf(docxPath, workDir, { format: 'pdf', timeout });
+    return { path: pdfPath, engine: 'pandoc+libreoffice' };
+  }
+
+  // 'pandoc' (docx direct) ou 'pandoc-typst' (pdf via typst)
+  const outPath = path.join(workDir, `export.${format}`);
+  await runPandoc(pandoc, pandocArgs(htmlPath, outPath, { metadataPath, typst }), timeout);
+  if (format === 'docx') await applyA4PageLayout(outPath);
+  return { path: outPath, engine: chain === 'pandoc-typst' ? 'pandoc+typst' : 'pandoc' };
+}
+
+/** Lance pandoc et lève en français avec stderr si la conversion échoue — un
+ * pandoc présent qui échoue est un vrai bug, on NE retombe PAS sur LibreOffice
+ * ici (le choix de chaîne s'est déjà fait, en amont, sur la présence des
+ * binaires). */
+async function runPandoc(pandoc, args, timeout) {
+  const result = await execFilePromise(pandoc, args, { timeout });
+  if (result.status === 0) return;
+  const detail = (result.stderr || result.stdout || '').trim()
+    || (result.timedOut ? `interrompu après ${Math.round(timeout / 1000)} s` : `code ${result.status}`);
+  throw new Error(`Conversion pandoc échouée (${detail})`);
+}
+
+module.exports = {
+  findPandoc,
+  findTypst,
+  chooseChain,
+  pandocArgs,
+  metadataYaml,
+  applyA4PageLayoutXml,
+  generateDocument,
+};

package/server/piecemaker/vendor/websocket-server/lib/export-render.cjs

@@ -0,0 +1,442 @@
+/**
+ * Rendu HTML imprimable (A4) pour l'export PDF/DOCX.
+ *
+ * Fonctions pures : aucune lecture disque, aucun appel git, aucun accès
+ * réseau — uniquement des données en entrée, une chaîne HTML en sortie. Le
+ * HTML produit ici est ensuite converti, ailleurs dans le pipeline
+ * (`doc-generate.cjs`) : par pandoc dans le cas nominal, avec un repli
+ * intégral sur LibreOffice (headless) si pandoc est absent du poste. C'est
+ * précisément ce repli qui oblige à garder le CSS volontairement pauvre
+ * (aucun flexbox/grid, aucune ressource externe) et les attributs HTML
+ * dupliqués sur chaque `<table>` : le moteur de rendu de LibreOffice ne
+ * supporte ni l'un ni l'autre autrement.
+ *
+ * Attention : le lecteur HTML de pandoc est bien plus strict que celui de
+ * LibreOffice et jette intégralement le CSS, `@page` compris — la mise en
+ * page du PDF vient donc des métadonnées passées à pandoc, pas de ce
+ * fichier. Si le rendu pandoc casse, trois constructions d'ici sont à
+ * surveiller en priorité : les `colspan` (séparateur de jour ~ligne 312 et
+ * ligne de total ~ligne 340), le `<tfoot>` (~ligne 339), et les `<br>` en
+ * cellule (~lignes 239 et 243).
+ */
+
+const { formatDurationFr } = require('../../piecemaker-plugin/scripts/lib/session-timing.cjs');
+
+// Mêmes libellés que la vue chronologie de l'admin (admin/app.js, CATEGORY_LABELS)
+// — on garde le vocabulaire déjà connu du cabinet plutôt que d'en inventer un autre.
+const CATEGORY_LABELS = {
+  personne: 'Personne',
+  societe: 'Société',
+  adresse: 'Adresse',
+  siren: 'SIREN',
+  autre: 'Autre',
+};
+
+/**
+ * Échappe une valeur pour insertion dans du HTML. Il n'existe pas d'équivalent
+ * serveur : celui d'admin/app.js tourne dans le navigateur (DOM `String.prototype`
+ * suffit là-bas), mais ce module est du CommonJS pur côté Node.
+ */
+function escapeHtml(value) {
+  if (value === null || value === undefined) return '';
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+/**
+ * `'2024-03-12'` (ou un ISO complet) → `'12/03/2024'`. Entrée vide/invalide → null,
+ * pour laisser l'appelant décider de l'affichage de repli (« Sans date », etc.).
+ */
+function formatDateFr(iso) {
+  if (typeof iso !== 'string' || !iso.trim()) return null;
+  const match = iso.match(/^(\d{4})-(\d{2})-(\d{2})/);
+  if (!match) return null;
+  const [, year, month, day] = match;
+  // On valide via Date plutôt que de faire confiance à la seule forme du texte :
+  // un "2024-13-40" a la bonne syntaxe mais n'est pas une date.
+  const asDate = new Date(`${year}-${month}-${day}T00:00:00Z`);
+  if (Number.isNaN(asDate.getTime())) return null;
+  return `${day}/${month}/${year}`;
+}
+
+/**
+ * Décumule le champ `PieceMaker-Temps-Session` : ce trailer de commit est le
+ * temps écoulé depuis le DÉBUT de la session (cumulatif), pas le temps propre
+ * à l'acte. On restitue `ownMs` = la part imputable à chaque commit, en
+ * soustrayant le cumul du commit précédent de la même session.
+ *
+ * Ne mute jamais l'entrée : on renvoie de nouveaux objets, dans l'ordre du
+ * tableau reçu (le tri par session/horodatage est purement interne au calcul).
+ */
+function decumulateDurations(entries) {
+  if (!Array.isArray(entries)) return [];
+
+  // Regroupement par sessionId. Une entrée sans sessionId (vide/null) forme
+  // sa propre session à elle seule : son ownMs est directement sa durée.
+  const groups = new Map(); // sessionId -> [{ entry, index }]
+  const solo = []; // indices des entrées sans sessionId
+
+  entries.forEach((entry, index) => {
+    const sessionId = entry && entry.sessionId ? entry.sessionId : null;
+    if (!sessionId) {
+      solo.push(index);
+      return;
+    }
+    if (!groups.has(sessionId)) groups.set(sessionId, []);
+    groups.get(sessionId).push({ entry, index });
+  });
+
+  const ownMsByIndex = new Array(entries.length).fill(0);
+
+  for (const index of solo) {
+    const durationMs = entries[index] && Number.isFinite(entries[index].durationMs)
+      ? entries[index].durationMs
+      : 0;
+    ownMsByIndex[index] = durationMs;
+  }
+
+  for (const items of groups.values()) {
+    // Tri croissant par horodatage : le cumul du trailer ne progresse que dans
+    // ce sens ; un ordre différent dans le tableau d'origine ne fausse donc pas
+    // le calcul (on ne réordonne que cette copie de travail).
+    // Départage par le cumul lui-même quand les horodatages sont identiques :
+    // git les stocke à la seconde, et le hook PostToolUse commite à chaque
+    // Write/Edit — deux actes tombent donc couramment dans la même seconde.
+    // Sans ce départage, l'ordre de `git log` (antichronologique) l'emporte,
+    // le décumul part du plus grand cumul et impute tout le temps au premier
+    // acte rencontré, les suivants étant ramenés à 0. Le compteur de session
+    // ne pouvant que croître, il est ici plus fiable que l'horodatage.
+    const sorted = [...items].sort((a, b) => {
+      const ta = Date.parse(a.entry.timestamp) || 0;
+      const tb = Date.parse(b.entry.timestamp) || 0;
+      if (ta !== tb) return ta - tb;
+      const da = Number.isFinite(a.entry.durationMs) ? a.entry.durationMs : 0;
+      const db = Number.isFinite(b.entry.durationMs) ? b.entry.durationMs : 0;
+      return da - db;
+    });
+    let previousCumulative = 0;
+    for (const { entry, index } of sorted) {
+      if (!Number.isFinite(entry.durationMs)) {
+        // Pas de trailer de temps sur cet acte : on ne peut rien lui imputer.
+        // Surtout, on ne touche pas `previousCumulative` — sinon l'acte
+        // suivant se retrouverait à tort décumulé depuis 0, et gonflerait
+        // artificiellement son propre temps.
+        ownMsByIndex[index] = 0;
+        continue;
+      }
+      const cumulative = entry.durationMs;
+      // Un écart négatif signale des horodatages désordonnés ou une reprise de
+      // session (le compteur repart plus bas) : on ramène à 0 plutôt que de
+      // retrancher du temps qui n'existe pas.
+      ownMsByIndex[index] = Math.max(0, cumulative - previousCumulative);
+      previousCumulative = cumulative;
+    }
+  }
+
+  return entries.map((entry, index) => ({ ...entry, ownMs: ownMsByIndex[index] }));
+}
+
+/** Enveloppe HTML commune : squelette + CSS inline, sobre pour LibreOffice. */
+function documentHtml({ title, byline, subtitle, bodyHtml }) {
+  const safeTitle = escapeHtml(title || '');
+  const safeByline = byline ? escapeHtml(byline) : '';
+  const safeSubtitle = subtitle ? escapeHtml(subtitle) : '';
+  return `<!DOCTYPE html>
+<html lang="fr">
+<head>
+<meta charset="utf-8">
+<title>${safeTitle}</title>
+<style>
+  @page { size: A4; margin: 2cm; }
+  body {
+    font-family: Arial, Helvetica, sans-serif;
+    font-size: 10pt;
+    color: #1a1a1a;
+    line-height: 1.35;
+  }
+  h1 {
+    color: #183153;
+    font-size: 19pt;
+    margin: 0 0 6px 0;
+    padding-bottom: 7px;
+    border-bottom: 3px solid #2f6f9f;
+  }
+  .export-byline {
+    font-size: 10pt;
+    color: #183153;
+    margin: 0 0 5px 0;
+  }
+  .export-subtitle {
+    font-size: 9pt;
+    color: #555555;
+    margin: 0 0 18px 0;
+  }
+  h2 {
+    font-size: 12pt;
+    margin: 20px 0 8px 0;
+    border-bottom: 1px solid #999999;
+    padding-bottom: 2px;
+  }
+  /* Le CSS ci-dessous sert à la lecture du HTML dans un navigateur. À
+     l'import, LibreOffice ignore la largeur et les bordures déclarées en CSS :
+     seuls les attributs HTML width/border/cellspacing posés sur chaque table
+     survivent à la conversion. Les deux sont donc nécessaires — ne retirer ni
+     l'un ni l'autre. Ces attributs sont inutiles à pandoc (qui jette tout le
+     CSS et ignore ces attributs HTML de toute façon), mais indispensables au
+     repli LibreOffice : à conserver pour cette seule raison. */
+  table {
+    width: 100%;
+    border-collapse: collapse;
+    margin-bottom: 12px;
+    font-size: 9pt;
+  }
+  th, td {
+    border: 1px solid #bbbbbb;
+    padding: 4px 6px;
+    text-align: left;
+    vertical-align: top;
+  }
+  th {
+    background-color: #e8e8e8;
+    font-weight: bold;
+  }
+  tfoot td {
+    font-weight: bold;
+    background-color: #f2f2f2;
+  }
+  .export-summary {
+    margin-bottom: 16px;
+  }
+  .export-summary td, .export-summary th {
+    border: none;
+    padding: 2px 12px 2px 0;
+  }
+  .export-daysep td {
+    background-color: #f2f2f2;
+    font-weight: bold;
+  }
+  .export-task-title {
+    font-weight: bold;
+    color: #183153;
+    font-size: 10pt;
+  }
+  .export-task-comment {
+    margin-top: 4px;
+    color: #3f4852;
+  }
+  .export-task-files-label {
+    margin-top: 6px;
+    color: #66717d;
+    font-size: 8pt;
+  }
+  .export-task-files {
+    margin: 2px 0 0 18px;
+    padding: 0;
+    color: #66717d;
+    font-size: 8pt;
+  }
+  .export-task-time {
+    text-align: right;
+    white-space: nowrap;
+    color: #183153;
+    font-weight: bold;
+  }
+  .export-task-date {
+    color: #3f4852;
+    white-space: nowrap;
+  }
+  .export-timesheet th {
+    background-color: #183153;
+    color: #ffffff;
+    border-color: #183153;
+    padding: 7px 8px;
+  }
+  .export-timesheet td {
+    border-color: #d7dee5;
+    padding: 8px;
+  }
+  .export-timesheet tbody tr:nth-child(even) td {
+    background-color: #f7f9fb;
+  }
+  .export-timesheet tfoot td {
+    background-color: #eaf1f6;
+    border-top: 2px solid #2f6f9f;
+    padding: 8px;
+  }
+  .export-empty {
+    color: #777777;
+    font-style: italic;
+  }
+</style>
+</head>
+<body>
+<h1>${safeTitle}</h1>
+${safeByline ? `<p class="export-byline"><strong>${safeByline}</strong></p>` : ''}
+${safeSubtitle ? `<p class="export-subtitle">${safeSubtitle}</p>` : ''}
+${bodyHtml}
+</body>
+</html>`;
+}
+
+/** Rendu HTML papier de la chronologie (`buildChronology()` de document-index.cjs). */
+function renderChronologyHtml(chronology, { caseName } = {}) {
+  const stats = (chronology && chronology.stats) || {};
+  const documents = Array.isArray(chronology && chronology.documents) ? chronology.documents : [];
+  const entities = Array.isArray(chronology && chronology.entities) ? chronology.entities : [];
+  const span = stats.span || null;
+
+  const now = new Date();
+  const generatedAtFr = now.toLocaleDateString('fr-FR', { day: 'numeric', month: 'long', year: 'numeric' });
+  const subtitle = `${caseName ? `Dossier « ${caseName} » — ` : ''}généré le ${generatedAtFr}`;
+
+  const periode = span ? `${formatDateFr(span.from) || span.from} → ${formatDateFr(span.to) || span.to}` : '—';
+
+  const summaryHtml = `
+<table class="export-summary" width="100%" border="0" cellspacing="0" cellpadding="4">
+  <tr><th>Pièces</th><td>${escapeHtml(stats.documents ?? 0)}</td>
+      <th>Indexées</th><td>${escapeHtml(stats.indexed ?? 0)}</td></tr>
+  <tr><th>Datées</th><td>${escapeHtml(stats.dated ?? 0)}</td>
+      <th>Entités</th><td>${escapeHtml(stats.entities ?? 0)}</td></tr>
+  <tr><th>Période couverte</th><td colspan="3">${escapeHtml(periode)}</td></tr>
+</table>`;
+
+  const docRows = documents.map((doc) => {
+    const dateLabel = formatDateFr(doc.dateIso) || 'Sans date';
+    const fields = Array.isArray(doc.fields) ? doc.fields : [];
+    const infosHtml = fields.length
+      ? fields.map((field) => `${escapeHtml(field.label)} : ${escapeHtml(field.value)}`).join('<br>')
+      : '';
+    const codes = Array.isArray(doc.codes) ? doc.codes : [];
+    const entitesHtml = codes.length
+      ? codes.map((code) => escapeHtml(code.label || code.code)).join('<br>')
+      : '';
+    return `<tr>
+      <td>${escapeHtml(dateLabel)}</td>
+      <td>${escapeHtml(doc.nature || '')}</td>
+      <td>${escapeHtml(doc.name)}</td>
+      <td>${escapeHtml(doc.localisation || '')}</td>
+      <td>${infosHtml}</td>
+      <td>${entitesHtml}</td>
+    </tr>`;
+  }).join('\n');
+
+  const frizeTableHtml = `
+<h2>Frise chronologique</h2>
+<table width="100%" border="1" cellspacing="0" cellpadding="4">
+  <thead>
+    <tr><th>Date</th><th>Nature</th><th>Pièce</th><th>Lieu</th><th>Informations</th><th>Personnes visées</th></tr>
+  </thead>
+  <tbody>
+    ${docRows || '<tr><td colspan="6" class="export-empty">Aucune pièce indexée.</td></tr>'}
+  </tbody>
+</table>`;
+
+  const entityRows = entities.map((entity) => `<tr>
+      <td>${escapeHtml(entity.label || entity.code)}</td>
+      <td>${escapeHtml(CATEGORY_LABELS[entity.category] || entity.category || '')}</td>
+      <td>${escapeHtml(entity.documentCount ?? 0)}</td>
+    </tr>`).join('\n');
+
+  const entitiesTableHtml = `
+<h2>Entités</h2>
+<table width="100%" border="1" cellspacing="0" cellpadding="4">
+  <thead>
+    <tr><th>Entité</th><th>Catégorie</th><th>Nombre de pièces</th></tr>
+  </thead>
+  <tbody>
+    ${entityRows || '<tr><td colspan="3" class="export-empty">Aucune entité détectée.</td></tr>'}
+  </tbody>
+</table>`;
+
+  // Le graphe (chronology.graph, vis-network interactif) n'a pas d'équivalent
+  // papier et n'est délibérément jamais utilisé ici.
+  const bodyHtml = `${summaryHtml}\n${frizeTableHtml}\n${entitiesTableHtml}`;
+
+  return documentHtml({ title: 'Chronologie du dossier', subtitle, bodyHtml });
+}
+
+/** Rendu HTML papier de la feuille de temps (commits) d'un mois donné. */
+function renderHistoryHtml(entries, { caseName, month } = {}) {
+  const decumulated = decumulateDurations(Array.isArray(entries) ? entries : []);
+
+  const monthLabel = formatMonthFr(month);
+  const subtitle = `${caseName ? `Dossier « ${caseName} » — ` : ''}${monthLabel || (month || '')}`;
+  const authors = [...new Set(decumulated
+    .map((item) => String(item.author || '').trim())
+    .filter(Boolean))];
+  const byline = authors.length
+    ? `${authors.length > 1 ? 'Auteurs' : 'Auteur'} : ${authors.join(', ')}`
+    : '';
+
+  const rows = [];
+  let totalMs = 0;
+
+  for (const item of decumulated) {
+    const timestamp = item.timestamp ? new Date(item.timestamp) : null;
+    const validDate = timestamp && !Number.isNaN(timestamp.getTime());
+    const date = validDate
+      ? timestamp.toLocaleDateString('fr-FR', { day: 'numeric', month: 'long', year: 'numeric' })
+      : 'Date inconnue';
+
+    const ownMs = Number.isFinite(item.ownMs) ? item.ownMs : 0;
+    totalMs += ownMs;
+    const tempsLabel = ownMs > 0 ? (formatDurationFr(ownMs) || '—') : '—';
+    const comment = String(item.comment || '').trim();
+    const commentHtml = comment
+      ? `<div class="export-task-comment"><em>${escapeHtml(comment).replace(/\r?\n/g, '<br>')}</em></div>`
+      : '';
+    const files = Array.isArray(item.files) ? item.files : [];
+    const filesHtml = files.length
+      ? `<div class="export-task-files-label"><em>Fichiers modifiés :</em></div>
+        <ul class="export-task-files">${files.map((file) => `<li>${escapeHtml(file)}</li>`).join('')}</ul>`
+      : '<div class="export-task-files-label"><em>Fichiers modifiés : aucun</em></div>';
+
+    rows.push(`<tr>
+      <td width="18%" class="export-task-date"><strong>${escapeHtml(date)}</strong></td>
+      <td width="64%"><strong class="export-task-title">${escapeHtml(item.subject || '')}</strong>${commentHtml}${filesHtml}</td>
+      <td width="18%" class="export-task-time"><strong>${escapeHtml(tempsLabel)}</strong></td>
+    </tr>`);
+  }
+
+  const totalLabel = totalMs > 0 ? (formatDurationFr(totalMs) || '—') : '—';
+
+  const bodyHtml = `
+<table class="export-timesheet" width="100%" border="1" cellspacing="0" cellpadding="7">
+  <colgroup><col width="18%"><col width="64%"><col width="18%"></colgroup>
+  <thead>
+    <tr><th width="18%">Date</th><th width="64%">Tâches réalisées</th><th width="18%">Temps passé total</th></tr>
+  </thead>
+  <tbody>
+    ${rows.length ? rows.join('\n') : '<tr><td colspan="3" class="export-empty">Aucune tâche pour cette période.</td></tr>'}
+  </tbody>
+  <tfoot>
+    <tr><td colspan="2"><strong>Total du mois</strong></td><td class="export-task-time"><strong>${escapeHtml(totalLabel)}</strong></td></tr>
+  </tfoot>
+</table>`;
+
+  return documentHtml({ title: 'Feuille de temps', byline, subtitle, bodyHtml });
+}
+
+/** `'2026-08'` → `'août 2026'`. Entrée invalide → null. */
+function formatMonthFr(month) {
+  if (typeof month !== 'string') return null;
+  const match = month.match(/^(\d{4})-(\d{2})$/);
+  if (!match) return null;
+  const [, year, monthNum] = match;
+  const asDate = new Date(`${year}-${monthNum}-01T00:00:00Z`);
+  if (Number.isNaN(asDate.getTime())) return null;
+  return asDate.toLocaleDateString('fr-FR', { month: 'long', year: 'numeric', timeZone: 'UTC' });
+}
+
+module.exports = {
+  escapeHtml,
+  documentHtml,
+  formatDateFr,
+  decumulateDurations,
+  renderChronologyHtml,
+  renderHistoryHtml,
+};