@piecemaker-legal/piecemaker 2.0.10 → 2.0.12

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/commits.cjs

@@ -564,33 +564,6 @@ function resolveCase(casesRoot, caseName) {
   return { casesRoot: root, name, root: caseRoot };
 }
 
-function locateCaseFile(casesRoot, filePath) {
-  const root = resolveCasesRoot(casesRoot);
-  const requested = path.resolve(String(filePath || ''));
-  let absolute = requested;
-  try {
-    absolute = fs.realpathSync(requested);
-  } catch {
-    try {
-      absolute = path.join(fs.realpathSync(path.dirname(requested)), path.basename(requested));
-    } catch {}
-  }
-  if (absolute === root || !absolute.startsWith(`${root}${path.sep}`)) return null;
-  const relativeToRoot = path.relative(root, absolute);
-  const [caseName, ...parts] = relativeToRoot.split(path.sep);
-  if (!caseName || parts.length === 0) return null;
-  const legalCase = resolveCase(root, caseName);
-  if (isProtectedFile(absolute, legalCase.root)) {
-    return { ...legalCase, absolute, protected: true, relative: parts.join('/') };
-  }
-  if (path.extname(absolute).toLowerCase() && !SAFE_EXTENSIONS.has(path.extname(absolute).toLowerCase())) {
-    return { ...legalCase, absolute, protected: false, safe: false, relative: parts.join('/') };
-  }
-  const relative = path.relative(legalCase.root, absolute).split(path.sep).join('/');
-  if (!relative || relative.startsWith('../')) return null;
-  return { ...legalCase, absolute, protected: false, safe: SAFE_EXTENSIONS.has(path.extname(relative).toLowerCase()), relative };
-}
-
 async function safeCaseFiles(caseRoot) {
   const startedAt = performance.now();
   const root = await fsp.realpath(caseRoot);
@@ -1668,7 +1641,6 @@ module.exports = {
   logPerformance,
   listHistory,
   listHistoryPeriod,
-  locateCaseFile,
   parseCommitTrailers,
   originalFilesOverview,
   repositoryOverview,

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/hook-io.mjs

@@ -25,8 +25,6 @@ import path from 'node:path';
 
 export const HOME_DIR = path.join(os.homedir(), '.piecemaker');
 export const CONFIG_FILE = path.join(HOME_DIR, 'config.json');
-export const BILLING_DIR = path.join(HOME_DIR, 'billing');
-export const SYNTHESIS_DIR = path.join(BILLING_DIR, 'synthese');
 
 /** Upper bound on waiting for stdout to drain before exiting anyway. */
 const FLUSH_TIMEOUT_MS = 2000;
@@ -236,14 +234,3 @@ export function ensureDirSafe(dir) {
     return false;
   }
 }
-
-/** Append one line to a JSONL file. Single appendFileSync call, never throws. */
-export function appendJsonl(filePath, obj) {
-  try {
-    ensureDirSafe(path.dirname(filePath));
-    fs.appendFileSync(filePath, `${JSON.stringify(obj)}\n`, 'utf8');
-    return true;
-  } catch {
-    return false;
-  }
-}

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/institutional-terms.cjs

@@ -9,9 +9,9 @@
  *
  * On ne débranche pas la détection : GLiNER continue de les trouver. C'est au
  * moment de bâtir le mapping qu'elles sont écartées — `normalizeMappingDocument`
- * (mapping.cjs) appelle `isInstitutionalEntity` sur chaque entité, à la lecture
- * comme à l'écriture. Une entité bannie ne persiste donc jamais dans
- * `mapping_default.json` et n'est jamais substituée par les hooks.
+ * (mapping.cjs) appelle `isInstitutionalEntity` sur chaque entité lue, et le
+ * magasin du dossier les retire de la base. Une entité bannie n'est donc jamais
+ * substituée par les hooks.
  *
  * La liste est globale (tous dossiers confondus), éditable depuis les paramètres
  * de l'administration, et la comparaison est insensible à la casse et aux

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/mapping.cjs

@@ -47,8 +47,7 @@ function readJsonFile(file, fallback = null) {
  * Tous les mappings présents, sous-dossier `WORKSPACE_SUBDIR` **et** racine
  * (lecture tolérante pendant la migration). Le fichier canonique du sous-dossier
  * passe en dernier : c'est lui qui gagne quand `readCaseMapping` fusionne, tandis
- * que les copies legacy (racine ou `mapping_<id>.json`) ne servent qu'à ne rien
- * perdre avant le prochain enregistrement.
+ * que les copies legacy (racine ou `mapping_<id>.json`) complètent la lecture.
  */
 function existingMappingFiles(caseRoot) {
   const dirs = [
@@ -80,113 +79,27 @@ function existingMappingFiles(caseRoot) {
 }
 
 /**
- * L'unique cible d'écriture par dossier vit désormais dans le sous-dossier
- * `WORKSPACE_SUBDIR`, pour garder la racine propre. Les anciens
- * `mapping_dossier.json` / `mapping_<id>.json` et un `mapping_default.json` resté
- * à la racine sont lus pour migration (voir `existingMappingFiles`), mais toute
- * écriture converge vers `<dossier>/<WORKSPACE_SUBDIR>/mapping_default.json`.
+ * Emplacement historique du mapping JSON d'un dossier, lu seulement : plus
+ * aucun code ne l'écrit, le mapping vit en base.
  */
 function caseMappingFile(caseRoot) {
   return path.join(caseRoot, WORKSPACE_SUBDIR, CANONICAL_MAPPING_FILE);
 }
 
-function cleanMappingString(value) {
-  return String(value || '').trim();
-}
-
-function normalizePartyAssignments(value) {
-  if (!Array.isArray(value)) return [];
-  return value.map((raw) => {
-    const assignment = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
-    const variants = [...new Set((Array.isArray(assignment.variants) ? assignment.variants : [])
-      .map(cleanMappingString).filter(Boolean))];
-    return {
-      field: cleanMappingString(assignment.field),
-      code: cleanMappingString(assignment.code),
-      original_code: cleanMappingString(assignment.original_code),
-      category: cleanMappingString(assignment.category),
-      principal: cleanMappingString(assignment.principal),
-      variants,
-    };
-  }).filter((assignment) => assignment.code && assignment.variants.length);
-}
-
-function normalizeProcedureParty(raw, side) {
-  const party = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
-  const type = party.type === 'societe' ? 'societe' : 'personne_physique';
-  const allowedPositions = new Set(['demandeur', 'defendeur', 'appelant', 'intime', 'requerant', 'mis_en_cause', 'intervenant', 'autre']);
-  const position = allowedPositions.has(party.position) ? party.position : side === 'client' ? 'demandeur' : 'defendeur';
-  return {
-    type,
-    position,
-    position_libelle: position === 'autre' ? cleanMappingString(party.position_libelle) : '',
-    civilite: type === 'personne_physique' ? cleanMappingString(party.civilite) : '',
-    nom: type === 'personne_physique' ? cleanMappingString(party.nom) : '',
-    date_naissance: type === 'personne_physique' ? cleanMappingString(party.date_naissance) : '',
-    lieu_naissance: type === 'personne_physique' ? cleanMappingString(party.lieu_naissance) : '',
-    adresse: type === 'personne_physique' ? cleanMappingString(party.adresse) : '',
-    societe_nom: type === 'societe' ? cleanMappingString(party.societe_nom) : '',
-    forme_sociale: type === 'societe' ? cleanMappingString(party.forme_sociale) : '',
-    pays: type === 'societe' ? cleanMappingString(party.pays) || 'France' : '',
-    siren: type === 'societe' ? cleanMappingString(party.siren) : '',
-    siege_social: type === 'societe' ? cleanMappingString(party.siege_social) : '',
-    representant: type === 'societe' ? cleanMappingString(party.representant) : '',
-    mapping_assignments: normalizePartyAssignments(party.mapping_assignments),
-  };
-}
-
-function relationshipId(source, target, role) {
-  return `relation:${source}\u0000${target}\u0000${role}`;
-}
-
-function normalizeProfileRelationships(value) {
-  if (!Array.isArray(value)) return [];
-  const ids = new Set();
-  const relationships = new Set();
-  return value.flatMap((raw) => {
-    const relationship = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
-    const source = cleanMappingString(relationship.source);
-    const original_source = cleanMappingString(relationship.original_source);
-    const target = cleanMappingString(relationship.target);
-    const role = cleanMappingString(relationship.role);
-    const id = cleanMappingString(relationship.id) || relationshipId(source, target, role);
-    const key = `${source}\u0000${target}\u0000${role}`;
-    if (!source || !target || !role || source === target || ids.has(id) || relationships.has(key)) return [];
-    ids.add(id);
-    relationships.add(key);
-    return [{ id, source, original_source, target, role }];
-  });
-}
-
-function normalizeProcedureInfo(raw) {
-  const info = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
-  return {
-    parties_clientes: (Array.isArray(info.parties_clientes) ? info.parties_clientes : [])
-      .map((party) => normalizeProcedureParty(party, 'client')),
-    parties_adverses: (Array.isArray(info.parties_adverses) ? info.parties_adverses : [])
-      .map((party) => normalizeProcedureParty(party, 'adversaire')),
-    relations: normalizeProfileRelationships(info.relations),
-  };
-}
-
 function normalizeMappingDocument(raw) {
   const document = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
   const mapping = {};
   const reverse = {};
   const source = document.mapping && typeof document.mapping === 'object' ? document.mapping : {};
   // Les entités institutionnelles (juridictions, registres, publications
-  // officielles…) sont écartées ici même : c'est le point de passage unique de la
-  // lecture comme de l'écriture, si bien qu'une entité bannie ne persiste jamais
-  // dans `mapping_default.json` et n'est jamais substituée par les hooks. GLiNER
-  // continue de les détecter — on ne débranche que le codage.
+  // officielles…) sont écartées ici même, à la lecture : une entité bannie n'est
+  // jamais substituée par les hooks. GLiNER continue de les détecter — on ne
+  // débranche que le codage.
   for (const [entity, code] of Object.entries(source)) {
     const from = String(entity || '').trim();
     const to = String(code || '').trim();
     if (from && to && !isInstitutionalEntity(from)) mapping[from] = to;
   }
-  const ignored = [...new Set((Array.isArray(document.ignored) ? document.ignored : [])
-    .map((entity) => String(entity || '').trim())
-    .filter(Boolean))];
   const reverseSource = document.reverse_mapping && typeof document.reverse_mapping === 'object' ? document.reverse_mapping : {};
   for (const [code, value] of Object.entries(reverseSource)) {
     const key = String(code || '').trim();
@@ -202,36 +115,10 @@ function normalizeMappingDocument(raw) {
     if (!reverse[code]) reverse[code] = [entity];
     else if (!reverse[code].includes(entity)) reverse[code].push(entity);
   }
-  // `extracted_data` est écrit par `convert_and_scan_pipeline.py` : c'est lui
-  // qui porte les variants d'une entité et l'analyse des adresses, dont la
-  // dé-anonymisation partielle a besoin (anonymization-server.cjs).
-  // L'administration ne l'édite pas, mais elle ne doit surtout pas le détruire —
-  // seules les entrées dont le code a disparu du mapping sont retirées.
-  const extracted = {};
-  const extractedSource = document.extracted_data && typeof document.extracted_data === 'object'
-    && !Array.isArray(document.extracted_data) ? document.extracted_data : {};
-  for (const [category, codes] of Object.entries(extractedSource)) {
-    if (!codes || typeof codes !== 'object' || Array.isArray(codes)) continue;
-    extracted[category] = Object.fromEntries(
-      Object.entries(codes).filter(([code]) => reverse[code])
-    );
-  }
-  return {
-    mapping,
-    reverse_mapping: reverse,
-    extracted_data: extracted,
-    ignored: ignored.filter((entity) => !mapping[entity]),
-    informations_dossier: normalizeProcedureInfo(document.informations_dossier),
-  };
+  return { mapping, reverse_mapping: reverse };
 }
 
 /** L'ordre d'écriture suit `byDescendingEntityLength`. */
-function sortedMapping(mapping) {
-  return Object.fromEntries(
-    Object.entries(mapping).sort((a, b) => b[0].length - a[0].length || a[0].localeCompare(b[0], 'fr'))
-  );
-}
-
 function readCaseMapping(caseRoot) {
   const file = caseMappingFile(caseRoot);
   const sourceFiles = existingMappingFiles(caseRoot);
@@ -239,15 +126,10 @@ function readCaseMapping(caseRoot) {
     return { file, sourceFiles: [], exists: false, ...normalizeMappingDocument(null) };
   }
 
-  // Migration non destructive à la lecture : tous les anciens mappings sont
-  // réunis en mémoire. Le canonique passe en dernier et gagne donc si une même
-  // entité a été recodée. Le prochain enregistrement écrira l'ensemble dans le
-  // seul `mapping_default.json`.
+  // Tous les anciens mappings sont réunis en mémoire. Le canonique passe en
+  // dernier et gagne donc si une même entité a été recodée.
   const mapping = {};
   const preferredVariants = {};
-  const extracted_data = {};
-  const ignored = [];
-  let informations_dossier = normalizeProcedureInfo();
   const readableFiles = [];
   for (const sourceFile of sourceFiles) {
     const raw = readJsonFile(sourceFile, null);
@@ -255,18 +137,9 @@ function readCaseMapping(caseRoot) {
     readableFiles.push(sourceFile);
     const document = normalizeMappingDocument(raw);
     Object.assign(mapping, document.mapping);
-    ignored.push(...document.ignored);
     for (const [code, variants] of Object.entries(document.reverse_mapping)) {
       preferredVariants[code] = [...new Set([...(preferredVariants[code] || []), ...variants])];
     }
-    for (const [category, codes] of Object.entries(document.extracted_data)) {
-      extracted_data[category] = { ...(extracted_data[category] || {}), ...codes };
-    }
-    if (path.basename(sourceFile) === CANONICAL_MAPPING_FILE
-        || document.informations_dossier.parties_clientes.length
-        || document.informations_dossier.parties_adverses.length) {
-      informations_dossier = document.informations_dossier;
-    }
   }
 
   const reverse_mapping = {};
@@ -281,7 +154,7 @@ function readCaseMapping(caseRoot) {
     file,
     sourceFiles: readableFiles,
     exists: readableFiles.length > 0,
-    ...normalizeMappingDocument({ mapping, reverse_mapping, extracted_data, ignored, informations_dossier }),
+    ...normalizeMappingDocument({ mapping, reverse_mapping }),
   };
 }
 
@@ -302,15 +175,9 @@ module.exports = {
   applyMapping,
   buildEntityRegex,
   byDescendingEntityLength,
-  caseMappingFile,
   escapeWithVariants,
-  normalizeMappingDocument,
-  normalizeProcedureInfo,
   readCaseMapping,
-  readJsonFile,
   resolveProjectCaseMapping,
   resolveMappedPath,
   revertMapping,
-  sortedMapping,
-  CANONICAL_MAPPING_FILE,
 };

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/protection.cjs

@@ -30,7 +30,7 @@ const PROTECTION_FILE = 'protection.json';
 const PROTECTION_BYPASS_FILE = 'protection-bypass.json';
 
 /**
- * Sous-dossier technique historique et emplacement du `mapping_default.json`.
+ * Sous-dossier technique historique (ancien emplacement du mapping JSON).
  * Le Markdown courant vit dans les sous-dossiers de conversion de
  * Correspondance et Data Room ; ce repli reste nécessaire aux anciens dossiers
  * et aux espaces de travail OOXML. `mapping.cjs` et `commits.cjs` l'importent.

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/session-timing.cjs

@@ -1,66 +1,3 @@
-/**
- * Session timing helpers shared by the commit and billing hooks.
- *
- * A hook runs once per event with no memory of the session's start. The
- * transcript is the only durable clock: its first entry's `timestamp` is the
- * session start. `commit-track.mjs` needs that start on every Write/Edit to
- * stamp the elapsed session time into the commit, so reading the whole
- * transcript on each tool call would be wasteful — we only need the first
- * timestamp, so we scan a bounded head of the file.
- *
- * Everything here fails soft: an unreadable/empty/malformed transcript yields
- * `null`, and the caller simply omits the time trailer.
- */
-const fs = require('node:fs');
-
-// Enough to comfortably contain the first JSONL record even with a large
-// system prompt echoed into it; we stop at the first line that parses.
-const HEAD_BYTES = 256 * 1024;
-
-/** First ISO timestamp in the transcript (session start), or null. */
-function readSessionStartTimestamp(transcriptPath) {
-  if (!transcriptPath) return null;
-  let fd;
-  try {
-    fd = fs.openSync(transcriptPath, 'r');
-    const stat = fs.fstatSync(fd);
-    const length = Math.min(stat.size, HEAD_BYTES);
-    if (length === 0) return null;
-    const buffer = Buffer.allocUnsafe(length);
-    const bytesRead = fs.readSync(fd, buffer, 0, length, 0);
-    const text = buffer.subarray(0, bytesRead).toString('utf8');
-    for (const line of text.split('\n')) {
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-      // The last line of a partial head read may be truncated; ignore parse
-      // failures and keep looking for the first fully-formed record.
-      let entry;
-      try {
-        entry = JSON.parse(trimmed);
-      } catch {
-        continue;
-      }
-      const ts = entry?.timestamp || entry?.message?.timestamp;
-      if (ts && Number.isFinite(Date.parse(ts))) return ts;
-    }
-    return null;
-  } catch {
-    return null;
-  } finally {
-    if (fd !== undefined) {
-      try { fs.closeSync(fd); } catch {}
-    }
-  }
-}
-
-/** Milliseconds elapsed between the session's first entry and `now`. */
-function sessionElapsedMs(transcriptPath, now = Date.now()) {
-  const start = readSessionStartTimestamp(transcriptPath);
-  if (!start) return null;
-  const ms = now - Date.parse(start);
-  return Number.isFinite(ms) && ms >= 0 ? ms : null;
-}
-
 /** Compact French duration, e.g. "12 min 30 s", "1 h 05 min", "8 s". */
 function formatDurationFr(ms) {
   if (!Number.isFinite(ms) || ms < 0) return null;
@@ -75,6 +12,4 @@ function formatDurationFr(ms) {
 
 module.exports = {
   formatDurationFr,
-  readSessionStartTimestamp,
-  sessionElapsedMs,
 };

package/server/piecemaker/vendor/piecemaker-plugin/scripts/lib/substitution.cjs

@@ -115,6 +115,157 @@ function byDescendingEntityLength(getEntity) {
   };
 }
 
+function mappingSignature(entries) {
+  let signature = '';
+  for (const [key, value] of entries) signature += key + '\u0000' + value + '\u0001';
+  return signature;
+}
+
+function literalAnchor(value) {
+  const runs = String(value).match(/[A-Za-z0-9_]+/g) || [];
+  return runs.reduce((longest, run) => (run.length > longest.length ? run : longest), '');
+}
+
+const ANCHOR_WIDTH = 37;
+const ANCHOR_SYMBOL = new Int8Array(128).fill(-1);
+for (let letter = 0; letter < 26; letter += 1) {
+  ANCHOR_SYMBOL[65 + letter] = letter;
+  ANCHOR_SYMBOL[97 + letter] = letter;
+}
+for (let digit = 0; digit < 10; digit += 1) ANCHOR_SYMBOL[48 + digit] = 26 + digit;
+ANCHOR_SYMBOL[95] = 36;
+const KELVIN_SIGN = 0x212A;
+const LONG_S = 0x017F;
+
+function anchorSymbol(unit) {
+  if (unit < 128) return ANCHOR_SYMBOL[unit];
+  if (unit === KELVIN_SIGN) return ANCHOR_SYMBOL[107];
+  if (unit === LONG_S) return ANCHOR_SYMBOL[115];
+  return -1;
+}
+
+function buildAnchorScanner(anchors) {
+  let transitions = new Int32Array(ANCHOR_WIDTH * 16).fill(-1);
+  const outputs = [[]];
+  let size = 1;
+  anchors.forEach((anchor, index) => {
+    if (!anchor) return;
+    let node = 0;
+    for (let position = 0; position < anchor.length; position += 1) {
+      const slot = node * ANCHOR_WIDTH + ANCHOR_SYMBOL[anchor.charCodeAt(position)];
+      if (transitions[slot] === -1) {
+        if ((size + 1) * ANCHOR_WIDTH > transitions.length) {
+          const grown = new Int32Array(transitions.length * 2).fill(-1);
+          grown.set(transitions);
+          transitions = grown;
+        }
+        transitions[slot] = size;
+        outputs.push([]);
+        size += 1;
+      }
+      node = transitions[slot];
+    }
+    outputs[node].push(index);
+  });
+
+  const failure = new Int32Array(size);
+  const queue = [];
+  for (let symbol = 0; symbol < ANCHOR_WIDTH; symbol += 1) {
+    const child = transitions[symbol];
+    if (child === -1) transitions[symbol] = 0;
+    else queue.push(child);
+  }
+  for (let head = 0; head < queue.length; head += 1) {
+    const node = queue[head];
+    outputs[node] = outputs[node].concat(outputs[failure[node]]);
+    for (let symbol = 0; symbol < ANCHOR_WIDTH; symbol += 1) {
+      const slot = node * ANCHOR_WIDTH + symbol;
+      const child = transitions[slot];
+      if (child === -1) {
+        transitions[slot] = transitions[failure[node] * ANCHOR_WIDTH + symbol];
+      } else {
+        failure[child] = transitions[failure[node] * ANCHOR_WIDTH + symbol];
+        queue.push(child);
+      }
+    }
+  }
+
+  const next = new Int32Array(size * ANCHOR_WIDTH);
+  for (let slot = 0; slot < next.length; slot += 1) next[slot] = transitions[slot] * ANCHOR_WIDTH;
+  const emitted = new Array(size * ANCHOR_WIDTH).fill(null);
+  for (let node = 0; node < size; node += 1) if (outputs[node].length) emitted[node * ANCHOR_WIDTH] = outputs[node];
+
+  return (text) => {
+    const found = new Set();
+    let state = 0;
+    for (let position = 0; position < text.length; position += 1) {
+      const symbol = anchorSymbol(text.charCodeAt(position));
+      if (symbol === -1) {
+        state = 0;
+        continue;
+      }
+      state = next[state + symbol];
+      const matched = emitted[state];
+      if (matched !== null) for (const index of matched) found.add(index);
+    }
+    return found;
+  };
+}
+
+function compileReplacements(replacements) {
+  return { replacements, scan: buildAnchorScanner(replacements.map(({ anchor }) => anchor.toLowerCase())) };
+}
+
+function isDeeplyFrozen(object) {
+  return Object.isFrozen(object) && Object.values(object).every((value) => !Array.isArray(value) || Object.isFrozen(value));
+}
+
+const compiledMappings = new WeakMap();
+
+function compileMapping(mapping) {
+  const cached = compiledMappings.get(mapping);
+  if (cached && cached.frozen) return cached;
+  const entries = Object.entries(mapping);
+  const signature = mappingSignature(entries);
+  if (cached && cached.signature === signature) return cached;
+
+  const codes = [...new Set(entries.map(([, code]) => String(code)).filter(Boolean))]
+    .sort((a, b) => b.length - a.length);
+  const replacements = [];
+  for (const [entity, code] of entries.sort(byDescendingEntityLength(([key]) => key))) {
+    const regex = buildEntityRegex(entity);
+    if (!regex) continue;
+    const trimmed = entity.trim();
+    replacements.push({ regex, code, anchor: literalAnchor(regex.flags.includes('i') ? trimmed : trimmed.toUpperCase()) });
+  }
+  const compiled = {
+    frozen: Object.isFrozen(mapping),
+    signature,
+    codes,
+    codeProbe: codes.length ? new RegExp(codes.map(escapeRegex).join('|')) : null,
+    replacements: compileReplacements(replacements),
+  };
+  compiledMappings.set(mapping, compiled);
+  return compiled;
+}
+
+function applyReplacements({ replacements, scan }, text) {
+  let output = text;
+  let present = null;
+  replacements.forEach(({ regex, code, anchor }, index) => {
+    if (anchor) {
+      if (present === null) present = scan(output);
+      if (!present.has(index)) return;
+    }
+    const next = output.replace(regex, code);
+    if (next !== output) {
+      output = next;
+      present = null;
+    }
+  });
+  return output;
+}
+
 /**
  * Entité → code. Les entrées passent de la plus longue à la plus courte pour
  * qu'un nom contenu dans un autre ne consomme jamais le plus long en premier
@@ -122,41 +273,49 @@ function byDescendingEntityLength(getEntity) {
  */
 function applyMapping(text, mapping) {
   if (typeof text !== 'string' || !text) return text;
-  const entries = Object.entries(mapping || {});
-  if (!entries.length) return text;
-
-  // Masquage préalable des codes déjà présents dans le texte. La substitution en
-  // sous-chaîne (≥ 3 car.) et l'underscore-séparateur (acronymes 2 car.)
-  // pourraient sinon réécrire l'intérieur d'un code — « SA » dans « URGOT SA »,
-  // « Moral » dans « PERSONNE_MORALE_01 » — et le corrompre. Chaque code distinct
-  // est remplacé par un caractère de zone privée (ni lettre ni chiffre, absent des
-  // documents, jamais matché par une regex d'entité), on anonymise, puis on
-  // restaure. C'est aussi ce qui garantit l'idempotence : réappliquer le mapping à
-  // un texte déjà codé masque ses codes et ne touche à rien. Codes triés du plus
-  // long au plus court pour qu'un code contenu dans un autre ne soit pas masqué
-  // en premier.
-  const codes = [...new Set(entries.map(([, code]) => String(code)).filter(Boolean))]
-    .sort((a, b) => b.length - a.length);
+  if (!mapping || typeof mapping !== 'object') return text;
+  const compiled = compileMapping(mapping);
+  if (!compiled.replacements.replacements.length) return text;
+
   const restore = [];
   let masked = text;
-  codes.forEach((code, idx) => {
-    if (!masked.includes(code)) return;
-    const token = String.fromCodePoint(0xE000 + idx);
-    restore.push([token, code]);
-    masked = masked.split(code).join(token);
-  });
-
-  let output = masked;
-  for (const [entity, code] of entries.sort(byDescendingEntityLength(([key]) => key))) {
-    const regex = buildEntityRegex(entity);
-    if (!regex) continue;
-    output = output.replace(regex, code);
+  if (compiled.codeProbe && compiled.codeProbe.test(text)) {
+    compiled.codes.forEach((code, idx) => {
+      if (!masked.includes(code)) return;
+      const token = String.fromCodePoint(0xE000 + idx);
+      restore.push([token, code]);
+      masked = masked.split(code).join(token);
+    });
   }
 
+  let output = applyReplacements(compiled.replacements, masked);
+  if (output === masked) return text;
+
   for (const [token, code] of restore) output = output.split(token).join(code);
   return output;
 }
 
+const compiledReverseMappings = new WeakMap();
+
+function compileReverseMapping(reverseMapping) {
+  const cached = compiledReverseMappings.get(reverseMapping);
+  if (cached && cached.frozen) return cached;
+  const entries = Object.entries(reverseMapping);
+  const signature = mappingSignature(entries.map(([code, variants]) => [code, Array.isArray(variants) ? variants[0] : variants]));
+  if (cached && cached.signature === signature) return cached;
+
+  const replacements = [];
+  for (const [code, variants] of entries.sort(byDescendingEntityLength(([key]) => key))) {
+    const canonical = Array.isArray(variants) ? variants[0] : variants;
+    if (!canonical) continue;
+    const regex = new RegExp(`${WORD_BOUNDARY_BEFORE}${escapeRegex(String(code))}${WORD_BOUNDARY_AFTER}`, 'giu');
+    replacements.push({ regex, code: String(canonical), anchor: literalAnchor(code) });
+  }
+  const compiled = { frozen: isDeeplyFrozen(reverseMapping), signature, replacements: compileReplacements(replacements) };
+  compiledReverseMappings.set(reverseMapping, compiled);
+  return compiled;
+}
+
 /**
  * Code → entité. Le premier variant du tableau fait foi : c'est l'orthographe
  * canonique retenue par `consolidate_duplicate_entities`, celle qu'un humain
@@ -175,20 +334,9 @@ function applyMapping(text, mapping) {
  */
 function revertMapping(text, reverseMapping) {
   if (typeof text !== 'string' || !text) return text;
-  const entries = Object.entries(reverseMapping || {});
-  if (!entries.length) return text;
-
-  let output = text;
-  for (const [code, variants] of entries.sort(byDescendingEntityLength(([key]) => key))) {
-    const canonical = Array.isArray(variants) ? variants[0] : variants;
-    if (!canonical) continue;
-    // Un code est un identifiant ASCII : pas de variantes Unicode à gérer, mais
-    // les mêmes frontières de mots, pour ne pas réécrire un code cité dans un
-    // mot plus long.
-    const regex = new RegExp(`${WORD_BOUNDARY_BEFORE}${escapeRegex(String(code))}${WORD_BOUNDARY_AFTER}`, 'giu');
-    output = output.replace(regex, String(canonical));
-  }
-  return output;
+  if (!reverseMapping || typeof reverseMapping !== 'object') return text;
+  const compiled = compileReverseMapping(reverseMapping);
+  return applyReplacements(compiled.replacements, text);
 }
 
 function normalizedPathName(value) {