domainforge 0.13.0

package/domainforge-core/src/semantic_pack/diagnostics.rs

@@ -0,0 +1,214 @@
+use serde::{Deserialize, Serialize};
+
+use super::schema::{PackRef, PackSetRef, SourceRef, Suggestion};
+
+// ---------------------------------------------------------------------------
+// 4.5 SemanticTruth and DiagnosticSeverity
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SemanticTruth {
+    Valid,
+    Invalid,
+    Unknown,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DiagnosticSeverity {
+    Error,
+    Warning,
+    Info,
+    Hint,
+}
+
+// ---------------------------------------------------------------------------
+// 4.6 SemanticDiagnosticCode
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SemanticDiagnosticCode {
+    UnknownConcept,
+    DeprecatedConcept,
+    AmbiguousConcept,
+    AmbiguousAlias,
+    AliasConflict,
+    RejectedConcept,
+    ProposedConcept,
+    InvalidRelation,
+    InvalidPredicate,
+    UnknownMetric,
+    UnknownDimension,
+    UnknownUnit,
+    UnitMismatch,
+    DimensionMismatch,
+    MissingDefinition,
+    MissingOwner,
+    DuplicateCanonicalName,
+    DuplicateConceptId,
+    UnreviewedConcept,
+    PackUnavailable,
+    PackSchemaMismatch,
+    PackVersionMismatch,
+    PackHashMismatch,
+    PackUnsigned,
+    PackSignatureInvalid,
+    PackSetConflict,
+    MappingRequired,
+    MeaningVersionNotBumped,
+    MeaningVersionBaselineMissing,
+    AmbiguousAliasGroup,
+}
+
+impl SemanticDiagnosticCode {
+    pub fn as_str(&self) -> &str {
+        match self {
+            Self::UnknownConcept => "unknown_concept",
+            Self::DeprecatedConcept => "deprecated_concept",
+            Self::AmbiguousConcept => "ambiguous_concept",
+            Self::AmbiguousAlias => "ambiguous_alias",
+            Self::AliasConflict => "alias_conflict",
+            Self::RejectedConcept => "rejected_concept",
+            Self::ProposedConcept => "proposed_concept",
+            Self::InvalidRelation => "invalid_relation",
+            Self::InvalidPredicate => "invalid_predicate",
+            Self::UnknownMetric => "unknown_metric",
+            Self::UnknownDimension => "unknown_dimension",
+            Self::UnknownUnit => "unknown_unit",
+            Self::UnitMismatch => "unit_mismatch",
+            Self::DimensionMismatch => "dimension_mismatch",
+            Self::MissingDefinition => "missing_definition",
+            Self::MissingOwner => "missing_owner",
+            Self::DuplicateCanonicalName => "duplicate_canonical_name",
+            Self::DuplicateConceptId => "duplicate_concept_id",
+            Self::UnreviewedConcept => "unreviewed_concept",
+            Self::PackUnavailable => "pack_unavailable",
+            Self::PackSchemaMismatch => "pack_schema_mismatch",
+            Self::PackVersionMismatch => "pack_version_mismatch",
+            Self::PackHashMismatch => "pack_hash_mismatch",
+            Self::PackUnsigned => "pack_unsigned",
+            Self::PackSignatureInvalid => "pack_signature_invalid",
+            Self::PackSetConflict => "pack_set_conflict",
+            Self::MappingRequired => "mapping_required",
+            Self::MeaningVersionNotBumped => "meaning_version_not_bumped",
+            Self::MeaningVersionBaselineMissing => "meaning_version_baseline_missing",
+            Self::AmbiguousAliasGroup => "ambiguous_alias_group",
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// 4.6 SemanticDiagnostic
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SemanticDiagnostic {
+    pub code: SemanticDiagnosticCode,
+    pub severity: DiagnosticSeverity,
+    pub semantic_truth: SemanticTruth,
+    pub message: String,
+    pub source_ref: SourceRef,
+    pub pack_ref: PackRef,
+    #[serde(default)]
+    pub suggestions: Vec<Suggestion>,
+    pub recoverability_hint: String,
+}
+
+// ---------------------------------------------------------------------------
+// 4.7 SemanticValidationResult
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct SemanticValidationResult {
+    pub status: SemanticValidationStatus,
+    pub diagnostics: Vec<SemanticDiagnostic>,
+    pub pack_set_ref: PackSetRef,
+    pub input_hash: String,
+    pub validation_mode: ValidationMode,
+    pub expected_hashes: Vec<ExpectedHashCheck>,
+    pub unsigned_fixture_bypass_used: bool,
+    pub first_approved_version_bypass_used: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub evidence_ref: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum SemanticValidationStatus {
+    Passed,
+    Failed,
+    Unknown,
+    Blocked,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct ExpectedHashCheck {
+    pub path: String,
+    pub expected_hash: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub actual_hash: Option<String>,
+    pub matched: bool,
+}
+
+// ---------------------------------------------------------------------------
+// ValidationMode / policies (11.2)
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ValidationMode {
+    Off,
+    Warn,
+    Strict,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum UnknownConceptPolicy {
+    Ignore,
+    Warning,
+    Error,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DeprecatedPolicy {
+    Allow,
+    Warn,
+    ErrorInStrict,
+    ErrorAlways,
+}
+
+// ---------------------------------------------------------------------------
+// ValidationOptions (11.2)
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(default)]
+pub struct ValidationOptions {
+    pub mode: ValidationMode,
+    pub unknown_concept_policy: UnknownConceptPolicy,
+    pub deprecated_policy: DeprecatedPolicy,
+    pub require_signed_pack: bool,
+    pub allow_unsigned_test_fixtures: bool,
+}
+
+impl Default for ValidationOptions {
+    fn default() -> Self {
+        Self {
+            mode: ValidationMode::Warn,
+            unknown_concept_policy: UnknownConceptPolicy::Warning,
+            deprecated_policy: DeprecatedPolicy::Warn,
+            require_signed_pack: false,
+            allow_unsigned_test_fixtures: false,
+        }
+    }
+}
+
+impl ValidationOptions {
+    pub fn strict() -> Self {
+        Self {
+            mode: ValidationMode::Strict,
+            unknown_concept_policy: UnknownConceptPolicy::Error,
+            deprecated_policy: DeprecatedPolicy::ErrorInStrict,
+            require_signed_pack: true,
+            allow_unsigned_test_fixtures: false,
+        }
+    }
+}

package/domainforge-core/src/semantic_pack/diff.rs

@@ -0,0 +1,216 @@
+use serde::{Deserialize, Serialize};
+
+use super::schema::{ConceptDef, SemanticPack};
+
+/// Diff classification (12.4)
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum DiffClassification {
+    Additive,
+    DefinitionalChange,
+    Deprecating,
+    Breaking,
+    GovernanceCritical,
+    SignatureOnly,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DiffEntry {
+    pub classification: DiffClassification,
+    pub subject_type: String,
+    pub subject_id: String,
+    pub detail: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PackDiff {
+    pub old_pack_id: String,
+    pub new_pack_id: String,
+    pub entries: Vec<DiffEntry>,
+    pub summary: DiffSummary,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DiffSummary {
+    pub additive_count: usize,
+    pub definitional_change_count: usize,
+    pub deprecating_count: usize,
+    pub breaking_count: usize,
+    pub governance_critical_count: usize,
+    pub signature_only_count: usize,
+}
+
+/// Compute the diff between two semantic packs.
+pub fn diff_packs(old: &SemanticPack, new: &SemanticPack) -> PackDiff {
+    let mut entries = Vec::new();
+
+    let old_concepts: std::collections::HashMap<&str, &ConceptDef> =
+        old.concepts.iter().map(|c| (c.id.as_str(), c)).collect();
+    let new_concepts: std::collections::HashMap<&str, &ConceptDef> =
+        new.concepts.iter().map(|c| (c.id.as_str(), c)).collect();
+
+    // Added concepts
+    for (id, concept) in &new_concepts {
+        if !old_concepts.contains_key(id) {
+            entries.push(DiffEntry {
+                classification: DiffClassification::Additive,
+                subject_type: "concept".to_string(),
+                subject_id: id.to_string(),
+                detail: format!(
+                    "Added concept '{}' ({})",
+                    concept.canonical_name,
+                    concept.status.as_str()
+                ),
+            });
+        }
+    }
+
+    // Removed concepts (breaking if active)
+    for (id, concept) in &old_concepts {
+        if !new_concepts.contains_key(id) {
+            let is_breaking = matches!(concept.status, super::schema::ConceptStatus::Active);
+            entries.push(DiffEntry {
+                classification: if is_breaking {
+                    DiffClassification::Breaking
+                } else {
+                    DiffClassification::Deprecating
+                },
+                subject_type: "concept".to_string(),
+                subject_id: id.to_string(),
+                detail: format!(
+                    "Removed concept '{}' (was {})",
+                    concept.canonical_name,
+                    concept.status.as_str()
+                ),
+            });
+        }
+    }
+
+    // Changed concepts
+    for (id, new_concept) in &new_concepts {
+        if let Some(old_concept) = old_concepts.get(id) {
+            // Definition hash change
+            if old_concept.definition.definition_hash != new_concept.definition.definition_hash {
+                let is_breaking = old.meaning_fingerprint != new.meaning_fingerprint
+                    && !version_increased(&old.meaning_version, &new.meaning_version);
+                entries.push(DiffEntry {
+                    classification: if is_breaking {
+                        DiffClassification::Breaking
+                    } else {
+                        DiffClassification::DefinitionalChange
+                    },
+                    subject_type: "concept".to_string(),
+                    subject_id: id.to_string(),
+                    detail: format!(
+                        "Definition changed for '{}' (hash {} -> {})",
+                        id,
+                        old_concept.definition.definition_hash,
+                        new_concept.definition.definition_hash
+                    ),
+                });
+            }
+
+            // Status transition
+            if old_concept.status != new_concept.status {
+                let classification = match new_concept.status {
+                    super::schema::ConceptStatus::Deprecated => DiffClassification::Deprecating,
+                    super::schema::ConceptStatus::Rejected => DiffClassification::Breaking,
+                    _ => DiffClassification::GovernanceCritical,
+                };
+                entries.push(DiffEntry {
+                    classification,
+                    subject_type: "concept".to_string(),
+                    subject_id: id.to_string(),
+                    detail: format!(
+                        "Status changed: {} -> {}",
+                        old_concept.status.as_str(),
+                        new_concept.status.as_str()
+                    ),
+                });
+            }
+        }
+    }
+
+    // Meaning fingerprint change without version bump
+    if old.meaning_fingerprint != new.meaning_fingerprint
+        && !version_increased(&old.meaning_version, &new.meaning_version)
+    {
+        entries.push(DiffEntry {
+            classification: DiffClassification::Breaking,
+            subject_type: "pack".to_string(),
+            subject_id: "meaning_fingerprint".to_string(),
+            detail: format!(
+                "meaning_fingerprint changed without meaning_version increase ({} vs {})",
+                old.meaning_version, new.meaning_version
+            ),
+        });
+    }
+
+    // Sort entries by classification priority then subject_id
+    entries.sort_by(|a, b| {
+        classification_order(a.classification)
+            .cmp(&classification_order(b.classification))
+            .then(a.subject_id.cmp(&b.subject_id))
+    });
+
+    let summary = DiffSummary {
+        additive_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::Additive)
+            .count(),
+        definitional_change_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::DefinitionalChange)
+            .count(),
+        deprecating_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::Deprecating)
+            .count(),
+        breaking_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::Breaking)
+            .count(),
+        governance_critical_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::GovernanceCritical)
+            .count(),
+        signature_only_count: entries
+            .iter()
+            .filter(|e| e.classification == DiffClassification::SignatureOnly)
+            .count(),
+    };
+
+    PackDiff {
+        old_pack_id: old.pack_id.clone(),
+        new_pack_id: new.pack_id.clone(),
+        entries,
+        summary,
+    }
+}
+
+fn classification_order(c: DiffClassification) -> u8 {
+    match c {
+        DiffClassification::Breaking => 0,
+        DiffClassification::GovernanceCritical => 1,
+        DiffClassification::DefinitionalChange => 2,
+        DiffClassification::Deprecating => 3,
+        DiffClassification::Additive => 4,
+        DiffClassification::SignatureOnly => 5,
+    }
+}
+
+fn version_increased(old: &str, new: &str) -> bool {
+    super::builder::version_increased(old, new).unwrap_or(false)
+}
+
+impl super::schema::ConceptStatus {
+    fn as_str(&self) -> &'static str {
+        match self {
+            super::schema::ConceptStatus::Active => "active",
+            super::schema::ConceptStatus::Proposed => "proposed",
+            super::schema::ConceptStatus::Deprecated => "deprecated",
+            super::schema::ConceptStatus::Rejected => "rejected",
+            super::schema::ConceptStatus::ExternalOnly => "external_only",
+        }
+    }
+}

package/domainforge-core/src/semantic_pack/mod.rs

@@ -0,0 +1,31 @@
+pub mod builder;
+pub mod canonical_json;
+pub mod diagnostics;
+pub mod diff;
+pub mod pack_set;
+pub mod resolver;
+pub mod review;
+pub mod schema;
+#[cfg(feature = "signing")]
+pub mod signing;
+pub mod validator;
+
+// Re-export main public types (§11.1)
+pub use builder::{build_semantic_pack, PackBuildInput, PackBuildOutput};
+pub use canonical_json::{canonical_json, compute_pack_content_hash, compute_sha256};
+pub use diagnostics::{
+    DeprecatedPolicy, DiagnosticSeverity, SemanticDiagnostic, SemanticDiagnosticCode,
+    SemanticTruth, SemanticValidationResult, SemanticValidationStatus, UnknownConceptPolicy,
+    ValidationMode, ValidationOptions,
+};
+pub use diff::{diff_packs, PackDiff};
+pub use pack_set::{merge_packs, ConflictType, PackSet};
+pub use resolver::{normalize_lookup_key, resolve_concept, ResolveRequest, ResolveResult};
+pub use schema::{
+    AliasDef, AliasStatus, ApprovalState, CompatibilityInfo, ConceptDef, ConceptDefinition,
+    ConceptKind, ConceptStatus, GeneratorInfo, PackRef, PackSetRef, PackTrust, ReviewDecision,
+    ReviewRecord, SemanticPack, SignatureState, SourceRef,
+};
+#[cfg(feature = "signing")]
+pub use signing::{derive_signer_id, sign_pack, verify_pack_signature, SignOutput};
+pub use validator::{validate_graph_with_pack, validate_semantic_pack, validate_term};

package/domainforge-core/src/semantic_pack/pack_set.rs

@@ -0,0 +1,240 @@
+use serde::{Deserialize, Serialize};
+
+use super::schema::{PackRef, SemanticPack};
+
+// ---------------------------------------------------------------------------
+// PackSet (10.1)
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PackSet {
+    pub packs: Vec<PackRef>,
+    pub precedence: Vec<String>,
+    pub merged_pack_hash: String,
+    pub conflicts: Vec<PackConflict>,
+}
+
+// ---------------------------------------------------------------------------
+// PackConflict (10.4)
+// ---------------------------------------------------------------------------
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct PackConflict {
+    pub conflict_type: ConflictType,
+    pub key: String,
+    pub pack_a_id: String,
+    pub pack_b_id: String,
+    pub detail: String,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "snake_case")]
+pub enum ConflictType {
+    SameConceptIdDifferentHash,
+    SameCanonicalNameDifferentId,
+    SameAliasKeyDifferentTarget,
+    IncompatibleRelationCardinality,
+    SameUnitSymbolDifferentDimension,
+    InvalidPriorityOrder,
+}
+
+// ---------------------------------------------------------------------------
+// Merge packs into a PackSet
+// ---------------------------------------------------------------------------
+pub fn merge_packs(
+    packs: &[SemanticPack],
+    priority_order: &[i32],
+) -> Result<PackSet, Vec<PackConflict>> {
+    if !packs.is_empty() && priority_order.len() != packs.len() {
+        return Err(vec![PackConflict {
+            conflict_type: ConflictType::InvalidPriorityOrder,
+            key: String::new(),
+            pack_a_id: String::new(),
+            pack_b_id: String::new(),
+            detail: format!(
+                "priority_order length ({}) must match packs length ({})",
+                priority_order.len(),
+                packs.len()
+            ),
+        }]);
+    }
+    if packs.is_empty() {
+        return Ok(PackSet {
+            packs: vec![],
+            precedence: vec![],
+            merged_pack_hash: super::canonical_json::compute_sha256(b"empty_pack_set"),
+            conflicts: vec![],
+        });
+    }
+
+    // Build PackRefs sorted by canonical merge order (§10.2)
+    let mut refs: Vec<(PackRef, usize)> = Vec::new();
+    for (i, pack) in packs.iter().enumerate() {
+        let content_hash = super::canonical_json::compute_pack_content_hash(pack);
+        let priority = priority_order.get(i).copied().unwrap_or(0);
+        refs.push((
+            PackRef {
+                pack_id: pack.pack_id.clone(),
+                pack_content_hash: content_hash,
+                path_or_uri: format!("pack://{}", pack.pack_id),
+                priority,
+            },
+            i,
+        ));
+    }
+
+    // Sort: explicit priority ascending, pack_id ascending, hash ascending
+    refs.sort_by(|a, b| {
+        a.0.priority
+            .cmp(&b.0.priority)
+            .then(a.0.pack_id.cmp(&b.0.pack_id))
+            .then(a.0.pack_content_hash.cmp(&b.0.pack_content_hash))
+    });
+
+    // Detect conflicts (§10.4)
+    let conflicts = detect_conflicts(packs, &refs);
+
+    if !conflicts.is_empty() {
+        return Err(conflicts);
+    }
+
+    let pack_refs: Vec<PackRef> = refs.into_iter().map(|(r, _)| r).collect();
+    let merged_hash = compute_merged_hash(&pack_refs).map_err(|e| {
+        vec![PackConflict {
+            conflict_type: ConflictType::InvalidPriorityOrder,
+            key: format!("hash computation failed: {}", e),
+            pack_a_id: String::new(),
+            pack_b_id: String::new(),
+            detail: e,
+        }]
+    })?;
+    let precedence: Vec<String> = pack_refs.iter().map(|r| r.pack_id.clone()).collect();
+
+    Ok(PackSet {
+        packs: pack_refs.clone(),
+        precedence,
+        merged_pack_hash: merged_hash,
+        conflicts: vec![],
+    })
+}
+
+fn detect_conflicts(packs: &[SemanticPack], refs: &[(PackRef, usize)]) -> Vec<PackConflict> {
+    let mut conflicts = Vec::new();
+
+    // Same concept ID, different definition hash
+    for i in 0..refs.len() {
+        for j in (i + 1)..refs.len() {
+            let pack_a = &packs[refs[i].1];
+            let pack_b = &packs[refs[j].1];
+
+            // Concept conflicts
+            for ca in &pack_a.concepts {
+                for cb in &pack_b.concepts {
+                    if ca.id == cb.id
+                        && ca.definition.definition_hash != cb.definition.definition_hash
+                    {
+                        conflicts.push(PackConflict {
+                            conflict_type: ConflictType::SameConceptIdDifferentHash,
+                            key: ca.id.clone(),
+                            pack_a_id: pack_a.pack_id.clone(),
+                            pack_b_id: pack_b.pack_id.clone(),
+                            detail: format!(
+                                "Concept '{}' has different definition hashes: {} vs {}",
+                                ca.id, ca.definition.definition_hash, cb.definition.definition_hash
+                            ),
+                        });
+                    }
+                }
+            }
+
+            // Canonical name conflicts
+            use super::resolver::normalize_lookup_key;
+            let mut names_a: std::collections::HashMap<String, &str> =
+                std::collections::HashMap::new();
+            for c in &pack_a.concepts {
+                let norm = normalize_lookup_key(&c.canonical_name);
+                names_a.insert(norm, &c.id);
+            }
+            for c in &pack_b.concepts {
+                let norm = normalize_lookup_key(&c.canonical_name);
+                if let Some(existing_id) = names_a.get(&norm) {
+                    if *existing_id != c.id {
+                        conflicts.push(PackConflict {
+                            conflict_type: ConflictType::SameCanonicalNameDifferentId,
+                            key: norm.clone(),
+                            pack_a_id: pack_a.pack_id.clone(),
+                            pack_b_id: pack_b.pack_id.clone(),
+                            detail: format!(
+                                "Canonical name '{}' maps to '{}' and '{}'",
+                                norm, existing_id, c.id
+                            ),
+                        });
+                    }
+                }
+            }
+
+            // Alias conflicts
+            let mut aliases_a: std::collections::HashMap<String, &str> =
+                std::collections::HashMap::new();
+            for a in &pack_a.aliases {
+                aliases_a.insert(a.normalized_alias.clone(), &a.target_concept_id);
+            }
+            for a in &pack_b.aliases {
+                if let Some(existing_target) = aliases_a.get(&a.normalized_alias) {
+                    if *existing_target != a.target_concept_id {
+                        conflicts.push(PackConflict {
+                            conflict_type: ConflictType::SameAliasKeyDifferentTarget,
+                            key: a.normalized_alias.clone(),
+                            pack_a_id: pack_a.pack_id.clone(),
+                            pack_b_id: pack_b.pack_id.clone(),
+                            detail: format!(
+                                "Alias '{}' targets '{}' and '{}'",
+                                a.normalized_alias, existing_target, a.target_concept_id
+                            ),
+                        });
+                    }
+                }
+            }
+
+            // Unit symbol conflicts
+            let mut units_a: std::collections::HashMap<String, &str> =
+                std::collections::HashMap::new();
+            for u in &pack_a.units {
+                units_a.insert(u.symbol.clone(), &u.dimension_id);
+            }
+            for u in &pack_b.units {
+                if let Some(existing_dim) = units_a.get(&u.symbol) {
+                    if *existing_dim != u.dimension_id {
+                        conflicts.push(PackConflict {
+                            conflict_type: ConflictType::SameUnitSymbolDifferentDimension,
+                            key: u.symbol.clone(),
+                            pack_a_id: pack_a.pack_id.clone(),
+                            pack_b_id: pack_b.pack_id.clone(),
+                            detail: format!(
+                                "Unit '{}' has different dimensions: {} vs {}",
+                                u.symbol, existing_dim, u.dimension_id
+                            ),
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    conflicts
+}
+
+fn compute_merged_hash(refs: &[PackRef]) -> Result<String, String> {
+    let mut sorted_refs: Vec<serde_json::Value> = refs
+        .iter()
+        .map(|r| serde_json::to_value(r).map_err(|e| format!("failed to serialize PackRef: {}", e)))
+        .collect::<Result<_, _>>()?;
+    sorted_refs.sort_by(|a, b| {
+        let a_id = a.get("pack_id").and_then(|v| v.as_str()).unwrap_or("");
+        let b_id = b.get("pack_id").and_then(|v| v.as_str()).unwrap_or("");
+        a_id.cmp(b_id)
+    });
+    let input = serde_json::json!({
+        "pack_refs": sorted_refs,
+        "conflict_policy": "error_on_conflict"
+    });
+    Ok(super::canonical_json::hash_canonical_json(&input))
+}