@gitwand/core 2.3.0 → 2.4.1

package/dist/__tests__/v2-core-scenarios.test.js

@@ -0,0 +1,692 @@
+/**
+ * Tests d'intégration "grandeur nature" v2.x — scénarios de régression
+ *
+ * Couvre les apports majeurs de chaque release mineure du moteur :
+ *
+ *   v2.1 — Histogram diff & block-move detection
+ *     · `same_change` (renommage a,b→x,y) isolé malgré des insertions adjacentes
+ *     · `insertion_at_boundary` (multiply vs divide) résolu sans conflit
+ *     · `detectBlockMove` détecte un déplacement de bloc
+ *
+ *   v2.2 — Format profile registry + JSON Patch arrays
+ *     · `package.json` /dependencies, /keywords, /scripts résolu via profil
+ *     · `tsconfig.json` /include résolu via stratégie "set"
+ *     · `disableFormatProfiles` rétablit le comportement v2.1
+ *
+ *   v2.3 — Structural TypeScript merge (tree-sitter)
+ *     · Deux branches ajoutent des fonctions TS différentes → merge structural
+ *     · Conflit sur le corps d'une même fonction → structural retourne null
+ *
+ *   v2.4 — Validation parse-tree post-merge & rétraction
+ *     · parseTreeValid: true après résolution propre
+ *     · parseTreeValid: false + rétraction sur fichier syntaxiquement cassé
+ *     · parseTreeValid: null sur fichier non supporté (.json)
+ *     · resolve() synchrone → parseTreeValid toujours null
+ *
+ * Convention de non-flakiness (héritée de grandeur-nature.test.ts) :
+ *   Les assertions qui requièrent WASM sont gardées par
+ *   `if (merged === null) return;` ou `if (!WASM) return;`
+ *   afin que les tests restent verts en CI sans peer optionnels.
+ *
+ * Le contenu hardcodé correspond exactement aux fichiers créés dans
+ * `_tmp_split_scenario` par `setup-v2-scenarios.sh`.
+ */
+import { describe, it, expect, beforeAll } from "vitest";
+import { resolve, resolveAsync } from "../resolver/index.js";
+import { tryStructuralMergeResolve } from "../structural/index.js";
+import { checkParseTreeValid, applyPostMergeRiskPenalty } from "../resolver/validate-parse-tree.js";
+import { tryResolveJsonConflict } from "../resolvers/json.js";
+import { histogramDiff } from "../diff/histogram.js";
+import { detectBlockMove } from "../diff/block-move.js";
+import { _resetCache } from "../structural/parsers/loader.js";
+beforeAll(() => {
+    _resetCache();
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+/** Construit un conflit au format diff3. */
+function diff3(ours, base, theirs) {
+    return `<<<<<<< ours\n${ours}||||||| base\n${base}=======\n${theirs}>>>>>>> theirs\n`;
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// ── v2.1 — Histogram diff & block-move detection ─────────────────────────────
+//
+// Scénario : branche v2.1-ours vs v2.1-theirs depuis split-base.
+//
+//   split-base   : add(a,b) + subtract(a,b)
+//   v2.1-ours    : rename add→add(x,y), add multiply(), reorder subtract après multiply
+//   v2.1-theirs  : rename add→add(x,y), add divide()
+//
+// Conflits attendus :
+//   Hunk 1 — same_change  : le renommage a,b→x,y dans add()
+//   Hunk 2 — insertion_at_boundary : multiply (ours) vs divide (theirs) en fin de fichier
+// ─────────────────────────────────────────────────────────────────────────────
+/** Fichier de base (split-base). */
+const V21_BASE = `// Tiny calculator module — educational demo
+export function add(a, b) {
+  return a + b;
+}
+
+export function subtract(a, b) {
+  return a - b;
+}
+`;
+/** Branche ours : rename + multiply + reorder subtract. */
+const V21_OURS = `// Tiny calculator module — educational demo
+export function add(x, y) {
+  return x + y;
+}
+
+export function multiply(a, b) {
+  return a * b;
+}
+
+export function subtract(a, b) {
+  return a - b;
+}
+`;
+/** Branche theirs : rename + divide. */
+const V21_THEIRS = `// Tiny calculator module — educational demo
+export function add(x, y) {
+  return x + y;
+}
+
+export function subtract(a, b) {
+  return a - b;
+}
+
+export function divide(a, b) {
+  if (b === 0) throw new Error("division by zero");
+  return a / b;
+}
+`;
+describe("v2.1 — same_change (renommage a,b→x,y isolé par histogram)", () => {
+    // Git produit un conflit sur le renommage add(a,b)→add(x,y) que les deux
+    // branches ont fait identiquement. Histogram ancre sur les lignes uniques
+    // (return / export function subtract) pour isoler ce hunk précisément.
+    const CONFLICT = diff3("export function add(x, y) {\n  return x + y;\n}\n", "export function add(a, b) {\n  return a + b;\n}\n", "export function add(x, y) {\n  return x + y;\n}\n");
+    it("résout automatiquement le same_change", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        expect(result.stats.autoResolved).toBe(1);
+        expect(result.stats.remaining).toBe(0);
+        expect(result.mergedContent).toContain("add(x, y)");
+    });
+    it("type classifié same_change", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        expect(result.hunks[0]?.type).toBe("same_change");
+    });
+    it("confiance ≥ high (score ≥ 68)", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        const score = result.hunks[0]?.confidence.score ?? 0;
+        expect(score).toBeGreaterThanOrEqual(68);
+    });
+});
+describe("v2.1 — insertion_at_boundary (multiply vs divide en fin de fichier)", () => {
+    // insertion_at_boundary requiert des lignes uniques de chaque côté pour que
+    // le LCS détecte correctement les additions sans faux-positifs sur les lignes
+    // communes comme `}`. On représente les exports du calculator en lignes uniques.
+    // Base : add + subtract ; ours ajoute multiply ; theirs ajoute divide.
+    const CONFLICT = diff3(
+    // ours : base + multiply
+    "  add,\n  subtract,\n  multiply,\n", 
+    // base
+    "  add,\n  subtract,\n", 
+    // theirs : base + divide
+    "  add,\n  subtract,\n  divide,\n");
+    it("résout automatiquement le hunk d'insertion (insertion_at_boundary)", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        expect(result.stats.autoResolved).toBeGreaterThanOrEqual(1);
+    });
+    it("type classifié insertion_at_boundary", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        const type = result.hunks[0]?.type;
+        expect(type).toBe("insertion_at_boundary");
+    });
+    it("le résultat contient les deux exports ajoutés", () => {
+        const result = resolve(CONFLICT, "calculator.js");
+        if (!result.mergedContent)
+            return;
+        expect(result.mergedContent).toContain("multiply");
+        expect(result.mergedContent).toContain("divide");
+    });
+});
+describe("v2.1 — histogramDiff ancre sur les lignes rares", () => {
+    it("ancre sur la signature unique et non sur les accolades communes", () => {
+        const a = V21_BASE.split("\n");
+        const b = V21_OURS.split("\n");
+        const pairs = histogramDiff(a, b);
+        // Les paires doivent être valides
+        for (const [i, j] of pairs) {
+            expect(a[i]).toBe(b[j]);
+        }
+        // Les indices doivent être strictement croissants
+        for (let k = 1; k < pairs.length; k++) {
+            expect(pairs[k][0]).toBeGreaterThan(pairs[k - 1][0]);
+            expect(pairs[k][1]).toBeGreaterThan(pairs[k - 1][1]);
+        }
+    });
+    it("ne lève jamais d'exception sur des séquences vides", () => {
+        expect(() => histogramDiff([], [])).not.toThrow();
+        expect(() => histogramDiff(V21_BASE.split("\n"), [])).not.toThrow();
+    });
+});
+describe("v2.1 — detectBlockMove : subtract déplacé après multiply dans ours", () => {
+    it("ne lève jamais d'exception", () => {
+        expect(() => detectBlockMove(V21_BASE.split("\n"), V21_OURS.split("\n"), V21_THEIRS.split("\n"))).not.toThrow();
+    });
+    it("détecte le bloc subtract déplacé dans ours quand suffisamment grand", () => {
+        // detectBlockMove requiert windowSize lignes consécutives (default 3).
+        // Notre bloc subtract fait exactement 3 lignes → résultat possible.
+        const moves = detectBlockMove(V21_BASE.split("\n"), V21_OURS.split("\n"), V21_THEIRS.split("\n"));
+        // Peut être vide si le bloc est trop petit pour la fenêtre — mais ne doit pas throw.
+        expect(Array.isArray(moves)).toBe(true);
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// ── v2.2 — Format profile registry + JSON Patch arrays ───────────────────────
+//
+// Scénario : v2.2-ours vs v2.2-theirs depuis v2.2-base.
+//
+//   v2.2-base   : package.json avec debug dep, "math" keyword, "test" script
+//                 tsconfig.json avec include: ["src"]
+//   v2.2-ours   : + axios, + "calculator" keyword, + "build" script, + "test" include
+//   v2.2-theirs : + lodash, + "utility" keyword, + "lint" script, + "types" include
+//
+// Chaque conflict array est résolu via JSON Patch (stratégie "set").
+// ─────────────────────────────────────────────────────────────────────────────
+const PKG_BASE = `{
+  "name": "calculator",
+  "version": "1.0.0",
+  "description": "Tiny calculator module — educational demo",
+  "keywords": [
+    "math"
+  ],
+  "scripts": {
+    "test": "node test.js"
+  },
+  "dependencies": {
+    "debug": "^4.0.0"
+  }
+}`;
+const PKG_OURS = `{
+  "name": "calculator",
+  "version": "1.0.0",
+  "description": "Tiny calculator module — educational demo",
+  "keywords": [
+    "math",
+    "calculator"
+  ],
+  "scripts": {
+    "test": "node test.js",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "debug": "^4.0.0",
+    "axios": "^1.7.0"
+  }
+}`;
+const PKG_THEIRS = `{
+  "name": "calculator",
+  "version": "1.0.0",
+  "description": "Tiny calculator module — educational demo",
+  "keywords": [
+    "math",
+    "utility"
+  ],
+  "scripts": {
+    "test": "node test.js",
+    "lint": "eslint ."
+  },
+  "dependencies": {
+    "debug": "^4.0.0",
+    "lodash": "^4.17.21"
+  }
+}`;
+const TSCONFIG_BASE = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src"
+  ]
+}`;
+const TSCONFIG_OURS = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src",
+    "test"
+  ]
+}`;
+const TSCONFIG_THEIRS = `{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "outDir": "dist"
+  },
+  "include": [
+    "src",
+    "types"
+  ]
+}`;
+describe("v2.2 — package.json : profil résout keywords, scripts, dependencies", () => {
+    it("/keywords — set merge : math + calculator + utility", () => {
+        const result = tryResolveJsonConflict(PKG_BASE.split("\n"), PKG_OURS.split("\n"), PKG_THEIRS.split("\n"), "package.json");
+        expect(result.merged).not.toBeNull();
+        const parsed = JSON.parse(result.merged);
+        expect(parsed.keywords).toContain("math");
+        expect(parsed.keywords).toContain("calculator");
+        expect(parsed.keywords).toContain("utility");
+    });
+    it("/dependencies — set merge : debug + axios + lodash", () => {
+        const result = tryResolveJsonConflict(PKG_BASE.split("\n"), PKG_OURS.split("\n"), PKG_THEIRS.split("\n"), "package.json");
+        expect(result.merged).not.toBeNull();
+        const parsed = JSON.parse(result.merged);
+        expect(parsed.dependencies["debug"]).toBeDefined();
+        expect(parsed.dependencies["axios"]).toBeDefined();
+        expect(parsed.dependencies["lodash"]).toBeDefined();
+    });
+    it("/scripts — merge : test + build + lint présents", () => {
+        const result = tryResolveJsonConflict(PKG_BASE.split("\n"), PKG_OURS.split("\n"), PKG_THEIRS.split("\n"), "package.json");
+        expect(result.merged).not.toBeNull();
+        const parsed = JSON.parse(result.merged);
+        expect(parsed.scripts["test"]).toBeDefined();
+        expect(parsed.scripts["build"]).toBeDefined();
+        expect(parsed.scripts["lint"]).toBeDefined();
+    });
+    it("le résultat est du JSON valide", () => {
+        const result = tryResolveJsonConflict(PKG_BASE.split("\n"), PKG_OURS.split("\n"), PKG_THEIRS.split("\n"), "package.json");
+        expect(() => JSON.parse(result.merged)).not.toThrow();
+    });
+    it("sans profil (filePath inconnu) — fallback : non résolu", () => {
+        const result = tryResolveJsonConflict(PKG_BASE.split("\n"), PKG_OURS.split("\n"), PKG_THEIRS.split("\n"), "other-file.json");
+        // Pas de profil pour ce fichier → les arrays divergents ne sont pas résolus
+        expect(result.merged).toBeNull();
+    });
+    it("disableFormatProfiles=true — retombe en conflit", () => {
+        const conflictedPkg = diff3(PKG_OURS + "\n", PKG_BASE + "\n", PKG_THEIRS + "\n");
+        const disabled = resolve(conflictedPkg, "package.json", { disableFormatProfiles: true });
+        expect(disabled.stats.autoResolved).toBe(0);
+    });
+});
+describe("v2.2 — tsconfig.json : /include résolu par stratégie set", () => {
+    it("/include — set merge : src + test + types", () => {
+        const result = tryResolveJsonConflict(TSCONFIG_BASE.split("\n"), TSCONFIG_OURS.split("\n"), TSCONFIG_THEIRS.split("\n"), "tsconfig.json");
+        expect(result.merged).not.toBeNull();
+        const parsed = JSON.parse(result.merged);
+        expect(parsed.include).toContain("src");
+        expect(parsed.include).toContain("test");
+        expect(parsed.include).toContain("types");
+    });
+    it("le résultat est du JSON valide et compilerOptions est préservé", () => {
+        const result = tryResolveJsonConflict(TSCONFIG_BASE.split("\n"), TSCONFIG_OURS.split("\n"), TSCONFIG_THEIRS.split("\n"), "tsconfig.json");
+        expect(result.merged).not.toBeNull();
+        const parsed = JSON.parse(result.merged);
+        expect(parsed.compilerOptions.strict).toBe(true);
+        expect(parsed.compilerOptions.outDir).toBe("dist");
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// ── v2.3 — Structural TypeScript merge (tree-sitter) ─────────────────────────
+//
+// Scénario : v2.3-ours vs v2.3-theirs depuis v2.3-base.
+//
+//   v2.3-base   : calculator.ts — add(typed) + subtract(typed)
+//   v2.3-ours   : + power(base, exp) + absolute(n)
+//   v2.3-theirs : + sqrt(n) + floor(n)
+//
+// Git produit un seul grand hunk en fin de fichier (les deux branches ont
+// inséré leurs fonctions au même endroit). Le merge structurel résout en
+// fusionnant entity-par-entity.
+// ─────────────────────────────────────────────────────────────────────────────
+const TS_BASE = `// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+`;
+const TS_OURS = `// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+
+export function power(base: number, exp: number): number {
+  return Math.pow(base, exp);
+}
+
+export function absolute(n: number): number {
+  return Math.abs(n);
+}
+`;
+const TS_THEIRS = `// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+
+export function sqrt(n: number): number {
+  if (n < 0) throw new RangeError("sqrt: argument must be non-negative");
+  return Math.sqrt(n);
+}
+
+export function floor(n: number): number {
+  return Math.floor(n);
+}
+`;
+// Le conflit Git typique pour ce scénario : un seul grand hunk en fin de fichier.
+const TS_CONFLICT = `// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+
+` + diff3(`export function power(base: number, exp: number): number {
+  return Math.pow(base, exp);
+}
+
+export function absolute(n: number): number {
+  return Math.abs(n);
+}
+`, "", `export function sqrt(n: number): number {
+  if (n < 0) throw new RangeError("sqrt: argument must be non-negative");
+  return Math.sqrt(n);
+}
+
+export function floor(n: number): number {
+  return Math.floor(n);
+}
+`);
+describe("v2.3 — structural TypeScript merge : deux branches ajoutent des fonctions différentes", () => {
+    it("tryStructuralMergeResolve résout (quand WASM disponible)", async () => {
+        const merged = await tryStructuralMergeResolve(TS_CONFLICT, "calculator.ts");
+        if (merged === null)
+            return; // WASM non disponible dans cet environnement
+        expect(merged).not.toContain("<<<<<<<");
+        expect(merged).not.toContain("=======");
+        expect(merged).not.toContain(">>>>>>>");
+    });
+    it("le résultat ne contient aucun marqueur de conflit (quand WASM disponible)", async () => {
+        const merged = await tryStructuralMergeResolve(TS_CONFLICT, "calculator.ts");
+        if (merged === null)
+            return; // WASM non disponible
+        expect(merged).not.toContain("<<<<<<<");
+        expect(merged).not.toContain("=======");
+        expect(merged).not.toContain(">>>>>>>");
+        // Les fonctions de base (non conflictuelles) sont toujours préservées
+        expect(merged).toContain("function add");
+        expect(merged).toContain("function subtract");
+    });
+    it("resolveAsync résout entièrement le fichier (quand WASM disponible)", async () => {
+        const result = await resolveAsync(TS_CONFLICT, "calculator.ts");
+        if (!result.mergedContent)
+            return; // WASM non disponible — hunk-based laisse un conflit
+        expect(result.stats.remaining).toBe(0);
+    });
+    it("tryStructuralMergeResolve ne lève jamais d'exception", async () => {
+        await expect(tryStructuralMergeResolve(TS_CONFLICT, "calculator.ts")).resolves.not.toThrow();
+    });
+});
+describe("v2.3 — structural merge : conflit sur le corps d'une même fonction → null", () => {
+    // Les deux branches remplacent le corps de add() différemment.
+    // Le merge structurel doit retourner null (ne peut pas décider).
+    const BODY_CONFLICT = diff3(`// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return (a + b);
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+`, TS_BASE, `// Tiny calculator module — TypeScript version
+export function add(a: number, b: number): number {
+  return a + b || 0;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+`);
+    it("tryStructuralMergeResolve retourne null — conflit réel sur le corps", async () => {
+        const merged = await tryStructuralMergeResolve(BODY_CONFLICT, "calculator.ts");
+        expect(merged).toBeNull();
+    });
+    it("resolveAsync a des conflits restants", async () => {
+        const result = await resolveAsync(BODY_CONFLICT, "calculator.ts");
+        expect(result.stats.remaining).toBeGreaterThan(0);
+        expect(result.mergedContent).toBeNull();
+    });
+});
+// ─────────────────────────────────────────────────────────────────────────────
+// ── v2.4 — Validation parse-tree post-merge & rétraction ─────────────────────
+//
+// Scénario A : happy path — same_change JSDoc sur calculator.ts
+//   Les deux branches ajoutent exactement le même JSDoc sur add().
+//   Résolution → same_change → parseTreeValid: true
+//
+// Scénario B : rétraction — fichier à contexte syntaxiquement cassé
+//   La résolution du hunk (same_change) produit un fichier mergé dont
+//   le parse-tree tree-sitter contient des ERROR nodes.
+//   → parseTreeValid: false + rétraction de toutes les résolutions auto.
+//
+// Scénario C : non supporté — .json → parseTreeValid: null
+// Scénario D : resolve() synchrone → parseTreeValid: null (toujours)
+// ─────────────────────────────────────────────────────────────────────────────
+describe("v2.4A — happy path : parseTreeValid: true après résolution propre", () => {
+    // same_change : les deux branches ajoutent le même JSDoc sur add()
+    const JSDOC_CONFLICT = `// Tiny calculator module — TypeScript version
+
+` + diff3(`/** Adds two numbers. */
+export function add(a: number, b: number): number {
+  return a + b;
+}
+`, `export function add(a: number, b: number): number {
+  return a + b;
+}
+`, `/** Adds two numbers. */
+export function add(a: number, b: number): number {
+  return a + b;
+}
+`) + `
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+`;
+    it("resolveAsync : parseTreeValid est true ou null (jamais false sur code valide)", async () => {
+        const result = await resolveAsync(JSDOC_CONFLICT, "calculator.ts");
+        // null = tree-sitter non disponible ; true = syntaxe valide
+        expect(result.validation.parseTreeValid === null || result.validation.parseTreeValid === true).toBe(true);
+    });
+    it("resolveAsync : le same_change est résolu (code valide → pas de rétraction)", async () => {
+        const result = await resolveAsync(JSDOC_CONFLICT, "calculator.ts");
+        // Si tree-sitter est disponible et valide, la résolution est maintenue.
+        // Si non disponible, le same_change reste résolu également.
+        if (result.validation.parseTreeValid !== false) {
+            // Pas de rétraction — la résolution doit être présente
+            expect(result.stats.autoResolved).toBeGreaterThanOrEqual(0);
+        }
+    });
+    it("checkParseTreeValid retourne true ou null sur du TypeScript valide", async () => {
+        const validTs = `/** Adds two numbers. */
+export function add(a: number, b: number): number {
+  return a + b;
+}
+
+export function subtract(a: number, b: number): number {
+  return a - b;
+}
+`;
+        const result = await checkParseTreeValid(validTs, "calculator.ts");
+        expect(result === null || result === true).toBe(true);
+    });
+});
+describe("v2.4B — rétraction : parseTreeValid: false sur fichier cassé", () => {
+    // Fichier avec une accolade fermante manquante pour la closure forEach.
+    // La résolution du same_change produit du TS syntaxiquement invalide.
+    const BROKEN_BASE = `import { EventEmitter } from "events";
+
+export class CalculatorEvents extends EventEmitter {
+  processAll(ops: string[]) {
+    ops.forEach(op => {
+      this.emit("before", op);
+      // placeholder
+      this.emit("after", op);
+    // NB: closing }) intentionally omitted
+
+export function createCalculatorEvents(): CalculatorEvents {
+  return new CalculatorEvents();
+}
+`;
+    const BROKEN_OURS = `import { EventEmitter } from "events";
+
+export class CalculatorEvents extends EventEmitter {
+  processAll(ops: string[]) {
+    ops.forEach(op => {
+      this.emit("before", op);
+      console.log(\`processing: \${op}\`);
+      this.emit("after", op);
+    // NB: closing }) intentionally omitted
+
+export function createCalculatorEvents(): CalculatorEvents {
+  return new CalculatorEvents();
+}
+`;
+    const BROKEN_THEIRS = BROKEN_OURS; // same_change
+    it("checkParseTreeValid retourne false ou null sur du TypeScript cassé", async () => {
+        const broken = `function foo( {\n  return 1;\n`;
+        const result = await checkParseTreeValid(broken, "broken.ts");
+        expect(result === null || result === false).toBe(true);
+    });
+    it("applyPostMergeRiskPenalty : rétraction immutable et complète", () => {
+        const resolution = {
+            autoResolved: true,
+            resolvedLines: ["console.log('ok');"],
+            resolutionReason: "same_change",
+            hunk: {
+                baseLines: ["// placeholder"],
+                oursLines: ["console.log('ok');"],
+                theirsLines: ["console.log('ok');"],
+                startLine: 7,
+                type: "same_change",
+                confidence: {
+                    score: 100,
+                    label: "certain",
+                    dimensions: {
+                        typeClassification: 100,
+                        dataRisk: 0,
+                        scopeImpact: 0,
+                        fileFrequency: 0,
+                        baseAvailability: 100,
+                    },
+                    boosters: ["same_change"],
+                    penalties: [],
+                },
+                explanation: "same_change",
+                trace: {
+                    steps: [],
+                    selected: "same_change",
+                    summary: "same_change",
+                    hasBase: true,
+                },
+            },
+        };
+        const retracted = applyPostMergeRiskPenalty(resolution);
+        // Rétraction effective
+        expect(retracted.autoResolved).toBe(false);
+        expect(retracted.resolvedLines).toBeNull();
+        expect(retracted.hunk.confidence.score).toBe(0);
+        expect(retracted.hunk.confidence.label).toBe("low");
+        expect(retracted.hunk.confidence.dimensions.postMergeRisk).toBe(100);
+        expect(retracted.hunk.confidence.penalties.some((p) => /parse-tree/i.test(p))).toBe(true);
+        // Immutabilité de l'original
+        expect(resolution.autoResolved).toBe(true);
+        expect(resolution.resolvedLines).toEqual(["console.log('ok');"]);
+        expect(resolution.hunk.confidence.score).toBe(100);
+    });
+    it("resolveAsync sur fichier cassé : parseTreeValid false → rétraction (quand WASM)", async () => {
+        const conflictedBroken = diff3(BROKEN_OURS, BROKEN_BASE, BROKEN_THEIRS);
+        const result = await resolveAsync(conflictedBroken, "calculator-events.ts");
+        if (result.validation.parseTreeValid === null) {
+            // WASM non disponible → pas de validation → la résolution est maintenue ou non
+            return;
+        }
+        if (result.validation.parseTreeValid === false) {
+            // Rétraction activée
+            expect(result.mergedContent).toBeNull();
+            expect(result.stats.autoResolved).toBe(0);
+            expect(result.resolutions.every((r) => !r.autoResolved)).toBe(true);
+        }
+        // parseTreeValid: true = le parse-tree ne voit pas l'erreur dans ce contexte → ok aussi
+    });
+});
+describe("v2.4C — non-supporté : parseTreeValid: null sur .json", () => {
+    it("checkParseTreeValid retourne null pour .json (pas de grammaire tree-sitter)", async () => {
+        const result = await checkParseTreeValid('{"a": 1}', "package.json");
+        expect(result).toBeNull();
+    });
+    it("resolveAsync : parseTreeValid est null sur .json", async () => {
+        const conflict = diff3('{"version": "1.0.0"}\n', '{"version": "0.9.0"}\n', '{"version": "1.0.0"}\n');
+        const result = await resolveAsync(conflict, "package.json");
+        expect(result.validation.parseTreeValid).toBeNull();
+    });
+    it("checkParseTreeValid retourne null pour .md", async () => {
+        const result = await checkParseTreeValid("# Hello\n\nsome text\n", "README.md");
+        expect(result).toBeNull();
+    });
+});
+describe("v2.4D — resolve() synchrone : parseTreeValid toujours null", () => {
+    it("resolve() ne fait pas de validation parse-tree → null", () => {
+        const conflict = diff3("const x = 1;\n", "const x = 0;\n", "const x = 1;\n");
+        const result = resolve(conflict, "test.ts");
+        // resolve() est synchrone : parseTreeValid n'est jamais calculé
+        expect(result.validation.parseTreeValid).toBeNull();
+    });
+    it("resolve() : externalValidation absent par défaut (sync ne lance pas la validation stricte)", () => {
+        const conflict = diff3("const x = 1;\n", "const x = 0;\n", "const x = 1;\n");
+        const result = resolve(conflict, "test.ts");
+        // resolve() synchrone : la validation stricte (tsc/eslint) n'est jamais lancée
+        expect(result.validation.externalValidation).toBeUndefined();
+    });
+});
+describe("v2.4 — checkParseTreeValid : robustesse et graceful degradation", () => {
+    it("ne lève jamais d'exception sur contenu vide ou chemin vide", async () => {
+        await expect(checkParseTreeValid("", "")).resolves.not.toThrow();
+    });
+    it("ne lève jamais d'exception sur contenu binaire", async () => {
+        await expect(checkParseTreeValid("\x00\xff\xfe", "weird.ts")).resolves.not.toThrow();
+    });
+    it("retourne null ou boolean pour du JS valide (.js)", async () => {
+        const js = `const add = (a, b) => a + b;\nmodule.exports = { add };\n`;
+        const result = await checkParseTreeValid(js, "utils.js");
+        expect(result === null || typeof result === "boolean").toBe(true);
+    });
+    it("resolveAsync ne lève jamais d'exception sur fichier .ts mal formé", async () => {
+        const conflict = diff3("function broken( {\n", "function broken() {\n", "function broken() {\n  return 1;\n}\n");
+        await expect(resolveAsync(conflict, "broken.ts")).resolves.not.toThrow();
+    });
+});
+//# sourceMappingURL=v2-core-scenarios.test.js.map