json-schema-compatibility-checker 1.0.3 → 1.0.4

package/dist/chunk-8me729r7.js.map

@@ -1,12 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/semantic-diff/detectors.ts", "../src/semantic-diff/analyzer.ts", "../src/subset-checker.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7 } from \"json-schema\";\nimport type { SchemaDiff } from \"../types\";\nimport type { SemanticDiff } from \"./types\";\n\n// ─── Semantic Diff Detectors ─────────────────────────────────────────────────\n//\n// Fonctions de détection par catégorie d'incompatibilité.\n// Chaque détecteur analyse les diffs structurels et les schemas originaux\n// pour produire des SemanticDiff lisibles et actionnables.\n//\n// Organisation :\n//   1. Property detectors  — missing, optional, not-allowed\n//   2. Type detectors      — mismatch, too-wide\n//   3. Value detectors     — enum, const\n//   4. Constraint detectors — min/max/length/items/etc.\n//   5. Structure detectors — additionalProperties, items\n//   6. Format detectors    — format, pattern\n//   7. Fallback            — schema-incompatible (catch-all)\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\n/** Formate un type JSON Schema pour l'affichage (string, array → \"string | number\") */\nexport function formatType(type: unknown): string {\n\tif (Array.isArray(type)) {\n\t\treturn type.join(\" | \");\n\t}\n\tif (type === undefined || type === null) {\n\t\treturn \"any\";\n\t}\n\treturn String(type);\n}\n\n/**\n * Extrait le type lisible d'un sous-schema pour les messages.\n * Gère les cas const, enum, type, et boolean schemas.\n */\nfunction extractTypeLabel(schema: unknown): string {\n\tif (typeof schema === \"boolean\") {\n\t\treturn schema ? \"any\" : \"never\";\n\t}\n\tif (typeof schema !== \"object\" || schema === null) {\n\t\treturn \"unknown\";\n\t}\n\tconst s = schema as JSONSchema7;\n\tif (s.const !== undefined) {\n\t\treturn `const(${JSON.stringify(s.const)})`;\n\t}\n\tif (s.enum) {\n\t\treturn `enum(${JSON.stringify(s.enum)})`;\n\t}\n\tif (s.type) {\n\t\treturn formatType(s.type);\n\t}\n\treturn \"object\";\n}\n\n// ─── 1. Property Detectors ──────────────────────────────────────────────────\n\n/**\n * Détecte les propriétés requises par le target que le source ne fournit pas.\n *\n * Condition : la propriété est dans `sup.required` mais n'existe pas\n * dans `sub.properties`.\n *\n * Regroupe les diffs structurels `properties.X added` + `required changed`\n * en un seul diagnostic.\n */\nexport function detectMissingRequiredProperties(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tconst subProps = sub.properties || {};\n\tconst supProps = sup.properties || {};\n\tconst supRequired = new Set(sup.required || []);\n\n\t// Chercher les propriétés ajoutées par le merge qui sont requises par le target\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\n\t\tconst match = diff.path.match(/^properties\\.([^.]+)$/);\n\t\tif (!match) continue;\n\n\t\tconst propName = match[1];\n\t\tif (propName === undefined) continue;\n\n\t\t// Propriété ajoutée par le merge ET requise par le target ET absente du source\n\t\tif (\n\t\t\tdiff.type === \"added\" &&\n\t\t\tsupRequired.has(propName) &&\n\t\t\t!(propName in subProps)\n\t\t) {\n\t\t\tconst targetSchema = supProps[propName];\n\t\t\tresult.push({\n\t\t\t\ttype: \"missing-required-property\",\n\t\t\t\tpath: `properties.${propName}`,\n\t\t\t\tmessage: `Target requires property '${propName}' (${extractTypeLabel(targetSchema)}) which source does not provide`,\n\t\t\t\tdetails: {\n\t\t\t\t\tproperty: propName,\n\t\t\t\t\ttargetSchema: targetSchema ?? null,\n\t\t\t\t},\n\t\t\t});\n\t\t\tconsumed.add(i);\n\t\t}\n\t}\n\n\t// Si on a trouvé des missing-required, consommer aussi le diff `required`\n\tif (result.length > 0) {\n\t\tfor (let i = 0; i < diffs.length; i++) {\n\t\t\tif (consumed.has(i)) continue;\n\t\t\tconst diff = diffs[i];\n\t\t\tif (diff === undefined) continue;\n\t\t\tif (diff.path === \"required\" && diff.type === \"changed\") {\n\t\t\t\tconsumed.add(i);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn result;\n}\n\n/**\n * Détecte les propriétés optionnelles dans le source mais requises par le target.\n *\n * Condition : la propriété existe dans `sub.properties` (mais pas dans\n * `sub.required`), et elle est dans `sup.required`.\n *\n * Ne se déclenche que si la propriété n'a pas déjà été détectée comme\n * `missing-required-property`.\n */\nexport function detectPropertiesNotGuaranteed(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tconst subRequired = new Set(sub.required || []);\n\tconst supRequired = new Set(sup.required || []);\n\tconst subProps = sub.properties || {};\n\n\t// Compare les schemas directement plutôt que de chercher le diff `required`.\n\t// Le diff `required` peut déjà avoir été consommé par `detectMissingRequiredProperties`,\n\t// mais l'incompatibilité d'optionalité reste valide et doit être détectée.\n\n\t// Pour chaque propriété requise par le target mais pas par le source\n\tfor (const propName of supRequired) {\n\t\tif (subRequired.has(propName)) continue;\n\n\t\t// La propriété existe dans le source mais est optionnelle\n\t\tif (propName in subProps) {\n\t\t\tresult.push({\n\t\t\t\ttype: \"property-not-guaranteed\",\n\t\t\t\tpath: `properties.${propName}`,\n\t\t\t\tmessage: `Property '${propName}' is optional in source but required by target`,\n\t\t\t\tdetails: {\n\t\t\t\t\tproperty: propName,\n\t\t\t\t},\n\t\t\t});\n\t\t}\n\t}\n\n\t// Consommer le diff `required` s'il est encore disponible\n\tif (result.length > 0) {\n\t\tfor (let i = 0; i < diffs.length; i++) {\n\t\t\tif (consumed.has(i)) continue;\n\t\t\tconst diff = diffs[i];\n\t\t\tif (diff === undefined) continue;\n\t\t\tif (diff.path === \"required\" && diff.type === \"changed\") {\n\t\t\t\tconsumed.add(i);\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn result;\n}\n\n/**\n * Détecte les propriétés fournies par le source que le target interdit.\n *\n * Condition : la propriété existe dans `sub.properties` mais pas dans\n * `sup.properties`, et `sup.additionalProperties === false`.\n */\nexport function detectPropertiesNotAllowed(\n\t_sub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tif (sup.additionalProperties !== false) return result;\n\n\tconst supProps = sup.properties || {};\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\n\t\tconst match = diff.path.match(/^properties\\.([^.]+)$/);\n\t\tif (!match) continue;\n\n\t\tconst propName = match[1];\n\t\tif (propName === undefined) continue;\n\n\t\t// Propriété retirée par le merge (source l'a, target l'interdit)\n\t\tif (diff.type === \"removed\" && !(propName in supProps)) {\n\t\t\tresult.push({\n\t\t\t\ttype: \"property-not-allowed\",\n\t\t\t\tpath: `properties.${propName}`,\n\t\t\t\tmessage: `Source provides property '${propName}' which target does not allow`,\n\t\t\t\tdetails: {\n\t\t\t\t\tproperty: propName,\n\t\t\t\t},\n\t\t\t});\n\t\t\tconsumed.add(i);\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── 2. Type Detectors ──────────────────────────────────────────────────────\n\n/**\n * Détecte les incompatibilités de type sur les propriétés ou à la racine.\n *\n * Distingue deux cas :\n *   - `type-mismatch`  : types complètement différents (string vs number)\n *   - `type-too-wide`  : source est un superset du target (string|number vs string)\n */\nexport function detectTypeDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\t// Match root \"type\" or \"properties.X.type\"\n\t\tconst rootTypeMatch = diff.path === \"type\";\n\t\tconst propTypeMatch = diff.path.match(/^properties\\.([^.]+)\\.type$/);\n\n\t\tif (!rootTypeMatch && !propTypeMatch) continue;\n\n\t\tconst propName = propTypeMatch ? (propTypeMatch[1] ?? null) : null;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\t// Récupérer les types source et target depuis les schemas originaux\n\t\tconst sourceType = propName ? getPropertyType(sub, propName) : sub.type;\n\t\tconst targetType = propName ? getPropertyType(sup, propName) : sup.type;\n\n\t\tconst sourceTypes = normalizeTypeToArray(sourceType);\n\t\tconst targetTypes = normalizeTypeToArray(targetType);\n\n\t\t// Vérifier si c'est un type-too-wide (source ⊃ target) ou un mismatch total\n\t\tconst overlap = sourceTypes.filter((t) => targetTypes.includes(t));\n\n\t\tif (overlap.length === 0) {\n\t\t\t// Aucun type en commun → mismatch total\n\t\t\tresult.push({\n\t\t\t\ttype: \"type-mismatch\",\n\t\t\t\tpath: basePath || \"type\",\n\t\t\t\tmessage: propName\n\t\t\t\t\t? `Property '${propName}': source produces '${formatType(sourceType)}' but target expects '${formatType(targetType)}'`\n\t\t\t\t\t: `Source produces '${formatType(sourceType)}' but target expects '${formatType(targetType)}'`,\n\t\t\t\tdetails: {\n\t\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\t\tsourceType,\n\t\t\t\t\ttargetType,\n\t\t\t\t},\n\t\t\t});\n\t\t} else if (overlap.length < sourceTypes.length) {\n\t\t\t// Overlap partiel → source trop large\n\t\t\tconst extraTypes = sourceTypes.filter((t) => !targetTypes.includes(t));\n\t\t\tresult.push({\n\t\t\t\ttype: \"type-too-wide\",\n\t\t\t\tpath: basePath || \"type\",\n\t\t\t\tmessage: propName\n\t\t\t\t\t? `Property '${propName}': source can produce '${formatType(sourceType)}' but target only accepts '${formatType(targetType)}'`\n\t\t\t\t\t: `Source can produce '${formatType(sourceType)}' but target only accepts '${formatType(targetType)}'`,\n\t\t\t\tdetails: {\n\t\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\t\tsourceType,\n\t\t\t\t\ttargetType,\n\t\t\t\t\textraTypes,\n\t\t\t\t},\n\t\t\t});\n\t\t} else {\n\t\t\t// Même types mais le diff existe (cas edge, ne devrait pas arriver souvent)\n\t\t\tresult.push({\n\t\t\t\ttype: \"type-mismatch\",\n\t\t\t\tpath: basePath || \"type\",\n\t\t\t\tmessage: propName\n\t\t\t\t\t? `Property '${propName}': type changed from '${formatType(diff.sourceValue)}' to '${formatType(diff.mergedValue)}'`\n\t\t\t\t\t: `Type changed from '${formatType(diff.sourceValue)}' to '${formatType(diff.mergedValue)}'`,\n\t\t\t\tdetails: {\n\t\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\t\tsourceType: diff.sourceValue,\n\t\t\t\t\ttargetType: diff.mergedValue,\n\t\t\t\t},\n\t\t\t});\n\t\t}\n\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n/** Extrait le type d'une propriété d'un schema */\nfunction getPropertyType(\n\tschema: JSONSchema7,\n\tpropName: string,\n): JSONSchema7[\"type\"] | undefined {\n\tconst prop = schema.properties?.[propName];\n\tif (typeof prop === \"object\" && prop !== null && !Array.isArray(prop)) {\n\t\treturn prop.type;\n\t}\n\treturn undefined;\n}\n\n/** Normalise un type en tableau (pour faciliter les comparaisons) */\nfunction normalizeTypeToArray(type: JSONSchema7[\"type\"] | undefined): string[] {\n\tif (type === undefined) return [];\n\tif (Array.isArray(type)) return type;\n\treturn [type];\n}\n\n// ─── 3. Value Detectors ─────────────────────────────────────────────────────\n\n/**\n * Détecte les incompatibilités d'enum : source autorise des valeurs\n * que target n'accepte pas.\n */\nexport function detectEnumDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\tconst rootEnumMatch = diff.path === \"enum\";\n\t\tconst propEnumMatch = diff.path.match(/^properties\\.([^.]+)\\.enum$/);\n\n\t\tif (!rootEnumMatch && !propEnumMatch) continue;\n\n\t\tconst propName = propEnumMatch ? (propEnumMatch[1] ?? null) : null;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\tconst sourceValues = propName\n\t\t\t? getPropertyKeyword(sub, propName, \"enum\")\n\t\t\t: sub.enum;\n\t\tconst targetValues = propName\n\t\t\t? getPropertyKeyword(sup, propName, \"enum\")\n\t\t\t: sup.enum;\n\n\t\tconst sourceArr = Array.isArray(sourceValues) ? sourceValues : [];\n\t\tconst targetArr = Array.isArray(targetValues) ? targetValues : [];\n\t\tconst targetSet = new Set(targetArr.map((v) => JSON.stringify(v)));\n\t\tconst extraValues = sourceArr.filter(\n\t\t\t(v) => !targetSet.has(JSON.stringify(v)),\n\t\t);\n\n\t\tresult.push({\n\t\t\ttype: \"enum-not-subset\",\n\t\t\tpath: basePath || \"enum\",\n\t\t\tmessage: propName\n\t\t\t\t? `Property '${propName}': source allows ${JSON.stringify(extraValues)} which target does not accept`\n\t\t\t\t: `Source allows ${JSON.stringify(extraValues)} which target does not accept`,\n\t\t\tdetails: {\n\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\tsourceValues,\n\t\t\t\ttargetValues,\n\t\t\t\textraValues,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n/**\n * Détecte les incompatibilités de const : valeurs const différentes.\n */\nexport function detectConstDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\tconst rootConstMatch = diff.path === \"const\";\n\t\tconst propConstMatch = diff.path.match(/^properties\\.([^.]+)\\.const$/);\n\n\t\tif (!rootConstMatch && !propConstMatch) continue;\n\n\t\tconst propName = propConstMatch ? (propConstMatch[1] ?? null) : null;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\tconst sourceConst = propName\n\t\t\t? getPropertyKeyword(sub, propName, \"const\")\n\t\t\t: sub.const;\n\t\tconst targetConst = propName\n\t\t\t? getPropertyKeyword(sup, propName, \"const\")\n\t\t\t: sup.const;\n\n\t\tresult.push({\n\t\t\ttype: \"const-mismatch\",\n\t\t\tpath: basePath || \"const\",\n\t\t\tmessage: propName\n\t\t\t\t? `Property '${propName}': source produces ${JSON.stringify(sourceConst)} but target expects ${JSON.stringify(targetConst)}`\n\t\t\t\t: `Source produces ${JSON.stringify(sourceConst)} but target expects ${JSON.stringify(targetConst)}`,\n\t\t\tdetails: {\n\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\tsourceConst,\n\t\t\t\ttargetConst,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n// ─── 4. Constraint Detectors ────────────────────────────────────────────────\n\n/**\n * Mots-clés de contraintes numériques / string / array / object.\n * Chaque entrée indique le keyword et une description lisible.\n */\nconst CONSTRAINT_KEYWORDS: ReadonlyMap<string, string> = new Map([\n\t[\"minimum\", \"minimum value\"],\n\t[\"maximum\", \"maximum value\"],\n\t[\"exclusiveMinimum\", \"exclusive minimum\"],\n\t[\"exclusiveMaximum\", \"exclusive maximum\"],\n\t[\"multipleOf\", \"multipleOf\"],\n\t[\"minLength\", \"minimum length\"],\n\t[\"maxLength\", \"maximum length\"],\n\t[\"minItems\", \"minimum items\"],\n\t[\"maxItems\", \"maximum items\"],\n\t[\"minProperties\", \"minimum properties\"],\n\t[\"maxProperties\", \"maximum properties\"],\n\t[\"uniqueItems\", \"uniqueItems\"],\n]);\n\n/**\n * Détecte les contraintes du target plus strictes que celles du source.\n *\n * Couvre : minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf,\n * minLength, maxLength, minItems, maxItems, minProperties, maxProperties.\n */\nexport function detectConstraintDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\t// Match root constraint or properties.X.constraint\n\t\tlet keyword: string | null = null;\n\t\tlet propName: string | null = null;\n\n\t\t// Root level: \"minLength\", \"maximum\", etc.\n\t\tif (CONSTRAINT_KEYWORDS.has(diff.path)) {\n\t\t\tkeyword = diff.path;\n\t\t}\n\n\t\t// Property level: \"properties.X.minLength\", etc.\n\t\tif (!keyword) {\n\t\t\tconst propMatch = diff.path.match(/^properties\\.([^.]+)\\.(.+)$/);\n\t\t\tif (propMatch?.[2] && CONSTRAINT_KEYWORDS.has(propMatch[2])) {\n\t\t\t\tpropName = propMatch[1] ?? null;\n\t\t\t\tkeyword = propMatch[2];\n\t\t\t}\n\t\t}\n\n\t\tif (!keyword) continue;\n\n\t\tconst label = CONSTRAINT_KEYWORDS.get(keyword) ?? keyword;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\tconst sourceValue = propName\n\t\t\t? getPropertyKeyword(sub, propName, keyword)\n\t\t\t: (sub as Record<string, unknown>)[keyword];\n\t\tconst targetValue = propName\n\t\t\t? getPropertyKeyword(sup, propName, keyword)\n\t\t\t: (sup as Record<string, unknown>)[keyword];\n\n\t\tconst sourceLabel =\n\t\t\tsourceValue !== undefined ? String(sourceValue) : \"none\";\n\t\tconst targetLabel =\n\t\t\ttargetValue !== undefined ? String(targetValue) : \"none\";\n\n\t\tresult.push({\n\t\t\ttype: \"constraint-too-loose\",\n\t\t\tpath: basePath || keyword,\n\t\t\tmessage: propName\n\t\t\t\t? `Property '${propName}': source allows ${label}=${sourceLabel} but target requires ${label}=${targetLabel}`\n\t\t\t\t: `Source allows ${label}=${sourceLabel} but target requires ${label}=${targetLabel}`,\n\t\t\tdetails: {\n\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\tconstraint: keyword,\n\t\t\t\tsourceValue: sourceValue ?? null,\n\t\t\t\ttargetValue: targetValue ?? null,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n// ─── 5. Structure Detectors ─────────────────────────────────────────────────\n\n/**\n * Détecte les conflits d'additionalProperties :\n * source autorise des propriétés supplémentaires, target les interdit.\n */\nexport function detectAdditionalPropertiesConflict(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\n\t\tif (diff.path !== \"additionalProperties\") continue;\n\n\t\tconst sourceAllows = sub.additionalProperties !== false;\n\t\tconst targetAllows = sup.additionalProperties !== false;\n\n\t\tresult.push({\n\t\t\ttype: \"additional-properties-conflict\",\n\t\t\tpath: \"additionalProperties\",\n\t\t\tmessage:\n\t\t\t\tsourceAllows && !targetAllows\n\t\t\t\t\t? \"Source allows additional properties but target forbids them\"\n\t\t\t\t\t: `additionalProperties changed from ${JSON.stringify(diff.sourceValue)} to ${JSON.stringify(diff.mergedValue)}`,\n\t\t\tdetails: {\n\t\t\t\tsourceAllows,\n\t\t\t\ttargetAllows,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n/**\n * Détecte les incompatibilités de schema d'items (arrays).\n */\nexport function detectItemsDiffs(\n\t_sub: JSONSchema7,\n\t_sup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\n\t\t// Match \"items\" or \"items.something\"\n\t\tif (!diff.path.startsWith(\"items\")) continue;\n\n\t\t// Construire un message selon le sous-path\n\t\tconst subPath = diff.path === \"items\" ? \"\" : diff.path.slice(6); // remove \"items.\"\n\t\tconst detail = subPath ? ` (${subPath})` : \"\";\n\n\t\tresult.push({\n\t\t\ttype: \"incompatible-items\",\n\t\t\tpath: diff.path,\n\t\t\tmessage: `Array items${detail}: ${describeChange(diff)}`,\n\t\t\tdetails: {\n\t\t\t\treason: describeChange(diff),\n\t\t\t\tsubPath: subPath || null,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n// ─── 6. Format Detectors ────────────────────────────────────────────────────\n\n/**\n * Détecte les incompatibilités de format (email, uri, date-time, etc.).\n */\nexport function detectFormatDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\tconst rootFormatMatch = diff.path === \"format\";\n\t\tconst propFormatMatch = diff.path.match(/^properties\\.([^.]+)\\.format$/);\n\n\t\tif (!rootFormatMatch && !propFormatMatch) continue;\n\n\t\tconst propName = propFormatMatch ? (propFormatMatch[1] ?? null) : null;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\tconst sourceFormat = propName\n\t\t\t? getPropertyKeyword(sub, propName, \"format\")\n\t\t\t: sub.format;\n\t\tconst targetFormat = propName\n\t\t\t? getPropertyKeyword(sup, propName, \"format\")\n\t\t\t: sup.format;\n\n\t\tconst sourceLabel = sourceFormat ?? \"none\";\n\t\tconst targetLabel = targetFormat ?? \"none\";\n\n\t\tresult.push({\n\t\t\ttype: \"format-mismatch\",\n\t\t\tpath: basePath || \"format\",\n\t\t\tmessage: propName\n\t\t\t\t? `Property '${propName}': source format is '${sourceLabel}' but target requires '${targetLabel}'`\n\t\t\t\t: `Source format is '${sourceLabel}' but target requires '${targetLabel}'`,\n\t\t\tdetails: {\n\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\tsourceFormat: sourceFormat ?? null,\n\t\t\t\ttargetFormat: targetFormat ?? null,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n/**\n * Détecte les incompatibilités de pattern regex.\n */\nexport function detectPatternDiffs(\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n): SemanticDiff[] {\n\tconst result: SemanticDiff[] = [];\n\n\tfor (let i = 0; i < diffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = diffs[i];\n\t\tif (diff === undefined) continue;\n\t\tif (diff.type !== \"changed\" && diff.type !== \"added\") continue;\n\n\t\tconst rootPatternMatch = diff.path === \"pattern\";\n\t\tconst propPatternMatch = diff.path.match(/^properties\\.([^.]+)\\.pattern$/);\n\n\t\tif (!rootPatternMatch && !propPatternMatch) continue;\n\n\t\tconst propName = propPatternMatch ? (propPatternMatch[1] ?? null) : null;\n\t\tconst basePath = propName ? `properties.${propName}` : \"\";\n\n\t\tconst sourcePattern = propName\n\t\t\t? getPropertyKeyword(sub, propName, \"pattern\")\n\t\t\t: sub.pattern;\n\t\tconst targetPattern = propName\n\t\t\t? getPropertyKeyword(sup, propName, \"pattern\")\n\t\t\t: sup.pattern;\n\n\t\tconst sourceLabel = sourcePattern ?? \"none\";\n\t\tconst targetLabel = targetPattern ?? \"none\";\n\n\t\tresult.push({\n\t\t\ttype: \"pattern-not-subset\",\n\t\t\tpath: basePath || \"pattern\",\n\t\t\tmessage: propName\n\t\t\t\t? `Property '${propName}': source pattern '${sourceLabel}' is not a subset of target pattern '${targetLabel}'`\n\t\t\t\t: `Source pattern '${sourceLabel}' is not a subset of target pattern '${targetLabel}'`,\n\t\t\tdetails: {\n\t\t\t\t...(propName ? { property: propName } : {}),\n\t\t\t\tsourcePattern: sourcePattern ?? null,\n\t\t\t\ttargetPattern: targetPattern ?? null,\n\t\t\t},\n\t\t});\n\t\tconsumed.add(i);\n\t}\n\n\treturn result;\n}\n\n// ─── 7. Fallback ─────────────────────────────────────────────────────────────\n\n/**\n * Convertit les diffs structurels non consommés en `schema-incompatible`.\n *\n * C'est le catch-all pour les cas non couverts par les détecteurs spécifiques.\n */\nexport function createFallbackDiff(diff: SchemaDiff): SemanticDiff {\n\treturn {\n\t\ttype: \"schema-incompatible\",\n\t\tpath: diff.path,\n\t\tmessage: describeChange(diff),\n\t\tdetails: {\n\t\t\treason: describeChange(diff),\n\t\t\tstructuralType: diff.type,\n\t\t\tsourceValue: diff.sourceValue,\n\t\t\tmergedValue: diff.mergedValue,\n\t\t},\n\t};\n}\n\n// ─── Shared Helpers ──────────────────────────────────────────────────────────\n\n/**\n * Extrait la valeur d'un mot-clé d'un sous-schema de propriété.\n *\n * @param schema   Le schema parent\n * @param propName Le nom de la propriété\n * @param keyword  Le mot-clé à extraire (type, enum, format, etc.)\n */\nfunction getPropertyKeyword(\n\tschema: JSONSchema7,\n\tpropName: string,\n\tkeyword: string,\n): unknown {\n\tconst prop = schema.properties?.[propName];\n\tif (typeof prop === \"object\" && prop !== null && !Array.isArray(prop)) {\n\t\treturn (prop as Record<string, unknown>)[keyword];\n\t}\n\treturn undefined;\n}\n\n/**\n * Décrit un changement structurel en phrase lisible.\n * Utilisé pour les messages des détecteurs et du fallback.\n */\nfunction describeChange(diff: SchemaDiff): string {\n\tswitch (diff.type) {\n\t\tcase \"added\":\n\t\t\treturn `'${diff.path}' added with value ${JSON.stringify(diff.mergedValue)}`;\n\t\tcase \"removed\":\n\t\t\treturn `'${diff.path}' was removed (was ${JSON.stringify(diff.sourceValue)})`;\n\t\tdefault:\n\t\t\treturn `'${diff.path}' changed from ${JSON.stringify(diff.sourceValue)} to ${JSON.stringify(diff.mergedValue)}`;\n\t}\n}\n",
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport type { SchemaDiff } from \"../types\";\nimport {\n\tcreateFallbackDiff,\n\tdetectAdditionalPropertiesConflict,\n\tdetectConstDiffs,\n\tdetectConstraintDiffs,\n\tdetectEnumDiffs,\n\tdetectFormatDiffs,\n\tdetectItemsDiffs,\n\tdetectMissingRequiredProperties,\n\tdetectPatternDiffs,\n\tdetectPropertiesNotAllowed,\n\tdetectPropertiesNotGuaranteed,\n\tdetectTypeDiffs,\n} from \"./detectors\";\nimport type { SemanticDiff } from \"./types\";\n\n// ─── Semantic Diff Analyzer ──────────────────────────────────────────────────\n//\n// Orchestrateur principal qui transforme des diffs structurelles brutes\n// (original vs merged) en diffs sémantiques lisibles et actionnables.\n//\n// Architecture :\n//   1. Les détecteurs s'exécutent dans un ordre précis (priorité décroissante)\n//   2. Chaque détecteur marque les diffs structurelles qu'il a \"consommées\"\n//   3. Les diffs non consommées tombent dans le fallback `schema-incompatible`\n//\n// L'ordre des détecteurs est important :\n//   - Les property detectors passent en premier pour regrouper les diffs\n//     `properties.X added` + `required changed` en un seul diagnostic\n//   - Les type/value/constraint detectors traitent les diffs restantes\n//   - Le fallback attrape tout ce qui n'a pas été classifié\n\n// ─── Detector pipeline ───────────────────────────────────────────────────────\n\n/**\n * Pipeline de détecteurs, exécutés dans l'ordre.\n *\n * Chaque détecteur reçoit :\n *   - sub : le schema source (original)\n *   - sup : le schema target\n *   - diffs : toutes les diffs structurelles\n *   - consumed : Set d'indices des diffs déjà traitées\n *\n * Et retourne un tableau de SemanticDiff.\n *\n * L'ordre est crucial :\n *   1. Property-level (regroupe required + property diffs)\n *   2. Type-level\n *   3. Value-level (enum, const)\n *   4. Constraint-level (min/max/length/items/etc.)\n *   5. Structure-level (additionalProperties, items)\n *   6. Format-level (format, pattern)\n */\ntype DetectorFn = (\n\tsub: JSONSchema7,\n\tsup: JSONSchema7,\n\tdiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n) => SemanticDiff[];\n\nconst DETECTOR_PIPELINE: readonly DetectorFn[] = [\n\t// Phase 1 — Property detectors (order matters: missing before not-guaranteed)\n\tdetectMissingRequiredProperties,\n\tdetectPropertiesNotGuaranteed,\n\tdetectPropertiesNotAllowed,\n\n\t// Phase 2 — Type detectors\n\tdetectTypeDiffs,\n\n\t// Phase 3 — Value detectors\n\tdetectEnumDiffs,\n\tdetectConstDiffs,\n\n\t// Phase 4 — Constraint detectors\n\tdetectConstraintDiffs,\n\n\t// Phase 5 — Structure detectors\n\tdetectAdditionalPropertiesConflict,\n\tdetectItemsDiffs,\n\n\t// Phase 6 — Format detectors\n\tdetectFormatDiffs,\n\tdetectPatternDiffs,\n];\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Transforme les diffs structurelles en diffs sémantiques.\n *\n * @param sub   Le schema source (sourceOutput)\n * @param sup   Le schema target (targetInput)\n * @param structuralDiffs  Les diffs brutes produites par `computeDiffs`\n * @returns     Tableau de SemanticDiff lisibles et actionnables\n *\n * @example\n * ```ts\n * const semanticDiffs = computeSemanticDiffs(sourceSchema, targetSchema, rawDiffs);\n * // [\n * //   {\n * //     type: 'missing-required-property',\n * //     path: 'properties.meetingId',\n * //     message: \"Target requires property 'meetingId' (string) which source does not provide\",\n * //     details: { property: 'meetingId', targetSchema: { type: 'string' } }\n * //   }\n * // ]\n * ```\n */\nexport function computeSemanticDiffs(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tstructuralDiffs: SchemaDiff[],\n): SemanticDiff[] {\n\t// Pas de diffs structurelles → pas de diffs sémantiques\n\tif (structuralDiffs.length === 0) return [];\n\n\t// Boolean schemas : pas assez de structure pour détecter des patterns\n\t// → fallback direct\n\tif (typeof sub === \"boolean\" || typeof sup === \"boolean\") {\n\t\treturn handleBooleanSchemas(sub, sup, structuralDiffs);\n\t}\n\n\tconst result: SemanticDiff[] = [];\n\tconst consumed = new Set<number>();\n\n\t// Exécuter chaque détecteur dans l'ordre du pipeline\n\tfor (const detector of DETECTOR_PIPELINE) {\n\t\tconst detected = detector(sub, sup, structuralDiffs, consumed);\n\t\tfor (const diff of detected) {\n\t\t\tresult.push(diff);\n\t\t}\n\t}\n\n\t// Phase finale — Fallback pour les diffs non consommées\n\tcollectUnconsumedDiffs(structuralDiffs, consumed, result);\n\n\treturn result;\n}\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\n/**\n * Gère les boolean schemas (true/false).\n *\n * `true` = accepte tout, `false` = rejette tout.\n * Pas assez de structure pour les détecteurs spécifiques,\n * donc on produit un `schema-incompatible` générique.\n */\nfunction handleBooleanSchemas(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tstructuralDiffs: SchemaDiff[],\n): SemanticDiff[] {\n\tif (sub === false) {\n\t\treturn [\n\t\t\t{\n\t\t\t\ttype: \"schema-incompatible\",\n\t\t\t\tpath: \"$\",\n\t\t\t\tmessage: \"Source schema rejects all values (false schema)\",\n\t\t\t\tdetails: { reason: \"source is false schema\" },\n\t\t\t},\n\t\t];\n\t}\n\n\tif (sup === false) {\n\t\treturn [\n\t\t\t{\n\t\t\t\ttype: \"schema-incompatible\",\n\t\t\t\tpath: \"$\",\n\t\t\t\tmessage: \"Target schema rejects all values (false schema)\",\n\t\t\t\tdetails: { reason: \"target is false schema\" },\n\t\t\t},\n\t\t];\n\t}\n\n\t// sub === true et sup est un objet, ou vice versa\n\t// Le diff structurel devrait décrire le problème\n\treturn structuralDiffs.map(createFallbackDiff);\n}\n\n/**\n * Collecte les diffs structurelles non consommées par aucun détecteur\n * et les convertit en `schema-incompatible` (fallback).\n *\n * Garantit qu'aucune diff structurelle n'est silencieusement ignorée.\n */\nfunction collectUnconsumedDiffs(\n\tstructuralDiffs: SchemaDiff[],\n\tconsumed: Set<number>,\n\tresult: SemanticDiff[],\n): void {\n\tfor (let i = 0; i < structuralDiffs.length; i++) {\n\t\tif (consumed.has(i)) continue;\n\t\tconst diff = structuralDiffs[i];\n\t\tif (diff === undefined) continue;\n\t\tresult.push(createFallbackDiff(diff));\n\t}\n}\n",
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport { computeDiffs } from \"./differ\";\nimport { isFormatSubset } from \"./format-validator\";\nimport type { MergeEngine } from \"./merge-engine\";\nimport { normalize } from \"./normalizer\";\nimport { isPatternSubset } from \"./pattern-subset\";\nimport { computeSemanticDiffs } from \"./semantic-diff\";\nimport type { SchemaDiff, SubsetResult } from \"./types\";\nimport { deepEqual, hasOwn, isPlainObj, omitKeys } from \"./utils\";\n\n// ─── Subset Checker ──────────────────────────────────────────────────────────\n//\n// Logique de vérification sub ⊆ sup via l'approche :\n//   A ⊆ B  ⟺  A ∩ B ≡ A\n//\n// Gère les cas :\n//   - Schemas atomiques (pas de anyOf/oneOf)\n//   - anyOf/oneOf dans sub → chaque branche doit être acceptée par sup\n//   - anyOf/oneOf dans sup → au moins une branche doit accepter sub\n//   - Point 6 : Distinction anyOf / oneOf dans les messages de diff\n//   - Point 7 : Raisonnement étendu sur `not` (evaluateNot)\n//     - not.type, not.const, not.enum (existants)\n//     - not avec properties+required (1.1)\n//     - not avec anyOf/oneOf (1.2)\n//     - not dans sub (1.3)\n//     - not.format (format-vs-format)\n//\n// Utilise des helpers natifs partagés depuis `./utils` pour des performances\n// optimales (deepEqual, hasOwn, isPlainObj, omitKeys).\n\n// ─── Branch type ─────────────────────────────────────────────────────────────\n\n/**\n * Type de branchement détecté dans un schema.\n *\n * Point 6 — Distingue `anyOf` de `oneOf` pour produire des messages\n * de diff plus précis. `\"none\"` indique un schema atomique (pas de branches).\n *\n * Note : la sémantique d'exclusivité de `oneOf` n'est pas vérifiée\n * (ce serait un problème NP-hard en général). Le checker traite `oneOf`\n * comme `anyOf` pour le subset checking, ce qui est correct pour le cas\n * `sub ⊆ sup` mais peut produire des faux-positifs si les branches\n * du sub se chevauchent.\n */\nexport type BranchType = \"anyOf\" | \"oneOf\" | \"none\";\n\nexport interface BranchResult {\n\t/** Les branches extraites du schema */\n\tbranches: JSONSchema7Definition[];\n\t/** Le type de branchement détecté */\n\ttype: BranchType;\n}\n\n// ─── Branch extraction ───────────────────────────────────────────────────────\n\n// Pre-allocated singleton results for boolean schemas to avoid per-call allocations.\n// These are safe because the branches arrays are never mutated after creation.\nconst BRANCH_TRUE: BranchResult = { branches: [true], type: \"none\" };\nconst BRANCH_FALSE: BranchResult = { branches: [false], type: \"none\" };\n\n/**\n * WeakMap cache for atomic (no anyOf/oneOf) schema branch results.\n * Avoids allocating `{ branches: [def], type: \"none\" }` on every call\n * for the same schema object. Since normalized schemas are cached and\n * return the same reference, this cache hits frequently.\n */\nconst atomicBranchCache = new WeakMap<object, BranchResult>();\n\n/**\n * Extrait les branches d'un schema et le type de branchement.\n *\n * Retourne les éléments de `anyOf`/`oneOf` s'ils existent, sinon retourne\n * le schema lui-même dans un tableau avec type `\"none\"`.\n *\n * Point 6 — Distingue `anyOf` de `oneOf` dans les paths de diff.\n *\n * Optimisation : réutilise des objets pré-alloués pour les cas boolean\n * (true/false) et un WeakMap cache pour les schemas atomiques afin\n * d'éviter les allocations sur ces chemins fréquents.\n */\nexport function getBranchesTyped(def: JSONSchema7Definition): BranchResult {\n\tif (typeof def === \"boolean\") {\n\t\treturn def ? BRANCH_TRUE : BRANCH_FALSE;\n\t}\n\tif (hasOwn(def, \"anyOf\") && Array.isArray(def.anyOf)) {\n\t\treturn { branches: def.anyOf, type: \"anyOf\" };\n\t}\n\tif (hasOwn(def, \"oneOf\") && Array.isArray(def.oneOf)) {\n\t\treturn { branches: def.oneOf, type: \"oneOf\" };\n\t}\n\t// Cache atomic results per schema object to avoid repeated allocations.\n\tlet cached = atomicBranchCache.get(def);\n\tif (cached === undefined) {\n\t\tcached = { branches: [def], type: \"none\" };\n\t\tatomicBranchCache.set(def, cached);\n\t}\n\treturn cached;\n}\n\n// ─── `not` reasoning (Point 7 — étendu) ─────────────────────────────────────\n\n/**\n * Raisonnement étendu sur `not` pour les cas courants.\n *\n * Point 7 — Vérifie la compatibilité quand `sup` et/ou `sub` contiennent `not` :\n *\n * **Cas existants (not dans sup) :**\n *   - `not.type` : type exclu vs type de sub\n *   - `not.const` : const exclu vs const de sub\n *   - `not.enum` : valeurs exclues vs enum de sub\n *\n * **Cas ajoutés :**\n *   - 1.1 — `not` avec `properties` + `required` : vérifier que les propriétés\n *     de sub sont incompatibles avec celles du `not` (const/enum différents)\n *   - 1.2 — `not` avec `anyOf`/`oneOf` : `not(anyOf([A,B]))` ≡ `allOf([not(A), not(B)])`,\n *     donc sub doit être incompatible avec CHAQUE branche\n *   - 1.3 — `not` dans `sub` (pas seulement dans `sup`) : un sub avec `not`\n *     accepte un ensemble trop large pour être un sous-ensemble d'un sup concret\n *   - `not.format` : format-vs-format via `isFormatSubset`\n *\n * Contrat ternaire conservateur :\n *   - `true`  → compatible (certain)\n *   - `false` → incompatible (certain)\n *   - `null`  → indéterminé (laisser le merge engine décider)\n *\n * En cas de doute → `null`. Ne JAMAIS retourner `true` sans certitude.\n *\n * Utilise `_.has`, `_.get`, `_.isEqual`, `_.includes`, `_.every`, `_.some`,\n * `_.keys`, `_.isPlainObject`, `_.isArray` pour des vérifications concises.\n */\nfunction evaluateNot(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n): boolean | null {\n\tif (typeof sub === \"boolean\" || typeof sup === \"boolean\") return null;\n\n\t// ── 1.3 — `not` dans sub (pas dans sup) ──\n\t// Un `not` dans sub est une restriction supplémentaire : il exclut des\n\t// valeurs de l'ensemble accepté par sub, ce qui le rend potentiellement\n\t// plus petit — donc plus susceptible d'être ⊆ sup, pas moins.\n\t// On laisse le merge engine décider : allOf(sub, sup) préservera le `not`\n\t// de sub, et la comparaison merged ≡ sub donnera le bon résultat.\n\t// Exception : si les deux ont `not`, on traite l'identité plus bas.\n\n\t// Vérifier `not` dans sup\n\tif (hasOwn(sup, \"not\") && isPlainObj(sup.not)) {\n\t\tconst notSchema = sup.not as JSONSchema7;\n\n\t\t// ── 1.1 — Cas not avec properties + required ──\n\t\t// IMPORTANT : ce check est placé AVANT le check not.type car quand\n\t\t// le not a à la fois `type` et `properties`, le check not.type seul\n\t\t// produirait un faux négatif (ex: sub type=object et not type=object\n\t\t// retournerait false, mais les properties pourraient être incompatibles\n\t\t// ce qui rendrait sub compatible avec le not).\n\t\t// Si not contient des properties avec const/enum et required,\n\t\t// vérifier que les propriétés de sub sont incompatibles avec celles du not.\n\t\tif (isPlainObj(notSchema.properties) && Array.isArray(notSchema.required)) {\n\t\t\tconst notProps = notSchema.properties as Record<\n\t\t\t\tstring,\n\t\t\t\tJSONSchema7Definition\n\t\t\t>;\n\t\t\tconst notRequired = notSchema.required as string[];\n\n\t\t\t// sub doit avoir des properties pour qu'on puisse comparer\n\t\t\tif (isPlainObj(sub.properties)) {\n\t\t\t\tconst subProps = sub.properties as Record<\n\t\t\t\t\tstring,\n\t\t\t\t\tJSONSchema7Definition\n\t\t\t\t>;\n\t\t\t\tconst subRequired = Array.isArray(sub.required)\n\t\t\t\t\t? (sub.required as string[])\n\t\t\t\t\t: [];\n\t\t\t\tconst notPropKeys = Object.keys(notProps);\n\n\t\t\t\t// Pour que sub soit compatible avec not(schema),\n\t\t\t\t// il suffit qu'au moins UNE propriété du not soit incompatible avec sub.\n\t\t\t\t// Cela signifie que sub ne peut jamais valider le schema inside not.\n\t\t\t\tconst hasIncompatibleProp = notPropKeys.some((key) => {\n\t\t\t\t\tconst notPropDef = notProps[key];\n\t\t\t\t\tif (typeof notPropDef === \"boolean\") return false;\n\t\t\t\t\tconst notProp = notPropDef as JSONSchema7;\n\n\t\t\t\t\t// Si la propriété est required dans not mais PAS dans sub.required\n\t\t\t\t\t// et qu'elle n'existe pas dans sub.properties → sub peut ne pas\n\t\t\t\t\t// avoir cette propriété → le not schema ne matcherait pas → compatible\n\t\t\t\t\tif (\n\t\t\t\t\t\tnotRequired.includes(key) &&\n\t\t\t\t\t\t!subRequired.includes(key) &&\n\t\t\t\t\t\t!hasOwn(subProps, key)\n\t\t\t\t\t) {\n\t\t\t\t\t\treturn true; // Propriété absente de sub → not ne matche pas\n\t\t\t\t\t}\n\n\t\t\t\t\t// Comparer les const/enum de la propriété\n\t\t\t\t\tif (!hasOwn(subProps, key)) return false;\n\t\t\t\t\tconst subPropDef = subProps[key];\n\t\t\t\t\tif (typeof subPropDef === \"boolean\") return false;\n\t\t\t\t\tconst subProp = subPropDef as JSONSchema7;\n\n\t\t\t\t\t// not.prop a un const, sub.prop a un const différent → incompatible pour cette prop\n\t\t\t\t\tif (hasOwn(notProp, \"const\") && hasOwn(subProp, \"const\")) {\n\t\t\t\t\t\tif (!deepEqual(notProp.const, subProp.const)) {\n\t\t\t\t\t\t\treturn true; // Consts différents → sub ne matche pas le not\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\t// not.prop a un enum, sub.prop a un const ou enum dont aucune valeur\n\t\t\t\t\t// n'est dans not.enum → incompatible pour cette prop\n\t\t\t\t\tif (hasOwn(notProp, \"enum\") && Array.isArray(notProp.enum)) {\n\t\t\t\t\t\tif (hasOwn(subProp, \"const\")) {\n\t\t\t\t\t\t\tconst inNotEnum = notProp.enum.some((v) =>\n\t\t\t\t\t\t\t\tdeepEqual(v, subProp.const),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tif (!inNotEnum) return true; // sub.const absent du not.enum\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (hasOwn(subProp, \"enum\") && Array.isArray(subProp.enum)) {\n\t\t\t\t\t\t\tconst noneInNotEnum = subProp.enum.every(\n\t\t\t\t\t\t\t\t(v) => !notProp.enum?.some((nv) => deepEqual(v, nv)),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tif (noneInNotEnum) return true; // Aucune valeur de sub.enum dans not.enum\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn false;\n\t\t\t\t});\n\n\t\t\t\tif (hasIncompatibleProp) return true;\n\n\t\t\t\t// Vérification inverse : si TOUTES les propriétés du not matchent sub\n\t\t\t\t// exactement (même const, sub a les required du not), alors sub VIOLE le not\n\t\t\t\tconst allPropsMatch = notPropKeys.every((key) => {\n\t\t\t\t\tconst notPropDef = notProps[key];\n\t\t\t\t\tif (typeof notPropDef === \"boolean\") return true;\n\t\t\t\t\tconst notProp = notPropDef as JSONSchema7;\n\n\t\t\t\t\t// La propriété doit être dans sub.required si elle est dans not.required\n\t\t\t\t\tif (notRequired.includes(key) && !subRequired.includes(key))\n\t\t\t\t\t\treturn false;\n\t\t\t\t\tif (!hasOwn(subProps, key)) return false;\n\t\t\t\t\tconst subPropDef = subProps[key];\n\t\t\t\t\tif (typeof subPropDef === \"boolean\") return true;\n\t\t\t\t\tconst subProp = subPropDef as JSONSchema7;\n\n\t\t\t\t\t// Vérifier const match\n\t\t\t\t\tif (hasOwn(notProp, \"const\") && hasOwn(subProp, \"const\")) {\n\t\t\t\t\t\treturn deepEqual(notProp.const, subProp.const);\n\t\t\t\t\t}\n\n\t\t\t\t\t// Vérifier enum inclusion\n\t\t\t\t\tif (hasOwn(notProp, \"enum\") && Array.isArray(notProp.enum)) {\n\t\t\t\t\t\tif (hasOwn(subProp, \"const\")) {\n\t\t\t\t\t\t\treturn notProp.enum.some((v) => deepEqual(v, subProp.const));\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif (hasOwn(subProp, \"enum\") && Array.isArray(subProp.enum)) {\n\t\t\t\t\t\t\t// Toutes les valeurs de sub.enum sont dans not.enum\n\t\t\t\t\t\t\treturn subProp.enum.every((v) =>\n\t\t\t\t\t\t\t\tnotProp.enum?.some((nv) => deepEqual(v, nv)),\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn false; // Indéterminé pour cette propriété\n\t\t\t\t});\n\n\t\t\t\tif (allPropsMatch) return false; // sub matche exactement le not → incompatible\n\t\t\t}\n\t\t}\n\n\t\t// ── Cas not.const ──\n\t\t// IMPORTANT : ce check est placé AVANT not.type car quand le not a\n\t\t// à la fois `type` et `const`, le check not.type seul produirait un\n\t\t// faux négatif (ex: sub type=string const=\"active\" et not type=string\n\t\t// const=\"deleted\" → le type check retournerait false car même type,\n\t\t// alors que les consts sont différents → compatible).\n\t\tif (hasOwn(notSchema, \"const\") && hasOwn(sub, \"const\")) {\n\t\t\tconst notConst = notSchema.const;\n\t\t\tconst subConst = sub.const;\n\t\t\tif (deepEqual(subConst, notConst)) return false;\n\t\t\treturn true;\n\t\t}\n\n\t\t// ── Cas not.enum ──\n\t\t// Aussi placé AVANT not.type pour la même raison.\n\t\tif (\n\t\t\thasOwn(notSchema, \"enum\") &&\n\t\t\tArray.isArray(notSchema.enum) &&\n\t\t\thasOwn(sub, \"enum\") &&\n\t\t\tArray.isArray(sub.enum)\n\t\t) {\n\t\t\t// Toutes les valeurs de sub.enum doivent être absentes de not.enum\n\t\t\tconst allExcluded = sub.enum.every(\n\t\t\t\t(val) => !notSchema.enum?.some((notVal) => deepEqual(val, notVal)),\n\t\t\t);\n\t\t\tif (allExcluded) return true;\n\t\t\t// Certaines valeurs de sub sont dans not.enum → pas automatiquement faux,\n\t\t\t// le merge engine peut encore gérer\n\t\t}\n\n\t\t// ── Cas not.type ──\n\t\t// Placé APRÈS not.const, not.enum et properties+required pour ne pas\n\t\t// court-circuiter les cas où le not a des contraintes plus spécifiques.\n\t\t// Le check type seul est un fallback pour les not schemas simples\n\t\t// (ex: { not: { type: \"string\" } }).\n\t\tif (hasOwn(notSchema, \"type\") && hasOwn(sub, \"type\")) {\n\t\t\tconst notType = notSchema.type;\n\t\t\tconst subType = sub.type;\n\n\t\t\t// Si les deux sont des strings simples\n\t\t\tif (typeof notType === \"string\" && typeof subType === \"string\") {\n\t\t\t\t// Ne retourner que si le not n'a PAS de contraintes plus spécifiques\n\t\t\t\t// (const, enum, properties) qui auraient dû être traitées plus haut\n\t\t\t\tif (\n\t\t\t\t\t!hasOwn(notSchema, \"const\") &&\n\t\t\t\t\t!hasOwn(notSchema, \"enum\") &&\n\t\t\t\t\t!isPlainObj(notSchema.properties)\n\t\t\t\t) {\n\t\t\t\t\tif (subType === notType) return false; // Incompatible : sub est exactement le type exclu\n\t\t\t\t\treturn true; // Compatible : sub est un type différent du type exclu\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Si notType est un tableau, sub.type doit ne pas être dedans\n\t\t\tif (Array.isArray(notType) && typeof subType === \"string\") {\n\t\t\t\tif (notType.includes(subType)) return false;\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\n\t\t// ── 1.2 — Cas not avec anyOf / oneOf ──\n\t\t// not(anyOf([A, B])) ≡ allOf([not(A), not(B)])\n\t\t// Pour que sub ⊆ not(anyOf(...)), sub doit être incompatible avec CHAQUE branche.\n\t\tif (hasOwn(notSchema, \"anyOf\") && Array.isArray(notSchema.anyOf)) {\n\t\t\tconst branches = notSchema.anyOf as JSONSchema7Definition[];\n\t\t\t// Pour chaque branche du not.anyOf, vérifier que sub est incompatible\n\t\t\tconst allIncompatible = branches.every((branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return !branch; // not(true) = rien, not(false) = tout\n\t\t\t\t// Créer un sup virtuel { not: branch } et vérifier récursivement\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\t// result = true → sub est compatible avec not(branch) → sub ⊄ branch → OK\n\t\t\t\t// result = false → sub est incompatible avec not(branch) → sub ⊆ branch → pas OK\n\t\t\t\t// result = null → indéterminé\n\t\t\t\treturn result === true;\n\t\t\t});\n\t\t\tif (allIncompatible) return true;\n\n\t\t\t// Vérifier si au moins une branche accepte sub → incompatible avec not(anyOf)\n\t\t\tconst anyBranchMatches = branches.some((branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === false; // sub est incompatible avec not(branch) → sub ⊆ branch\n\t\t\t});\n\t\t\tif (anyBranchMatches) return false;\n\t\t}\n\n\t\t// Même logique pour oneOf (dans le contexte du not, traité comme anyOf)\n\t\tif (hasOwn(notSchema, \"oneOf\") && Array.isArray(notSchema.oneOf)) {\n\t\t\tconst branches = notSchema.oneOf as JSONSchema7Definition[];\n\t\t\tconst allIncompatible = branches.every((branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return !branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === true;\n\t\t\t});\n\t\t\tif (allIncompatible) return true;\n\n\t\t\tconst anyBranchMatches = branches.some((branch) => {\n\t\t\t\tif (typeof branch === \"boolean\") return branch;\n\t\t\t\tconst result = evaluateNot(sub, { not: branch });\n\t\t\t\treturn result === false;\n\t\t\t});\n\t\t\tif (anyBranchMatches) return false;\n\t\t}\n\n\t\t// ── Cas not.format (format-vs-format uniquement) ──\n\t\t// Si not a un format et sub aussi, vérifier la compatibilité\n\t\tif (hasOwn(notSchema, \"format\") && hasOwn(sub, \"format\")) {\n\t\t\tconst subFormat = sub.format as string;\n\t\t\tconst notFormat = notSchema.format as string;\n\t\t\tif (subFormat === notFormat) return false; // Incompatible : sub a exactement le format exclu\n\t\t\t// Formats différents → compatible (approximation conservatrice)\n\t\t\treturn true;\n\t\t}\n\t}\n\n\t// Vérifier `not` dans sub ET dans sup (identité : { not: X } ⊆ { not: X })\n\tif (hasOwn(sub, \"not\") && hasOwn(sup, \"not\")) {\n\t\tif (deepEqual(sub.not, sup.not)) return true;\n\t}\n\n\treturn null; // Pas d'avis → laisser le merge engine décider\n}\n\n// ─── Not stripping helper ────────────────────────────────────────────────────\n\n/**\n * Retire le mot-clé `not` d'un schema pour permettre un merge propre\n * quand `evaluateNot` a déjà confirmé la compatibilité.\n *\n * Gère aussi le `not` imbriqué dans les `properties` : si une propriété\n * de `sup` a un `not` qui est compatible avec la propriété correspondante\n * de `sub`, on le retire également.\n *\n * Retourne le schema nettoyé, ou `null` si le schema est vide après retrait.\n *\n * Utilise `_.omit`, `_.has`, `_.keys`, `_.isEmpty`, `_.isPlainObject`.\n */\nfunction stripNotFromSup(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tstripTopLevel: boolean = true,\n): JSONSchema7Definition {\n\tif (typeof sup === \"boolean\" || typeof sub === \"boolean\") return sup;\n\n\tlet result = sup as JSONSchema7;\n\n\t// ── Retirer le `not` de niveau supérieur (seulement si confirmé) ──\n\tif (stripTopLevel && hasOwn(result, \"not\")) {\n\t\tresult = omitKeys(result as unknown as Record<string, unknown>, [\n\t\t\t\"not\",\n\t\t]) as JSONSchema7;\n\t}\n\n\t// ── Retirer les `not` dans les propriétés communes ──\n\t// Si sup.properties[key] a un `not` et que evaluateNot(sub.prop, sup.prop)\n\t// confirme la compatibilité, on retire le `not` de cette propriété aussi.\n\tif (\n\t\tisPlainObj(result.properties) &&\n\t\tisPlainObj((sub as JSONSchema7).properties)\n\t) {\n\t\tconst subProps = (sub as JSONSchema7).properties as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition\n\t\t>;\n\t\tconst supProps = result.properties as Record<string, JSONSchema7Definition>;\n\t\tlet newProps: Record<string, JSONSchema7Definition> | undefined;\n\n\t\tfor (const key of Object.keys(supProps)) {\n\t\t\tconst supPropDef = supProps[key];\n\t\t\tconst subPropDef = subProps[key];\n\t\t\tif (\n\t\t\t\tsupPropDef !== undefined &&\n\t\t\t\tsubPropDef !== undefined &&\n\t\t\t\ttypeof supPropDef !== \"boolean\" &&\n\t\t\t\ttypeof subPropDef !== \"boolean\" &&\n\t\t\t\thasOwn(supPropDef, \"not\")\n\t\t\t) {\n\t\t\t\t// Vérifier la compatibilité du not au niveau de la propriété\n\t\t\t\tconst propNotResult = evaluateNot(subPropDef, supPropDef);\n\t\t\t\tif (propNotResult === true) {\n\t\t\t\t\t// Lazy allocate newProps only on first modification\n\t\t\t\t\tif (!newProps) newProps = { ...supProps };\n\t\t\t\t\tnewProps[key] = omitKeys(\n\t\t\t\t\t\tsupPropDef as unknown as Record<string, unknown>,\n\t\t\t\t\t\t[\"not\"],\n\t\t\t\t\t) as JSONSchema7Definition;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (newProps) {\n\t\t\tresult = { ...result, properties: newProps };\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── Pattern stripping helper ────────────────────────────────────────────────\n\n/**\n * Retire le `pattern` de `sup` quand `isPatternSubset` a confirmé que\n * sub.pattern ⊆ sup.pattern par échantillonnage.\n *\n * Fonctionne comme `stripNotFromSup` : on retire la contrainte de sup\n * qui est déjà satisfaite par sub, pour éviter que le merge engine\n * produise un pattern combiné (lookahead conjunction) structurellement\n * différent du pattern de sub, ce qui causerait un faux négatif.\n *\n * Récurse dans les `properties` pour traiter les patterns imbriqués.\n *\n * @param sub  Le schema sub (utilisé pour extraire les patterns à comparer)\n * @param sup  Le schema sup dont on retire les patterns confirmés\n * @returns    Le schema sup nettoyé\n */\nfunction stripPatternFromSup(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n): JSONSchema7Definition {\n\tif (typeof sub === \"boolean\" || typeof sup === \"boolean\") return sup;\n\n\tconst supObj: JSONSchema7 = sup;\n\n\t// Lazy copy-on-write: only create a copy when the first mutation is needed.\n\tlet result: JSONSchema7 = supObj;\n\tlet copied = false;\n\n\tfunction ensureCopy(): JSONSchema7 {\n\t\tif (!copied) {\n\t\t\tresult = { ...supObj };\n\t\t\tcopied = true;\n\t\t}\n\t\treturn result;\n\t}\n\n\t// ── Top-level pattern ──\n\tif (\n\t\thasOwn(result, \"pattern\") &&\n\t\thasOwn(sub, \"pattern\") &&\n\t\tresult.pattern !== (sub as JSONSchema7).pattern\n\t) {\n\t\tconst patResult = isPatternSubset(\n\t\t\t(sub as JSONSchema7).pattern as string,\n\t\t\tresult.pattern as string,\n\t\t);\n\t\tif (patResult === true) {\n\t\t\tresult = omitKeys(ensureCopy() as unknown as Record<string, unknown>, [\n\t\t\t\t\"pattern\",\n\t\t\t]) as JSONSchema7;\n\t\t\tcopied = true;\n\t\t}\n\t}\n\n\t// ── Patterns dans les propriétés communes ──\n\tif (\n\t\tisPlainObj(result.properties) &&\n\t\tisPlainObj((sub as JSONSchema7).properties)\n\t) {\n\t\tconst subProps = (sub as JSONSchema7).properties as Record<\n\t\t\tstring,\n\t\t\tJSONSchema7Definition\n\t\t>;\n\t\tconst supProps = result.properties as Record<string, JSONSchema7Definition>;\n\t\tlet propsModified = false;\n\t\tlet newProps: Record<string, JSONSchema7Definition> | undefined;\n\n\t\tfor (const key of Object.keys(supProps)) {\n\t\t\tconst supPropDef = supProps[key];\n\t\t\tconst subPropDef = subProps[key];\n\t\t\tif (\n\t\t\t\tsupPropDef !== undefined &&\n\t\t\t\tsubPropDef !== undefined &&\n\t\t\t\ttypeof supPropDef !== \"boolean\" &&\n\t\t\t\ttypeof subPropDef !== \"boolean\" &&\n\t\t\t\thasOwn(supPropDef, \"pattern\") &&\n\t\t\t\thasOwn(subPropDef, \"pattern\") &&\n\t\t\t\tsupPropDef.pattern !== subPropDef.pattern\n\t\t\t) {\n\t\t\t\tconst propPatResult = isPatternSubset(\n\t\t\t\t\t(subPropDef as JSONSchema7).pattern as string,\n\t\t\t\t\t(supPropDef as JSONSchema7).pattern as string,\n\t\t\t\t);\n\t\t\t\tif (propPatResult === true) {\n\t\t\t\t\tif (!newProps) newProps = { ...supProps };\n\t\t\t\t\tnewProps[key] = omitKeys(\n\t\t\t\t\t\tsupPropDef as unknown as Record<string, unknown>,\n\t\t\t\t\t\t[\"pattern\"],\n\t\t\t\t\t) as JSONSchema7Definition;\n\t\t\t\t\tpropsModified = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tif (propsModified && newProps) {\n\t\t\tensureCopy().properties = newProps;\n\t\t}\n\t}\n\n\t// ── Pattern dans items (single schema) ──\n\tif (\n\t\tisPlainObj(result.items) &&\n\t\ttypeof result.items !== \"boolean\" &&\n\t\tisPlainObj((sub as JSONSchema7).items) &&\n\t\ttypeof (sub as JSONSchema7).items !== \"boolean\"\n\t) {\n\t\tconst subItems = (sub as JSONSchema7).items as JSONSchema7;\n\t\tconst supItems = result.items as JSONSchema7;\n\t\tif (\n\t\t\thasOwn(supItems, \"pattern\") &&\n\t\t\thasOwn(subItems, \"pattern\") &&\n\t\t\tsupItems.pattern !== subItems.pattern\n\t\t) {\n\t\t\tconst itemsPatResult = isPatternSubset(\n\t\t\t\tsubItems.pattern as string,\n\t\t\t\tsupItems.pattern as string,\n\t\t\t);\n\t\t\tif (itemsPatResult === true) {\n\t\t\t\tensureCopy().items = omitKeys(\n\t\t\t\t\tsupItems as unknown as Record<string, unknown>,\n\t\t\t\t\t[\"pattern\"],\n\t\t\t\t) as JSONSchema7Definition;\n\t\t\t}\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── Atomic subset check ─────────────────────────────────────────────────────\n\n/**\n * Vérifie si `sub ⊆ sup` pour deux schemas sans anyOf/oneOf (ou avec\n * anyOf/oneOf uniquement côté sup).\n *\n * Point 7 — Intègre un pré-check `not` étendu (`evaluateNot`) avant le merge.\n *\n * Quand `evaluateNot` confirme la compatibilité (`true`), on retire le `not`\n * de `sup` avant le merge pour éviter que le merge engine ajoute une contrainte\n * `not` que `sub` n'a pas (ce qui ferait échouer `isEqual(merged, sub)`).\n *\n * Pattern pre-check — Quand les deux schemas ont des patterns différents,\n * vérifie l'inclusion par échantillonnage via `isPatternSubset`. Si confirmé,\n * retire le pattern de sup avant le merge (même stratégie que pour `not`).\n *\n * Principe : merge(sub, sup) ≡ sub → sub est un sous-ensemble de sup.\n *\n * Utilise `_.some`, `_.has`, `_.omit`, `_.keys`, `_.isEmpty` pour la logique.\n */\nexport function isAtomicSubsetOf(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n): boolean {\n\tconst { branches: supBranches } = getBranchesTyped(sup);\n\n\t// Schema simple → merge direct\n\tif (supBranches.length === 1 && supBranches[0] === sup) {\n\t\t// Point 7 : pré-check `not` étendu\n\t\tconst notResult = evaluateNot(sub, sup);\n\t\tif (notResult === false) return false;\n\n\t\t// ── Format pre-check ──\n\t\t// Si les deux schemas ont un `format` différent, vérifier que\n\t\t// sub.format ⊆ sup.format. Sinon, sub ne peut pas être ⊆ sup.\n\t\t// Cela complète hasFormatConflict (qui gère le merge) en gérant\n\t\t// la direction du subset check que le merge ne peut pas résoudre.\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof sup !== \"boolean\" &&\n\t\t\thasOwn(sub, \"format\") &&\n\t\t\thasOwn(sup, \"format\") &&\n\t\t\tsub.format !== sup.format\n\t\t) {\n\t\t\tconst fmtResult = isFormatSubset(\n\t\t\t\tsub.format as string,\n\t\t\t\tsup.format as string,\n\t\t\t);\n\t\t\tif (fmtResult !== true) return false;\n\t\t}\n\n\t\t// ── Pattern pre-check ──\n\t\t// Si les deux schemas ont des patterns différents, vérifier l'inclusion\n\t\t// par échantillonnage. Si sub.pattern ⊄ sup.pattern (contre-exemple trouvé),\n\t\t// on retourne false immédiatement. Sinon, on pourra retirer le pattern\n\t\t// de sup pour éviter le faux négatif structurel du merge.\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof sup !== \"boolean\" &&\n\t\t\thasOwn(sub, \"pattern\") &&\n\t\t\thasOwn(sup, \"pattern\") &&\n\t\t\tsub.pattern !== sup.pattern\n\t\t) {\n\t\t\tconst patResult = isPatternSubset(\n\t\t\t\tsub.pattern as string,\n\t\t\t\tsup.pattern as string,\n\t\t\t);\n\t\t\tif (patResult === false) return false;\n\t\t}\n\n\t\t// Retirer `not` de sup (top-level et/ou dans les properties)\n\t\t// quand evaluateNot confirme la compatibilité au niveau correspondant.\n\t\t// Cela évite que le merge engine ajoute une contrainte `not` que sub n'a pas\n\t\t// (ce qui ferait merged ≠ sub et produirait un faux négatif).\n\t\tlet effectiveSup = sup;\n\t\tif (typeof sup !== \"boolean\") {\n\t\t\t// Si top-level not est confirmé compatible → retirer le not top-level\n\t\t\tif (notResult === true) {\n\t\t\t\teffectiveSup = stripNotFromSup(sub, sup, true);\n\t\t\t\t// Si sup n'avait QUE `not` → sub est compatible (le not est résolu)\n\t\t\t\tif (\n\t\t\t\t\ttypeof effectiveSup !== \"boolean\" &&\n\t\t\t\t\tObject.keys(effectiveSup).length === 0\n\t\t\t\t) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Même si le top-level not n'est pas confirmé (null), on tente\n\t\t\t\t// de retirer les `not` dans les properties individuelles\n\t\t\t\t// sans toucher au `not` top-level\n\t\t\t\teffectiveSup = stripNotFromSup(sub, sup, false);\n\t\t\t}\n\n\t\t\t// Retirer les patterns de sup confirmés par échantillonnage.\n\t\t\t// Même stratégie que pour `not` : on retire la contrainte déjà\n\t\t\t// satisfaite par sub pour éviter que le merge produise un pattern\n\t\t\t// combiné (lookahead conjunction) structurellement ≠ sub.\n\t\t\teffectiveSup = stripPatternFromSup(sub, effectiveSup);\n\t\t}\n\n\t\tconst merged = engine.merge(sub, effectiveSup);\n\t\tif (merged === null) return false;\n\t\t// Fast path: if merged is already structurally equal to sub,\n\t\t// skip normalize entirely. This is the common case when sub ⊆ sup\n\t\t// (A ∩ B = A), saving O(n) normalize traversal on wide schemas.\n\t\tif (deepEqual(merged, sub)) return true;\n\t\t// Slow path: normalize to eliminate merge artifacts (e.g. redundant\n\t\t// enum when const is present), then compare.\n\t\tconst normalizedMerged = normalize(merged);\n\t\treturn (\n\t\t\tdeepEqual(normalizedMerged, sub) || engine.isEqual(normalizedMerged, sub)\n\t\t);\n\t}\n\n\t// anyOf/oneOf dans sup → au moins une branche doit accepter sub\n\treturn supBranches.some((branch) => {\n\t\t// Point 7 : pré-check `not` étendu par branche\n\t\tconst notResult = evaluateNot(sub, branch);\n\t\tif (notResult === false) return false;\n\n\t\t// ── Pattern pre-check par branche ──\n\t\tif (\n\t\t\ttypeof sub !== \"boolean\" &&\n\t\t\ttypeof branch !== \"boolean\" &&\n\t\t\thasOwn(sub, \"pattern\") &&\n\t\t\thasOwn(branch, \"pattern\") &&\n\t\t\tsub.pattern !== branch.pattern\n\t\t) {\n\t\t\tconst patResult = isPatternSubset(\n\t\t\t\tsub.pattern as string,\n\t\t\t\tbranch.pattern as string,\n\t\t\t);\n\t\t\tif (patResult === false) return false;\n\t\t}\n\n\t\t// Même logique de strip pour les branches\n\t\tlet effectiveBranch = branch;\n\t\tif (typeof branch !== \"boolean\") {\n\t\t\tif (notResult === true) {\n\t\t\t\teffectiveBranch = stripNotFromSup(sub, branch, true);\n\t\t\t\tif (\n\t\t\t\t\ttypeof effectiveBranch !== \"boolean\" &&\n\t\t\t\t\tObject.keys(effectiveBranch).length === 0\n\t\t\t\t) {\n\t\t\t\t\treturn true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\teffectiveBranch = stripNotFromSup(sub, branch, false);\n\t\t\t}\n\n\t\t\t// Strip patterns confirmés par échantillonnage\n\t\t\teffectiveBranch = stripPatternFromSup(sub, effectiveBranch);\n\t\t}\n\n\t\tconst merged = engine.merge(sub, effectiveBranch);\n\t\tif (merged === null) return false;\n\t\t// Fast path: skip normalize if merged already equals sub\n\t\tif (deepEqual(merged, sub)) return true;\n\t\tconst normalizedBranch = normalize(merged);\n\t\treturn (\n\t\t\tdeepEqual(normalizedBranch, sub) || engine.isEqual(normalizedBranch, sub)\n\t\t);\n\t});\n}\n\n// ─── Full subset check (with diffs) ─────────────────────────────────────────\n\n/**\n * Vérifie `sub ⊆ sup` pour un sub qui a des branches (anyOf/oneOf).\n * Chaque branche de sub doit être acceptée par sup.\n *\n * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf[i]` de\n * `oneOf[i]` dans les paths de diff.\n *\n * Utilise `_.every` / `_.flatMap` / `_.map` pour une itération idiomatique.\n */\nexport function checkBranchedSub(\n\tsubBranches: JSONSchema7Definition[],\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n\tbranchType: BranchType = \"anyOf\",\n): SubsetResult {\n\tconst allDiffs: SchemaDiff[] = [];\n\tlet allSubset = true;\n\n\t// Point 6 : utilise le type de branche réel pour le path\n\tconst branchLabel = branchType === \"none\" ? \"anyOf\" : branchType;\n\n\tfor (let i = 0; i < subBranches.length; i++) {\n\t\tconst branch = subBranches[i];\n\t\tif (branch === undefined) continue;\n\t\tif (!isAtomicSubsetOf(branch, sup, engine)) {\n\t\t\tallSubset = false;\n\t\t\tallDiffs.push({\n\t\t\t\tpath: `${branchLabel}[${i}]`,\n\t\t\t\ttype: \"changed\",\n\t\t\t\tsourceValue: branch,\n\t\t\t\tmergedValue: \"Branch not accepted by superset\",\n\t\t\t});\n\t\t}\n\t}\n\n\tconst semanticDiffs = allSubset\n\t\t? []\n\t\t: computeSemanticDiffs(subBranches[0] ?? true, sup, allDiffs);\n\n\treturn {\n\t\tisSubset: allSubset,\n\t\tmerged: allSubset\n\t\t\t? branchType === \"oneOf\"\n\t\t\t\t? { oneOf: subBranches }\n\t\t\t\t: { anyOf: subBranches }\n\t\t\t: null,\n\t\tdiffs: allDiffs,\n\t\tsemanticDiffs,\n\t};\n}\n\n/**\n * Vérifie `sub ⊆ sup` pour un sup qui a des branches (anyOf/oneOf).\n * Au moins une branche de sup doit accepter sub.\n *\n * Point 6 — Utilise le type de branche de sup pour des messages plus précis.\n *\n * Utilise `_.some` pour trouver la première branche compatible.\n */\nexport function checkBranchedSup(\n\tsub: JSONSchema7Definition,\n\tsupBranches: JSONSchema7Definition[],\n\tengine: MergeEngine,\n\tbranchType: BranchType = \"anyOf\",\n): SubsetResult {\n\tfor (const branch of supBranches) {\n\t\t// Strip patterns confirmés par échantillonnage avant le merge\n\t\tlet effectiveBranch = branch;\n\t\tif (typeof sub !== \"boolean\" && typeof branch !== \"boolean\") {\n\t\t\teffectiveBranch = stripPatternFromSup(sub, branch);\n\t\t}\n\t\tconst merged = engine.merge(sub, effectiveBranch);\n\t\tif (merged !== null) {\n\t\t\t// Fast path: skip normalize if merged already equals sub\n\t\t\tif (deepEqual(merged, sub)) {\n\t\t\t\treturn { isSubset: true, merged, diffs: [], semanticDiffs: [] };\n\t\t\t}\n\t\t\tconst normalizedMerged = normalize(merged);\n\t\t\tif (\n\t\t\t\tdeepEqual(normalizedMerged, sub) ||\n\t\t\t\tengine.isEqual(normalizedMerged, sub)\n\t\t\t) {\n\t\t\t\treturn { isSubset: true, merged, diffs: [], semanticDiffs: [] };\n\t\t\t}\n\t\t}\n\t}\n\n\t// Point 6 : message précis selon le type de branche\n\tconst branchLabel = branchType === \"none\" ? \"anyOf\" : branchType;\n\n\tconst fallbackDiffs: SchemaDiff[] = [\n\t\t{\n\t\t\tpath: \"$\",\n\t\t\ttype: \"changed\",\n\t\t\tsourceValue: sub,\n\t\t\tmergedValue: `No branch in superset's ${branchLabel} accepts this schema`,\n\t\t},\n\t];\n\n\treturn {\n\t\tisSubset: false,\n\t\tmerged: null,\n\t\tdiffs: fallbackDiffs,\n\t\tsemanticDiffs: computeSemanticDiffs(\n\t\t\tsub,\n\t\t\tbranchType === \"oneOf\" ? { oneOf: supBranches } : { anyOf: supBranches },\n\t\t\tfallbackDiffs,\n\t\t),\n\t};\n}\n\n/**\n * Vérifie `sub ⊆ sup` pour deux schemas atomiques (sans anyOf/oneOf).\n * Utilise `mergeOrThrow` pour capturer les erreurs d'incompatibilité.\n *\n * Utilise `deepEqual` pour la comparaison structurelle (avec short-circuit\n * par référence et comptage de clés).\n */\nexport function checkAtomic(\n\tsub: JSONSchema7Definition,\n\tsup: JSONSchema7Definition,\n\tengine: MergeEngine,\n): SubsetResult {\n\t// Strip patterns confirmés par échantillonnage avant le merge,\n\t// même stratégie que dans isAtomicSubsetOf pour éviter les faux négatifs\n\t// structurels causés par la conjonction de patterns en lookahead.\n\tlet effectiveSup = sup;\n\tif (typeof sub !== \"boolean\" && typeof sup !== \"boolean\") {\n\t\teffectiveSup = stripPatternFromSup(sub, sup);\n\t}\n\n\ttry {\n\t\tconst merged = engine.mergeOrThrow(sub, effectiveSup);\n\n\t\t// Fast path: skip normalize if merged already equals sub\n\t\tif (deepEqual(merged, sub)) {\n\t\t\treturn { isSubset: true, merged, diffs: [], semanticDiffs: [] };\n\t\t}\n\n\t\tconst normalizedMerged = normalize(merged);\n\n\t\tif (\n\t\t\tdeepEqual(normalizedMerged, sub) ||\n\t\t\tengine.isEqual(normalizedMerged, sub)\n\t\t) {\n\t\t\treturn {\n\t\t\t\tisSubset: true,\n\t\t\t\tmerged: normalizedMerged,\n\t\t\t\tdiffs: [],\n\t\t\t\tsemanticDiffs: [],\n\t\t\t};\n\t\t}\n\n\t\tconst diffs = computeDiffs(sub, normalizedMerged, \"\");\n\t\tconst semanticDiffs = computeSemanticDiffs(sub, effectiveSup, diffs);\n\t\treturn { isSubset: false, merged: normalizedMerged, diffs, semanticDiffs };\n\t} catch (e) {\n\t\tconst diffs: SchemaDiff[] = [\n\t\t\t{\n\t\t\t\tpath: \"$\",\n\t\t\t\ttype: \"changed\",\n\t\t\t\tsourceValue: sub,\n\t\t\t\tmergedValue: `Incompatible: ${e instanceof Error ? e.message : String(e)}`,\n\t\t\t},\n\t\t];\n\t\treturn {\n\t\t\tisSubset: false,\n\t\t\tmerged: null,\n\t\t\tdiffs,\n\t\t\tsemanticDiffs: computeSemanticDiffs(sub, effectiveSup, diffs),\n\t\t};\n\t}\n}\n"
-  ],
-  "mappings": "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",
-  "debugId": "189EA8740626810064756E2164756E21",
-  "names": []
-}

package/dist/chunk-8qenxa2z.js

@@ -1,7 +0,0 @@
-var z={"missing-required-property":"\uD83D\uDD34","property-not-guaranteed":"\uD83D\uDFE1","type-mismatch":"\uD83D\uDD34","type-too-wide":"\uD83D\uDFE0","enum-not-subset":"\uD83D\uDFE0","const-mismatch":"\uD83D\uDD34","constraint-too-loose":"\uD83D\uDFE1","additional-properties-conflict":"\uD83D\uDFE0","property-not-allowed":"\uD83D\uDD34","format-mismatch":"\uD83D\uDFE1","pattern-not-subset":"\uD83D\uDFE1","incompatible-items":"\uD83D\uDFE0","schema-incompatible":"\uD83D\uDD34"};function B(j){switch(j.type){case"added":return`  + ${j.path}: ${JSON.stringify(j.mergedValue)}`;case"removed":return`  - ${j.path}: was ${JSON.stringify(j.sourceValue)}`;default:return`  ~ ${j.path}: ${JSON.stringify(j.sourceValue)} → ${JSON.stringify(j.mergedValue)}`}}function y(j){return`  ${z[j.type]??"⚪"} [${j.type}] ${j.message}`}function H(j,k){let w=[`${k.isSubset?"✅":"❌"} ${j}: ${k.isSubset}`];if(!k.isSubset){if(k.semanticDiffs&&k.semanticDiffs.length>0){w.push("   Diffs:");for(let x of k.semanticDiffs)w.push(`     ${y(x)}`)}else if(k.diffs.length>0){w.push("   Diffs (structural):");for(let x of k.diffs)w.push(`     ${B(x)}`)}}return w.join(`
-`)}function J(j){if(j.length===0)return"";return j.map(y).join(`
-`)}
-export{H as n,J as o};
-
-//# debugId=D076377302008F4164756E2164756E21
-//# sourceMappingURL=chunk-8qenxa2z.js.map

package/dist/chunk-8qenxa2z.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/formatter.ts"],
-  "sourcesContent": [
-    "import type { SemanticDiff } from \"./semantic-diff/types\";\nimport type { SubsetResult } from \"./types\";\n\n// ─── Result Formatter ────────────────────────────────────────────────────────\n//\n// Formate un `SubsetResult` en chaîne lisible pour logs / debug.\n// Supporte les diffs structurelles (legacy) et les diffs sémantiques.\n\n// ─── Semantic diff icons ─────────────────────────────────────────────────────\n\n/** Icône associée à chaque type de diff sémantique */\nconst SEMANTIC_ICONS: Readonly<Record<string, string>> = {\n\t\"missing-required-property\": \"🔴\",\n\t\"property-not-guaranteed\": \"🟡\",\n\t\"type-mismatch\": \"🔴\",\n\t\"type-too-wide\": \"🟠\",\n\t\"enum-not-subset\": \"🟠\",\n\t\"const-mismatch\": \"🔴\",\n\t\"constraint-too-loose\": \"🟡\",\n\t\"additional-properties-conflict\": \"🟠\",\n\t\"property-not-allowed\": \"🔴\",\n\t\"format-mismatch\": \"🟡\",\n\t\"pattern-not-subset\": \"🟡\",\n\t\"incompatible-items\": \"🟠\",\n\t\"schema-incompatible\": \"🔴\",\n};\n\n// ─── Structural diff formatting (legacy) ─────────────────────────────────────\n\n/**\n * Formate un diff structurel individuel en ligne lisible avec préfixe iconique.\n *\n * @param d  Le diff à formater\n * @returns  Ligne formatée avec +, - ou ~ selon le type\n */\nfunction formatStructuralDiffLine(d: {\n\ttype: string;\n\tpath: string;\n\tsourceValue: unknown;\n\tmergedValue: unknown;\n}): string {\n\tswitch (d.type) {\n\t\tcase \"added\":\n\t\t\treturn `  + ${d.path}: ${JSON.stringify(d.mergedValue)}`;\n\t\tcase \"removed\":\n\t\t\treturn `  - ${d.path}: was ${JSON.stringify(d.sourceValue)}`;\n\t\tdefault:\n\t\t\treturn `  ~ ${d.path}: ${JSON.stringify(d.sourceValue)} → ${JSON.stringify(d.mergedValue)}`;\n\t}\n}\n\n// ─── Semantic diff formatting ────────────────────────────────────────────────\n\n/**\n * Formate un diff sémantique en ligne lisible avec icône et message.\n *\n * @param d  Le diff sémantique à formater\n * @returns  Ligne formatée avec icône, type et message\n */\nfunction formatSemanticDiffLine(d: SemanticDiff): string {\n\tconst icon = SEMANTIC_ICONS[d.type] ?? \"⚪\";\n\treturn `  ${icon} [${d.type}] ${d.message}`;\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Formate un SubsetResult en chaîne lisible (utile pour logs/debug).\n *\n * Affiche les diffs sémantiques en priorité (si disponibles),\n * avec un fallback sur les diffs structurelles.\n *\n * @param label   Label descriptif du check (ex: \"strict ⊆ loose\")\n * @param result  Le résultat du check à formater\n * @returns       Chaîne multi-lignes formatée avec icônes et diffs\n *\n * @example\n * ```\n * ✅ strict ⊆ loose: true\n * ```\n *\n * @example\n * ```\n * ❌ loose ⊆ strict: false\n *    Diffs:\n *      🔴 [missing-required-property] Target requires property 'meetingId' (string) which source does not provide\n * ```\n */\nexport function formatResult(label: string, result: SubsetResult): string {\n\tconst icon = result.isSubset ? \"✅\" : \"❌\";\n\tconst lines: string[] = [`${icon} ${label}: ${result.isSubset}`];\n\n\tif (!result.isSubset) {\n\t\t// Prefer semantic diffs over structural diffs\n\t\tif (result.semanticDiffs && result.semanticDiffs.length > 0) {\n\t\t\tlines.push(\"   Diffs:\");\n\t\t\tfor (const d of result.semanticDiffs) {\n\t\t\t\tlines.push(`     ${formatSemanticDiffLine(d)}`);\n\t\t\t}\n\t\t} else if (result.diffs.length > 0) {\n\t\t\tlines.push(\"   Diffs (structural):\");\n\t\t\tfor (const d of result.diffs) {\n\t\t\t\tlines.push(`     ${formatStructuralDiffLine(d)}`);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn lines.join(\"\\n\");\n}\n\n/**\n * Formate uniquement les diffs sémantiques en chaîne lisible.\n *\n * Utile quand on veut afficher les diagnostics sans le résultat global.\n *\n * @param diffs  Les diffs sémantiques à formater\n * @returns      Chaîne multi-lignes, ou chaîne vide si pas de diffs\n */\nexport function formatSemanticDiffs(diffs: SemanticDiff[]): string {\n\tif (diffs.length === 0) return \"\";\n\treturn diffs.map(formatSemanticDiffLine).join(\"\\n\");\n}\n"
-  ],
-  "mappings": "AAWA,IAAM,EAAmD,CACxD,4BAA6B,eAC7B,0BAA2B,eAC3B,gBAAiB,eACjB,gBAAiB,eACjB,kBAAmB,eACnB,iBAAkB,eAClB,uBAAwB,eACxB,iCAAkC,eAClC,uBAAwB,eACxB,kBAAmB,eACnB,qBAAsB,eACtB,qBAAsB,eACtB,sBAAuB,cACxB,EAUA,SAAS,CAAwB,CAAC,EAKvB,CACV,OAAQ,EAAE,UACJ,QACJ,MAAO,OAAO,EAAE,SAAS,KAAK,UAAU,EAAE,WAAW,QACjD,UACJ,MAAO,OAAO,EAAE,aAAa,KAAK,UAAU,EAAE,WAAW,YAEzD,MAAO,OAAO,EAAE,SAAS,KAAK,UAAU,EAAE,WAAW,OAAM,KAAK,UAAU,EAAE,WAAW,KAY1F,SAAS,CAAsB,CAAC,EAAyB,CAExD,MAAO,KADM,EAAe,EAAE,OAAS,QAClB,EAAE,SAAS,EAAE,UA2B5B,SAAS,CAAY,CAAC,EAAe,EAA8B,CAEzE,IAAM,EAAkB,CAAC,GADZ,EAAO,SAAW,IAAK,OACA,MAAU,EAAO,UAAU,EAE/D,GAAI,CAAC,EAAO,UAEX,GAAI,EAAO,eAAiB,EAAO,cAAc,OAAS,EAAG,CAC5D,EAAM,KAAK,WAAW,EACtB,QAAW,KAAK,EAAO,cACtB,EAAM,KAAK,QAAQ,EAAuB,CAAC,GAAG,EAEzC,QAAI,EAAO,MAAM,OAAS,EAAG,CACnC,EAAM,KAAK,wBAAwB,EACnC,QAAW,KAAK,EAAO,MACtB,EAAM,KAAK,QAAQ,EAAyB,CAAC,GAAG,GAKnD,OAAO,EAAM,KAAK;AAAA,CAAI,EAWhB,SAAS,CAAmB,CAAC,EAA+B,CAClE,GAAI,EAAM,SAAW,EAAG,MAAO,GAC/B,OAAO,EAAM,IAAI,CAAsB,EAAE,KAAK;AAAA,CAAI",
-  "debugId": "D076377302008F4164756E2164756E21",
-  "names": []
-}

package/dist/chunk-etwjsbj3.js

@@ -1,5 +0,0 @@
-import{u as q}from"./chunk-gdf3h8q4.js";import{x,y as X,z as _}from"./chunk-w1ypc97a.js";import{createComparator as K,createMerger as T,createShallowAllOfMerge as E}from"@x0k/json-schema-merge";import{createDeduplicator as I,createIntersector as V}from"@x0k/json-schema-merge/lib/array";function j(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;let Q=X(z,"const"),J=X(B,"const"),U=z.const,Z=B.const,G=z.enum,Y=B.enum;if(Q&&J)return!_(U,Z);if(Q&&Array.isArray(Y))return!Y.some(($)=>_($,U));if(J&&Array.isArray(G))return!G.some(($)=>_($,Z));return!1}var F=["items","additionalProperties","contains","propertyNames","not"],M=["properties","patternProperties"];function v(z,B){if(j(z,B))return!0;if(typeof z==="boolean"||typeof B==="boolean")return!1;for(let Q of F){let J=z[Q],U=B[Q];if(x(J)&&x(U)&&v(J,U))return!0}for(let Q of M){let J=z[Q],U=B[Q];if(!x(J)||!x(U))continue;let Z=J,G=U;for(let Y of Object.keys(Z)){let $=Z[Y],W=G[Y];if($!==void 0&&W!==void 0&&X(G,Y)&&v($,W))return!0}}if(Array.isArray(z.items)&&Array.isArray(B.items)){let Q=z.items,J=B.items,U=Math.min(Q.length,J.length);for(let Z=0;Z<U;Z++){let G=Q[Z],Y=J[Z];if(G===void 0||Y===void 0)continue;if(v(G,Y))return!0}}return!1}function A(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;let Q=x(z.properties)?z.properties:void 0,J=x(B.properties)?B.properties:void 0;if(!Q&&!J)return!1;let U=Q?Object.keys(Q):[],Z=J?Object.keys(J):[],G=Array.isArray(z.required)?z.required:[],Y=Array.isArray(B.required)?B.required:[];if(z.additionalProperties===!1&&Q&&J){if(Y.some((W)=>!X(Q,W)&&X(J,W))&&U.length>0)return!0}if(x(z.additionalProperties)&&typeof z.additionalProperties!=="boolean"&&Q&&J){let $=z.additionalProperties;if(X($,"type")){let W=$.type;if(Y.some((N)=>{if(X(Q,N))return!1;if(!X(J,N))return!1;let g=J[N];if(typeof g==="boolean")return!1;let L=g;if(!X(L,"type"))return!1;if(typeof W==="string"&&typeof L.type==="string")return W!==L.type&&!(W==="number"&&L.type==="integer")&&!(W==="integer"&&L.type==="number");return!1}))return!0}}if(B.additionalProperties===!1&&J&&Q){if(G.some((W)=>!X(J,W)&&X(Q,W))&&Z.length>0)return!0}if(x(B.additionalProperties)&&typeof B.additionalProperties!=="boolean"&&J&&Q){let $=B.additionalProperties;if(X($,"type")){let W=$.type;if(G.some((N)=>{if(X(J,N))return!1;if(!X(Q,N))return!1;let g=Q[N];if(typeof g==="boolean")return!1;let L=g;if(!X(L,"type"))return!1;if(typeof W==="string"&&typeof L.type==="string")return W!==L.type&&!(W==="number"&&L.type==="integer")&&!(W==="integer"&&L.type==="number");return!1}))return!0}}if(Q&&J)for(let $ of U){if(!X(J,$))continue;let W=Q[$],R=J[$];if(typeof W==="boolean"||typeof R==="boolean")continue;if(A(W,R))return!0}return!1}function H(z,B){if(typeof z==="boolean"||typeof B==="boolean")return!1;if(X(z,"format")&&X(B,"format")){let Q=z.format,J=B.format;if(Q!==J){if(q(Q,J)!==!0){if(q(J,Q)!==!0)return!0}}}if(x(z.properties)&&x(B.properties)){let Q=z.properties,J=B.properties;for(let U of Object.keys(Q)){let Z=Q[U],G=J[U];if(Z!==void 0&&G!==void 0&&X(J,U)&&H(Z,G))return!0}}if(x(z.items)&&x(B.items)){if(H(z.items,B.items))return!0}if(x(z.additionalProperties)&&x(B.additionalProperties)){if(H(z.additionalProperties,B.additionalProperties))return!0}return!1}class u{compareFn;shallowAllOfMergeFn;constructor(){let{compareSchemaDefinitions:z,compareSchemaValues:B}=K(),Q=(U,Z)=>{if(U===null&&Z===null)return 0;return B(U,Z)},{mergeArrayOfSchemaDefinitions:J}=T({intersectJson:V(Q),deduplicateJsonSchemaDef:I(z)});this.compareFn=z,this.shallowAllOfMergeFn=E(J)}merge(z,B){if(v(z,B))return null;if(H(z,B))return null;if(A(z,B))return null;try{return this.shallowAllOfMergeFn({allOf:[z,B]})}catch{return null}}mergeOrThrow(z,B){if(v(z,B))throw Error("Incompatible const values: schemas have conflicting const constraints");if(H(z,B))throw Error("Incompatible format values: schemas have conflicting format constraints");if(A(z,B))throw Error("Incompatible additionalProperties: required properties conflict with additionalProperties constraint");return this.shallowAllOfMergeFn({allOf:[z,B]})}compare(z,B){return this.compareFn(z,B)}isEqual(z,B){return this.compareFn(z,B)===0}}
-export{u as p};
-
-//# debugId=B46B487D9063BA4D64756E2164756E21
-//# sourceMappingURL=chunk-etwjsbj3.js.map

package/dist/chunk-jy9206ze.js

@@ -1,5 +0,0 @@
-import{c as U,d as V,e as Y,f as Z,g as _}from"./chunk-8me729r7.js";import{l as Q}from"./chunk-ayae82am.js";import{n as W}from"./chunk-8qenxa2z.js";import{p as X}from"./chunk-etwjsbj3.js";import{w as J}from"./chunk-ywa6h8q4.js";import{z as K}from"./chunk-w1ypc97a.js";class F{engine;constructor(){this.engine=new X}isSubset(j,x){if(j===x)return!0;if(K(j,x))return!0;let w=J(j),G=J(x);if(w!==j&&G!==x&&K(w,G))return!0;if(w!==G&&K(w,G))return!0;let{branches:H}=U(w);if(H.length>1||H[0]!==w)return H.every((L)=>V(L,G,this.engine));return V(w,G,this.engine)}check(j,x){if(j===x)return{isSubset:!0,merged:j,diffs:[],semanticDiffs:[]};if(K(j,x))return{isSubset:!0,merged:j,diffs:[],semanticDiffs:[]};let w=J(j),G=J(x);if(K(w,G))return{isSubset:!0,merged:w,diffs:[],semanticDiffs:[]};let{branches:H,type:L}=U(w),{branches:N,type:$}=U(G);if(H.length>1||H[0]!==w)return Y(H,G,this.engine,L);if(N.length>1||N[0]!==G)return Z(w,N,this.engine,$);return _(w,G,this.engine)}canConnect(j,x){return{...this.check(j,x),direction:"sourceOutput ⊆ targetInput"}}isEqual(j,x){return this.engine.isEqual(J(j),J(x))}intersect(j,x){if(j===x||K(j,x))return J(j);let w=J(j),G=J(x);if(K(w,G))return w;let H=this.engine.merge(w,G);if(H===null)return null;if(K(H,w)||K(H,G))return H;return J(H)}resolveConditions(j,x){return Q(j,x,this.engine)}checkResolved(j,x,w,G){let H=Q(j,w,this.engine),L=Q(x,G??w,this.engine);return{...this.check(H.resolved,L.resolved),resolvedSub:H,resolvedSup:L}}normalize(j){return J(j)}formatResult(j,x){return W(j,x)}}
-export{F as a};
-
-//# debugId=F7539F5812EBB21364756E2164756E21
-//# sourceMappingURL=chunk-jy9206ze.js.map

package/dist/chunk-jy9206ze.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/json-schema-compatibility-checker.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport { resolveConditions } from \"./condition-resolver\";\nimport { formatResult } from \"./formatter\";\nimport { MergeEngine } from \"./merge-engine\";\nimport { normalize } from \"./normalizer\";\nimport {\n\tarePatternsEquivalent,\n\tisPatternSubset,\n\tisTrivialPattern,\n} from \"./pattern-subset\";\nimport type { BranchResult, BranchType } from \"./subset-checker\";\nimport {\n\tcheckAtomic,\n\tcheckBranchedSub,\n\tcheckBranchedSup,\n\tgetBranchesTyped,\n\tisAtomicSubsetOf,\n} from \"./subset-checker\";\nimport type {\n\tConnectionResult,\n\tResolvedConditionResult,\n\tSchemaDiff,\n\tSubsetResult,\n} from \"./types\";\nimport { deepEqual } from \"./utils\";\n\n// ─── Re-exports ──────────────────────────────────────────────────────────────\n\nexport type {\n\tSchemaDiff,\n\tSubsetResult,\n\tConnectionResult,\n\tResolvedConditionResult,\n\tBranchType,\n\tBranchResult,\n};\n\nexport {\n\tnormalize,\n\tresolveConditions,\n\tformatResult,\n\tMergeEngine,\n\tisPatternSubset,\n\tarePatternsEquivalent,\n\tisTrivialPattern,\n};\n\n// ─── Main Class ──────────────────────────────────────────────────────────────\n//\n// Façade légère qui orchestre les sous-modules pour vérifier la compatibilité\n// entre JSON Schemas (Draft-07).\n//\n// Principe mathématique :\n//   A ⊆ B  ⟺  A ∩ B ≡ A\n//\n// En JSON Schema :\n//   - A ∩ B  =  allOf([A, B])  résolu via merge\n//   - ≡      =  comparaison structurelle\n//\n// @example\n// ```ts\n// const checker = new JsonSchemaCompatibilityChecker();\n//\n// checker.isSubset(strict, loose);             // true\n// checker.check(loose, strict);                // { isSubset: false, diffs: [...] }\n// checker.canConnect(nodeA.output, nodeB.input); // ConnectionResult\n// ```\n\nexport class JsonSchemaCompatibilityChecker {\n\tprivate readonly engine: MergeEngine;\n\n\tconstructor() {\n\t\tthis.engine = new MergeEngine();\n\t}\n\n\t// ── Subset check (boolean) ─────────────────────────────────────────────\n\n\t/**\n\t * Vérifie si `sub ⊆ sup`.\n\t * Toute valeur valide pour sub est-elle aussi valide pour sup ?\n\t *\n\t * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf` de `oneOf`\n\t * en interne, bien que le résultat boolean ne reflète pas la distinction.\n\t */\n\tisSubset(sub: JSONSchema7Definition, sup: JSONSchema7Definition): boolean {\n\t\t// ── Identity short-circuit ──\n\t\t// If sub and sup are the same reference, sub ⊆ sup is trivially true.\n\t\t// This avoids the entire normalize + merge + compare pipeline.\n\t\tif (sub === sup) return true;\n\n\t\t// ── Pre-normalize structural equality ──\n\t\t// If sub and sup are structurally identical before normalization,\n\t\t// they represent the same schema → sub ⊆ sup trivially.\n\t\t// This avoids the WeakMap overhead of normalize() for common cases\n\t\t// like {} ⊆ {} or identical schema objects with different references.\n\t\tif (deepEqual(sub, sup)) return true;\n\n\t\tconst nSub = normalize(sub);\n\t\tconst nSup = normalize(sup);\n\n\t\t// ── Post-normalize structural identity ──\n\t\t// After normalization, schemas that were syntactically different\n\t\t// but semantically equivalent become structurally equal\n\t\t// (e.g. {const:1} vs {const:1, type:\"integer\"}).\n\t\tif (nSub !== sub && nSup !== sup && deepEqual(nSub, nSup)) return true;\n\t\tif (nSub !== nSup && deepEqual(nSub, nSup)) return true;\n\n\t\tconst { branches: subBranches } = getBranchesTyped(nSub);\n\n\t\tif (subBranches.length > 1 || subBranches[0] !== nSub) {\n\t\t\treturn subBranches.every((branch) =>\n\t\t\t\tisAtomicSubsetOf(branch, nSup, this.engine),\n\t\t\t);\n\t\t}\n\n\t\treturn isAtomicSubsetOf(nSub, nSup, this.engine);\n\t}\n\n\t// ── Subset check (detailed) ────────────────────────────────────────────\n\n\t/**\n\t * Vérifie `sub ⊆ sup` et retourne un diagnostic complet\n\t * avec les diffs structurels.\n\t *\n\t * Point 6 — Utilise `getBranchesTyped` pour distinguer `anyOf` de `oneOf`\n\t * dans les paths de diff (ex: `anyOf[0]` vs `oneOf[0]`).\n\t */\n\tcheck(sub: JSONSchema7Definition, sup: JSONSchema7Definition): SubsetResult {\n\t\t// ── Identity short-circuit ──\n\t\t// Same reference → no diffs, no merge needed.\n\t\tif (sub === sup) {\n\t\t\treturn { isSubset: true, merged: sub, diffs: [], semanticDiffs: [] };\n\t\t}\n\n\t\t// ── Pre-normalize structural equality ──\n\t\t// Avoids WeakMap overhead for identical schemas ({} ⊆ {}, etc.).\n\t\tif (deepEqual(sub, sup)) {\n\t\t\treturn { isSubset: true, merged: sub, diffs: [], semanticDiffs: [] };\n\t\t}\n\n\t\tconst nSub = normalize(sub);\n\t\tconst nSup = normalize(sup);\n\n\t\t// ── Post-normalize structural identity ──\n\t\t// Catches semantically equivalent schemas after normalization.\n\t\tif (deepEqual(nSub, nSup)) {\n\t\t\treturn { isSubset: true, merged: nSub, diffs: [], semanticDiffs: [] };\n\t\t}\n\n\t\tconst { branches: subBranches, type: subBranchType } =\n\t\t\tgetBranchesTyped(nSub);\n\t\tconst { branches: supBranches, type: supBranchType } =\n\t\t\tgetBranchesTyped(nSup);\n\n\t\t// anyOf/oneOf dans sub\n\t\tif (subBranches.length > 1 || subBranches[0] !== nSub) {\n\t\t\treturn checkBranchedSub(subBranches, nSup, this.engine, subBranchType);\n\t\t}\n\n\t\t// anyOf/oneOf dans sup uniquement\n\t\tif (supBranches.length > 1 || supBranches[0] !== nSup) {\n\t\t\treturn checkBranchedSup(nSub, supBranches, this.engine, supBranchType);\n\t\t}\n\n\t\t// Cas standard\n\t\treturn checkAtomic(nSub, nSup, this.engine);\n\t}\n\n\t// ── Connection check ───────────────────────────────────────────────────\n\n\t/**\n\t * Vérifie si la sortie d'un nœud source peut alimenter l'entrée d'un nœud cible.\n\t *\n\t * Sémantique : `sourceOutput ⊆ targetInput`\n\t * → Toute donnée produite par source sera acceptée par target.\n\t */\n\tcanConnect(\n\t\tsourceOutput: JSONSchema7Definition,\n\t\ttargetInput: JSONSchema7Definition,\n\t): ConnectionResult {\n\t\tconst result = this.check(sourceOutput, targetInput);\n\t\treturn { ...result, direction: \"sourceOutput ⊆ targetInput\" };\n\t}\n\n\t// ── Equality ───────────────────────────────────────────────────────────\n\n\t/**\n\t * Vérifie l'égalité structurelle entre deux schemas.\n\t */\n\tisEqual(a: JSONSchema7Definition, b: JSONSchema7Definition): boolean {\n\t\treturn this.engine.isEqual(normalize(a), normalize(b));\n\t}\n\n\t// ── Intersection ───────────────────────────────────────────────────────\n\n\t/**\n\t * Calcule l'intersection de deux schemas (allOf merge).\n\t * Retourne null si les schemas sont incompatibles.\n\t *\n\t * Le résultat est normalisé pour éliminer les artefacts structurels\n\t * du merge (ex: `enum` redondant quand `const` est présent).\n\t */\n\tintersect(\n\t\ta: JSONSchema7Definition,\n\t\tb: JSONSchema7Definition,\n\t): JSONSchema7Definition | null {\n\t\t// ── Identity short-circuit ──\n\t\t// If a and b are the same reference or structurally equal,\n\t\t// intersection is just normalize(a) — skip the merge entirely.\n\t\tif (a === b || deepEqual(a, b)) return normalize(a);\n\n\t\tconst nA = normalize(a);\n\t\tconst nB = normalize(b);\n\n\t\t// ── Post-normalize identity ──\n\t\tif (deepEqual(nA, nB)) return nA;\n\n\t\tconst merged = this.engine.merge(nA, nB);\n\t\tif (merged === null) return null;\n\t\t// Fast path: if merge result equals one of the normalized inputs,\n\t\t// it's already normalized — skip redundant normalize call.\n\t\tif (deepEqual(merged, nA) || deepEqual(merged, nB)) return merged;\n\t\treturn normalize(merged);\n\t}\n\n\t// ── Condition resolution ───────────────────────────────────────────────\n\n\t/**\n\t * Résout les `if/then/else` d'un schema en évaluant le `if` contre\n\t * des données partielles (discriminants).\n\t */\n\tresolveConditions(\n\t\tschema: JSONSchema7,\n\t\tdata: Record<string, unknown>,\n\t): ResolvedConditionResult {\n\t\treturn resolveConditions(schema, data, this.engine);\n\t}\n\n\t// ── Resolved check ────────────────────────────────────────────────────\n\n\t/**\n\t * Raccourci : résout les conditions des deux schemas puis vérifie sub ⊆ sup.\n\t *\n\t * Utile quand le superset contient des if/then/else et que tu connais\n\t * les valeurs discriminantes que le subset va produire.\n\t */\n\tcheckResolved(\n\t\tsub: JSONSchema7,\n\t\tsup: JSONSchema7,\n\t\tsubData: Record<string, unknown>,\n\t\tsupData?: Record<string, unknown>,\n\t): SubsetResult & {\n\t\tresolvedSub: ResolvedConditionResult;\n\t\tresolvedSup: ResolvedConditionResult;\n\t} {\n\t\tconst resolvedSub = resolveConditions(sub, subData, this.engine);\n\t\tconst resolvedSup = resolveConditions(sup, supData ?? subData, this.engine);\n\t\tconst result = this.check(resolvedSub.resolved, resolvedSup.resolved);\n\n\t\treturn { ...result, resolvedSub, resolvedSup };\n\t}\n\n\t// ── Normalization ──────────────────────────────────────────────────────\n\n\t/**\n\t * Normalise un schema : infère `type` depuis `const`/`enum`,\n\t * et normalise récursivement tous les sous-schemas.\n\t */\n\tnormalize(def: JSONSchema7Definition): JSONSchema7Definition {\n\t\treturn normalize(def);\n\t}\n\n\t// ── Formatting ─────────────────────────────────────────────────────────\n\n\t/**\n\t * Formate un SubsetResult en chaîne lisible (utile pour logs/debug).\n\t */\n\tformatResult(label: string, result: SubsetResult): string {\n\t\treturn formatResult(label, result);\n\t}\n}\n"
-  ],
-  "mappings": "0SAoEO,AAAM,LAA+B,LAC1B,CAEjB,KAAW,EAAG,CACb,KAAK,OAAS,IAAI,EAYnB,QAAQ,CAAC,EAA4B,EAAqC,CAIzE,GAAI,IAAQ,EAAK,MAAO,GAOxB,GAAI,EAAU,EAAK,CAAG,EAAG,MAAO,GAEhC,IAAM,EAAO,EAAU,CAAG,EACpB,EAAO,EAAU,CAAG,EAM1B,GAAI,IAAS,GAAO,IAAS,GAAO,EAAU,EAAM,CAAI,EAAG,MAAO,GAClE,GAAI,IAAS,GAAQ,EAAU,EAAM,CAAI,EAAG,MAAO,GAEnD,IAAQ,SAAU,GAAgB,EAAiB,CAAI,EAEvD,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAY,MAAM,CAAC,IACzB,EAAiB,EAAQ,EAAM,KAAK,MAAM,CAC3C,EAGD,OAAO,EAAiB,EAAM,EAAM,KAAK,MAAM,EAYhD,KAAK,CAAC,EAA4B,EAA0C,CAG3E,GAAI,IAAQ,EACX,MAAO,CAAE,SAAU,GAAM,OAAQ,EAAK,MAAO,CAAC,EAAG,cAAe,CAAC,CAAE,EAKpE,GAAI,EAAU,EAAK,CAAG,EACrB,MAAO,CAAE,SAAU,GAAM,OAAQ,EAAK,MAAO,CAAC,EAAG,cAAe,CAAC,CAAE,EAGpE,IAAM,EAAO,EAAU,CAAG,EACpB,EAAO,EAAU,CAAG,EAI1B,GAAI,EAAU,EAAM,CAAI,EACvB,MAAO,CAAE,SAAU,GAAM,OAAQ,EAAM,MAAO,CAAC,EAAG,cAAe,CAAC,CAAE,EAGrE,IAAQ,SAAU,EAAa,KAAM,GACpC,EAAiB,CAAI,GACd,SAAU,EAAa,KAAM,GACpC,EAAiB,CAAI,EAGtB,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAiB,EAAa,EAAM,KAAK,OAAQ,CAAa,EAItE,GAAI,EAAY,OAAS,GAAK,EAAY,KAAO,EAChD,OAAO,EAAiB,EAAM,EAAa,KAAK,OAAQ,CAAa,EAItE,OAAO,EAAY,EAAM,EAAM,KAAK,MAAM,EAW3C,UAAU,CACT,EACA,EACmB,CAEnB,MAAO,IADQ,KAAK,MAAM,EAAc,CAAW,EAC/B,UAAW,4BAA4B,EAQ5D,OAAO,CAAC,EAA0B,EAAmC,CACpE,OAAO,KAAK,OAAO,QAAQ,EAAU,CAAC,EAAG,EAAU,CAAC,CAAC,EAYtD,SAAS,CACR,EACA,EAC+B,CAI/B,GAAI,IAAM,GAAK,EAAU,EAAG,CAAC,EAAG,OAAO,EAAU,CAAC,EAElD,IAAM,EAAK,EAAU,CAAC,EAChB,EAAK,EAAU,CAAC,EAGtB,GAAI,EAAU,EAAI,CAAE,EAAG,OAAO,EAE9B,IAAM,EAAS,KAAK,OAAO,MAAM,EAAI,CAAE,EACvC,GAAI,IAAW,KAAM,OAAO,KAG5B,GAAI,EAAU,EAAQ,CAAE,GAAK,EAAU,EAAQ,CAAE,EAAG,OAAO,EAC3D,OAAO,EAAU,CAAM,EASxB,iBAAiB,CAChB,EACA,EAC0B,CAC1B,OAAO,EAAkB,EAAQ,EAAM,KAAK,MAAM,EAWnD,aAAa,CACZ,EACA,EACA,EACA,EAIC,CACD,IAAM,EAAc,EAAkB,EAAK,EAAS,KAAK,MAAM,EACzD,EAAc,EAAkB,EAAK,GAAW,EAAS,KAAK,MAAM,EAG1E,MAAO,IAFQ,KAAK,MAAM,EAAY,SAAU,EAAY,QAAQ,EAEhD,cAAa,aAAY,EAS9C,SAAS,CAAC,EAAmD,CAC5D,OAAO,EAAU,CAAG,EAQrB,YAAY,CAAC,EAAe,EAA8B,CACzD,OAAO,EAAa,EAAO,CAAM,EAEnC",
-  "debugId": "F7539F5812EBB21364756E2164756E21",
-  "names": []
-}

package/dist/chunk-k92ftyzf.js

@@ -1,5 +0,0 @@
-import{B as W,x as M,z as Q}from"./chunk-w1ypc97a.js";var $=new Set(["items","additionalProperties","additionalItems","contains","propertyNames","not","if","then","else"]),C=new Set(["properties","patternProperties","dependencies"]);function T(z,A,F){return $.has(z)&&M(A)&&M(F)}function U(z,A,F){return C.has(z)&&M(A)&&M(F)}function X(z,A,F){if(typeof z==="boolean"||typeof A==="boolean"){if(z!==A)return[{path:F||"$",type:"changed",sourceValue:z,mergedValue:A}];return[]}let N=W(Object.keys(z),Object.keys(A)),H=[];for(let x of N){let G=F?`${F}.${x}`:x,w=z[x],v=A[x];if(w===void 0&&v!==void 0){H.push({path:G,type:"added",sourceValue:void 0,mergedValue:v});continue}if(w!==void 0&&v===void 0){H.push({path:G,type:"removed",sourceValue:w,mergedValue:void 0});continue}if(w!==void 0&&v!==void 0&&!Q(w,v)){if(T(x,w,v)){let B=X(w,v,G);for(let J of B)H.push(J);continue}if(U(x,w,v)){let B=q(w,v,G,x);for(let J of B)H.push(J);continue}H.push({path:G,type:"changed",sourceValue:w,mergedValue:v})}}return H}function q(z,A,F,N){let H=W(Object.keys(z),Object.keys(A)),x=[];for(let G of H){let w=`${F}.${G}`,v=z[G],B=A[G];if(v===void 0&&B!==void 0){x.push({path:w,type:"added",sourceValue:void 0,mergedValue:B});continue}if(v!==void 0&&B===void 0){x.push({path:w,type:"removed",sourceValue:v,mergedValue:void 0});continue}if(v!==void 0&&B!==void 0){if(N==="dependencies"&&(Array.isArray(v)||Array.isArray(B))){if(!Q(v,B))x.push({path:w,type:"changed",sourceValue:v,mergedValue:B});continue}let J=X(v,B,w);for(let Z of J)x.push(Z)}}return x}
-export{X as m};
-
-//# debugId=DE69788D2095718464756E2164756E21
-//# sourceMappingURL=chunk-k92ftyzf.js.map

package/dist/chunk-k92ftyzf.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/differ.ts"],
-  "sourcesContent": [
-    "import type { JSONSchema7, JSONSchema7Definition } from \"json-schema\";\nimport type { SchemaDiff } from \"./types\";\nimport { deepEqual, isPlainObj, unionStrings } from \"./utils\";\n\n// ─── Schema Differ ───────────────────────────────────────────────────────────\n//\n// Calcul des différences structurelles entre un schema original et son\n// intersection (merged). Utilisé pour produire des diagnostics lisibles\n// quand sub ⊄ sup.\n//\n// Utilise des méthodes natives JS pour des performances optimales.\n\n// ─── Recursive diff keys ─────────────────────────────────────────────────────\n\n/** Mots-clés dont la valeur est un sous-schema unique (récursion possible) */\nconst RECURSIVE_KEYS: ReadonlySet<string> = new Set([\n\t\"items\",\n\t\"additionalProperties\",\n\t\"additionalItems\",\n\t\"contains\",\n\t\"propertyNames\",\n\t\"not\",\n\t\"if\",\n\t\"then\",\n\t\"else\",\n]);\n\n/**\n * Mots-clés dont la valeur est un `Record<string, JSONSchema7Definition>`.\n * Chaque propriété est un sous-schema → récursion au niveau des clés.\n *\n * `dependencies` est inclus ici avec une gestion spéciale (forme tableau\n * vs forme schema) dans `computePropertyDiffs`.\n *\n * Point 3 — dependencies ajouté ici (avec gestion spéciale forme tableau).\n */\nconst PROPERTIES_LIKE_KEYS: ReadonlySet<string> = new Set([\n\t\"properties\",\n\t\"patternProperties\",\n\t\"dependencies\",\n]);\n\n// ─── Internal helpers ────────────────────────────────────────────────────────\n\n/**\n * Vérifie si on peut récurser dans un mot-clé single-schema :\n * la clé doit être dans RECURSIVE_KEYS et les deux valeurs doivent être\n * des objets (pas des tableaux, pas null).\n */\nfunction canRecurseInto(\n\tkey: string,\n\torigVal: unknown,\n\tmergedVal: unknown,\n): boolean {\n\treturn (\n\t\tRECURSIVE_KEYS.has(key) && isPlainObj(origVal) && isPlainObj(mergedVal)\n\t);\n}\n\n/**\n * Vérifie si un mot-clé est un objet de propriétés récursable.\n *\n * Utilise `_.includes` sur le Set pour une vérification concise.\n */\nfunction isPropertiesLikeObject(\n\tkey: string,\n\torigVal: unknown,\n\tmergedVal: unknown,\n): boolean {\n\treturn (\n\t\tPROPERTIES_LIKE_KEYS.has(key) &&\n\t\tisPlainObj(origVal) &&\n\t\tisPlainObj(mergedVal)\n\t);\n}\n\n// ─── Public API ──────────────────────────────────────────────────────────────\n\n/**\n * Compare un schema original avec sa version mergée et retourne la liste\n * des différences structurelles.\n *\n * @param original  Le schema sub tel qu'il était avant le merge\n * @param merged    Le schema résultant de l'intersection allOf(sub, sup)\n * @param path      Chemin JSON-path courant (vide à la racine)\n *\n * Point 9 — Utilise `deepEqual` au lieu de `JSON.stringify` pour comparer\n * les valeurs, ce qui élimine la dépendance à l'ordre des clés.\n */\nexport function computeDiffs(\n\toriginal: JSONSchema7Definition,\n\tmerged: JSONSchema7Definition,\n\tpath: string,\n): SchemaDiff[] {\n\t// Cas boolean schemas\n\tif (typeof original === \"boolean\" || typeof merged === \"boolean\") {\n\t\tif (original !== merged) {\n\t\t\treturn [\n\t\t\t\t{\n\t\t\t\t\tpath: path || \"$\",\n\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\tsourceValue: original,\n\t\t\t\t\tmergedValue: merged,\n\t\t\t\t},\n\t\t\t];\n\t\t}\n\t\treturn [];\n\t}\n\n\t// Collecter toutes les clés des deux schemas\n\tconst allKeys = unionStrings(\n\t\tObject.keys(original),\n\t\tObject.keys(merged),\n\t) as (keyof JSONSchema7)[];\n\n\tconst result: SchemaDiff[] = [];\n\tfor (const key of allKeys) {\n\t\tconst currentPath = path ? `${path}.${key}` : key;\n\t\tconst origVal = original[key];\n\t\tconst mergedVal = merged[key];\n\n\t\t// Clé ajoutée par le merge\n\t\tif (origVal === undefined && mergedVal !== undefined) {\n\t\t\tresult.push({\n\t\t\t\tpath: currentPath,\n\t\t\t\ttype: \"added\",\n\t\t\t\tsourceValue: undefined,\n\t\t\t\tmergedValue: mergedVal,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Clé supprimée par le merge\n\t\tif (origVal !== undefined && mergedVal === undefined) {\n\t\t\tresult.push({\n\t\t\t\tpath: currentPath,\n\t\t\t\ttype: \"removed\",\n\t\t\t\tsourceValue: origVal,\n\t\t\t\tmergedValue: undefined,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\t// Les deux sont définies — vérifier si elles diffèrent\n\t\t// Point 9 : deepEqual pour une comparaison profonde indépendante de l'ordre des clés\n\t\tif (\n\t\t\torigVal !== undefined &&\n\t\t\tmergedVal !== undefined &&\n\t\t\t!deepEqual(origVal, mergedVal)\n\t\t) {\n\t\t\t// Récurser dans les sous-schemas uniques\n\t\t\tif (canRecurseInto(key, origVal, mergedVal)) {\n\t\t\t\tconst sub = computeDiffs(\n\t\t\t\t\torigVal as JSONSchema7Definition,\n\t\t\t\t\tmergedVal as JSONSchema7Definition,\n\t\t\t\t\tcurrentPath,\n\t\t\t\t);\n\t\t\t\tfor (const d of sub) result.push(d);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Récurser dans les objets de propriétés (properties, patternProperties, dependencies)\n\t\t\tif (isPropertiesLikeObject(key, origVal, mergedVal)) {\n\t\t\t\tconst sub = computePropertyDiffs(\n\t\t\t\t\torigVal as Record<string, JSONSchema7Definition>,\n\t\t\t\t\tmergedVal as Record<string, JSONSchema7Definition>,\n\t\t\t\t\tcurrentPath,\n\t\t\t\t\tkey,\n\t\t\t\t);\n\t\t\t\tfor (const d of sub) result.push(d);\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Valeur scalaire ou structure non-récursable\n\t\t\tresult.push({\n\t\t\t\tpath: currentPath,\n\t\t\t\ttype: \"changed\",\n\t\t\t\tsourceValue: origVal,\n\t\t\t\tmergedValue: mergedVal,\n\t\t\t});\n\t\t}\n\t}\n\n\treturn result;\n}\n\n// ─── Property-level diffs ────────────────────────────────────────────────────\n\n/**\n * Calcule les diffs au niveau des propriétés d'un objet `properties`,\n * `patternProperties`, ou `dependencies`.\n *\n * Pour `dependencies` (Point 3), gère les deux formes :\n *   - Forme 1 (tableau de strings) : comparaison directe via `deepEqual`\n *   - Forme 2 (sous-schema) : récursion via `computeDiffs`\n *\n * Fusionne les clés des deux côtés et produit un tableau aplati de diffs.\n */\nfunction computePropertyDiffs(\n\toriginal: Record<string, JSONSchema7Definition | string[]>,\n\tmerged: Record<string, JSONSchema7Definition | string[]>,\n\tbasePath: string,\n\tparentKey: string,\n): SchemaDiff[] {\n\tconst allPropKeys = unionStrings(Object.keys(original), Object.keys(merged));\n\n\tconst result: SchemaDiff[] = [];\n\tfor (const key of allPropKeys) {\n\t\tconst currentPath = `${basePath}.${key}`;\n\t\tconst origVal = original[key];\n\t\tconst mergedVal = merged[key];\n\n\t\tif (origVal === undefined && mergedVal !== undefined) {\n\t\t\tresult.push({\n\t\t\t\tpath: currentPath,\n\t\t\t\ttype: \"added\",\n\t\t\t\tsourceValue: undefined,\n\t\t\t\tmergedValue: mergedVal,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (origVal !== undefined && mergedVal === undefined) {\n\t\t\tresult.push({\n\t\t\t\tpath: currentPath,\n\t\t\t\ttype: \"removed\",\n\t\t\t\tsourceValue: origVal,\n\t\t\t\tmergedValue: undefined,\n\t\t\t});\n\t\t\tcontinue;\n\t\t}\n\n\t\tif (origVal !== undefined && mergedVal !== undefined) {\n\t\t\t// Pour `dependencies`, les valeurs peuvent être des tableaux de strings (forme 1)\n\t\t\t// On ne récurse que si les deux valeurs sont des objets (sous-schemas)\n\t\t\tif (\n\t\t\t\tparentKey === \"dependencies\" &&\n\t\t\t\t(Array.isArray(origVal) || Array.isArray(mergedVal))\n\t\t\t) {\n\t\t\t\t// Comparaison directe pour les tableaux de strings\n\t\t\t\tif (!deepEqual(origVal, mergedVal)) {\n\t\t\t\t\tresult.push({\n\t\t\t\t\t\tpath: currentPath,\n\t\t\t\t\t\ttype: \"changed\",\n\t\t\t\t\t\tsourceValue: origVal,\n\t\t\t\t\t\tmergedValue: mergedVal,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// Récursion standard pour les sous-schemas\n\t\t\tconst sub = computeDiffs(\n\t\t\t\torigVal as JSONSchema7Definition,\n\t\t\t\tmergedVal as JSONSchema7Definition,\n\t\t\t\tcurrentPath,\n\t\t\t);\n\t\t\tfor (const d of sub) result.push(d);\n\t\t}\n\t}\n\n\treturn result;\n}\n"
-  ],
-  "mappings": "sDAeA,IAAM,EAAsC,IAAI,IAAI,CACnD,QACA,uBACA,kBACA,WACA,gBACA,MACA,KACA,OACA,MACD,CAAC,EAWK,EAA4C,IAAI,IAAI,CACzD,aACA,oBACA,cACD,CAAC,EASD,SAAS,CAAc,CACtB,EACA,EACA,EACU,CACV,OACC,EAAe,IAAI,CAAG,GAAK,EAAW,CAAO,GAAK,EAAW,CAAS,EASxE,SAAS,CAAsB,CAC9B,EACA,EACA,EACU,CACV,OACC,EAAqB,IAAI,CAAG,GAC5B,EAAW,CAAO,GAClB,EAAW,CAAS,EAiBf,SAAS,CAAY,CAC3B,EACA,EACA,EACe,CAEf,GAAI,OAAO,IAAa,WAAa,OAAO,IAAW,UAAW,CACjE,GAAI,IAAa,EAChB,MAAO,CACN,CACC,KAAM,GAAQ,IACd,KAAM,UACN,YAAa,EACb,YAAa,CACd,CACD,EAED,MAAO,CAAC,EAIT,IAAM,EAAU,EACf,OAAO,KAAK,CAAQ,EACpB,OAAO,KAAK,CAAM,CACnB,EAEM,EAAuB,CAAC,EAC9B,QAAW,KAAO,EAAS,CAC1B,IAAM,EAAc,EAAO,GAAG,KAAQ,IAAQ,EACxC,EAAU,EAAS,GACnB,EAAY,EAAO,GAGzB,GAAI,IAAY,QAAa,IAAc,OAAW,CACrD,EAAO,KAAK,CACX,KAAM,EACN,KAAM,QACN,YAAa,OACb,YAAa,CACd,CAAC,EACD,SAID,GAAI,IAAY,QAAa,IAAc,OAAW,CACrD,EAAO,KAAK,CACX,KAAM,EACN,KAAM,UACN,YAAa,EACb,YAAa,MACd,CAAC,EACD,SAKD,GACC,IAAY,QACZ,IAAc,QACd,CAAC,EAAU,EAAS,CAAS,EAC5B,CAED,GAAI,EAAe,EAAK,EAAS,CAAS,EAAG,CAC5C,IAAM,EAAM,EACX,EACA,EACA,CACD,EACA,QAAW,KAAK,EAAK,EAAO,KAAK,CAAC,EAClC,SAID,GAAI,EAAuB,EAAK,EAAS,CAAS,EAAG,CACpD,IAAM,EAAM,EACX,EACA,EACA,EACA,CACD,EACA,QAAW,KAAK,EAAK,EAAO,KAAK,CAAC,EAClC,SAID,EAAO,KAAK,CACX,KAAM,EACN,KAAM,UACN,YAAa,EACb,YAAa,CACd,CAAC,GAIH,OAAO,EAeR,SAAS,CAAoB,CAC5B,EACA,EACA,EACA,EACe,CACf,IAAM,EAAc,EAAa,OAAO,KAAK,CAAQ,EAAG,OAAO,KAAK,CAAM,CAAC,EAErE,EAAuB,CAAC,EAC9B,QAAW,KAAO,EAAa,CAC9B,IAAM,EAAc,GAAG,KAAY,IAC7B,EAAU,EAAS,GACnB,EAAY,EAAO,GAEzB,GAAI,IAAY,QAAa,IAAc,OAAW,CACrD,EAAO,KAAK,CACX,KAAM,EACN,KAAM,QACN,YAAa,OACb,YAAa,CACd,CAAC,EACD,SAGD,GAAI,IAAY,QAAa,IAAc,OAAW,CACrD,EAAO,KAAK,CACX,KAAM,EACN,KAAM,UACN,YAAa,EACb,YAAa,MACd,CAAC,EACD,SAGD,GAAI,IAAY,QAAa,IAAc,OAAW,CAGrD,GACC,IAAc,iBACb,MAAM,QAAQ,CAAO,GAAK,MAAM,QAAQ,CAAS,GACjD,CAED,GAAI,CAAC,EAAU,EAAS,CAAS,EAChC,EAAO,KAAK,CACX,KAAM,EACN,KAAM,UACN,YAAa,EACb,YAAa,CACd,CAAC,EAEF,SAID,IAAM,EAAM,EACX,EACA,EACA,CACD,EACA,QAAW,KAAK,EAAK,EAAO,KAAK,CAAC,GAIpC,OAAO",
-  "debugId": "DE69788D2095718464756E2164756E21",
-  "names": []
-}

package/dist/semantic-diff/analyzer.d.ts

@@ -1,25 +0,0 @@
-import type { JSONSchema7Definition } from "json-schema";
-import type { SchemaDiff } from "../types";
-import type { SemanticDiff } from "./types";
-/**
- * Transforme les diffs structurelles en diffs sémantiques.
- *
- * @param sub   Le schema source (sourceOutput)
- * @param sup   Le schema target (targetInput)
- * @param structuralDiffs  Les diffs brutes produites par `computeDiffs`
- * @returns     Tableau de SemanticDiff lisibles et actionnables
- *
- * @example
- * ```ts
- * const semanticDiffs = computeSemanticDiffs(sourceSchema, targetSchema, rawDiffs);
- * // [
- * //   {
- * //     type: 'missing-required-property',
- * //     path: 'properties.meetingId',
- * //     message: "Target requires property 'meetingId' (string) which source does not provide",
- * //     details: { property: 'meetingId', targetSchema: { type: 'string' } }
- * //   }
- * // ]
- * ```
- */
-export declare function computeSemanticDiffs(sub: JSONSchema7Definition, sup: JSONSchema7Definition, structuralDiffs: SchemaDiff[]): SemanticDiff[];

package/dist/semantic-diff/detectors.d.ts

@@ -1,79 +0,0 @@
-import type { JSONSchema7 } from "json-schema";
-import type { SchemaDiff } from "../types";
-import type { SemanticDiff } from "./types";
-/** Formate un type JSON Schema pour l'affichage (string, array → "string | number") */
-export declare function formatType(type: unknown): string;
-/**
- * Détecte les propriétés requises par le target que le source ne fournit pas.
- *
- * Condition : la propriété est dans `sup.required` mais n'existe pas
- * dans `sub.properties`.
- *
- * Regroupe les diffs structurels `properties.X added` + `required changed`
- * en un seul diagnostic.
- */
-export declare function detectMissingRequiredProperties(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les propriétés optionnelles dans le source mais requises par le target.
- *
- * Condition : la propriété existe dans `sub.properties` (mais pas dans
- * `sub.required`), et elle est dans `sup.required`.
- *
- * Ne se déclenche que si la propriété n'a pas déjà été détectée comme
- * `missing-required-property`.
- */
-export declare function detectPropertiesNotGuaranteed(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les propriétés fournies par le source que le target interdit.
- *
- * Condition : la propriété existe dans `sub.properties` mais pas dans
- * `sup.properties`, et `sup.additionalProperties === false`.
- */
-export declare function detectPropertiesNotAllowed(_sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités de type sur les propriétés ou à la racine.
- *
- * Distingue deux cas :
- *   - `type-mismatch`  : types complètement différents (string vs number)
- *   - `type-too-wide`  : source est un superset du target (string|number vs string)
- */
-export declare function detectTypeDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités d'enum : source autorise des valeurs
- * que target n'accepte pas.
- */
-export declare function detectEnumDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités de const : valeurs const différentes.
- */
-export declare function detectConstDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les contraintes du target plus strictes que celles du source.
- *
- * Couvre : minimum, maximum, exclusiveMinimum, exclusiveMaximum, multipleOf,
- * minLength, maxLength, minItems, maxItems, minProperties, maxProperties.
- */
-export declare function detectConstraintDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les conflits d'additionalProperties :
- * source autorise des propriétés supplémentaires, target les interdit.
- */
-export declare function detectAdditionalPropertiesConflict(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités de schema d'items (arrays).
- */
-export declare function detectItemsDiffs(_sub: JSONSchema7, _sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités de format (email, uri, date-time, etc.).
- */
-export declare function detectFormatDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Détecte les incompatibilités de pattern regex.
- */
-export declare function detectPatternDiffs(sub: JSONSchema7, sup: JSONSchema7, diffs: SchemaDiff[], consumed: Set<number>): SemanticDiff[];
-/**
- * Convertit les diffs structurels non consommés en `schema-incompatible`.
- *
- * C'est le catch-all pour les cas non couverts par les détecteurs spécifiques.
- */
-export declare function createFallbackDiff(diff: SchemaDiff): SemanticDiff;

package/dist/semantic-diff/index.d.ts

@@ -1,3 +0,0 @@
-export { computeSemanticDiffs } from "./analyzer";
-export { formatType } from "./detectors";
-export type { SemanticDiff, SemanticDiffType } from "./types";

package/dist/semantic-diff/types.d.ts

@@ -1,81 +0,0 @@
-/**
- * Types de diffs sémantiques possibles.
- *
- * Chaque type correspond à une catégorie d'incompatibilité
- * entre un schema source et un schema target.
- */
-export type SemanticDiffType = 
-/** Target exige une propriété que source ne fournit pas du tout */
-"missing-required-property"
-/** La propriété existe dans source mais est optionnelle, target l'exige */
- | "property-not-guaranteed"
-/** Même propriété, types complètement incompatibles (string vs number) */
- | "type-mismatch"
-/** Source produit un type plus large que ce que target accepte (string|number vs string) */
- | "type-too-wide"
-/** Source autorise des valeurs enum que target n'accepte pas */
- | "enum-not-subset"
-/** Valeurs const incompatibles */
- | "const-mismatch"
-/** Source a des contraintes plus larges (min/max/length/items/etc.) */
- | "constraint-too-loose"
-/** Source autorise des propriétés supplémentaires, target les interdit */
- | "additional-properties-conflict"
-/** Source fournit une propriété que target interdit (additionalProperties: false) */
- | "property-not-allowed"
-/** Contrainte de format incompatible */
- | "format-mismatch"
-/** Pattern regex du source pas inclus dans celui du target */
- | "pattern-not-subset"
-/** Schema des items d'un array incompatible */
- | "incompatible-items"
-/** Incompatibilité générique (catch-all pour les cas non couverts) */
- | "schema-incompatible";
-/**
- * Un diagnostic sémantique décrivant une incompatibilité entre deux schemas.
- *
- * Contrairement aux `SchemaDiff` structurels (qui comparent original vs merged),
- * les `SemanticDiff` décrivent le problème en termes compréhensibles :
- *   - Quel est le problème (`type`)
- *   - Où il se situe (`path`)
- *   - Pourquoi c'est incompatible (`message`)
- *   - Données structurées pour l'exploiter programmatiquement (`details`)
- *
- * @example
- * ```
- * {
- *   type: 'missing-required-property',
- *   path: 'properties.meetingId',
- *   message: "Target requires property 'meetingId' (string) which source does not provide",
- *   details: { property: 'meetingId', targetSchema: { type: 'string' } }
- * }
- * ```
- */
-export interface SemanticDiff {
-    /** Catégorie sémantique de l'incompatibilité */
-    type: SemanticDiffType;
-    /** Chemin JSON-path vers l'élément problématique (ex: "properties.meetingId") */
-    path: string;
-    /** Message humain lisible décrivant le problème */
-    message: string;
-    /**
-     * Données structurées associées au diagnostic.
-     *
-     * Le contenu varie selon le `type` :
-     *
-     * - `missing-required-property` → `{ property, targetSchema }`
-     * - `property-not-guaranteed`   → `{ property }`
-     * - `type-mismatch`             → `{ property?, sourceType, targetType }`
-     * - `type-too-wide`             → `{ property?, sourceType, targetType }`
-     * - `enum-not-subset`           → `{ property?, sourceValues, targetValues, extraValues }`
-     * - `const-mismatch`            → `{ property?, sourceConst, targetConst }`
-     * - `constraint-too-loose`      → `{ property?, constraint, sourceValue, targetValue }`
-     * - `additional-properties-conflict` → `{ sourceAllows, targetAllows }`
-     * - `property-not-allowed`      → `{ property }`
-     * - `format-mismatch`           → `{ property?, sourceFormat, targetFormat }`
-     * - `pattern-not-subset`        → `{ property?, sourcePattern, targetPattern }`
-     * - `incompatible-items`        → `{ reason }`
-     * - `schema-incompatible`       → `{ reason }`
-     */
-    details: Record<string, unknown>;
-}