omena_cross_file_summary/

lib.rs

//! Cross-file summary hypergraph substrate shared by query and streaming IFDS.

use std::collections::{BTreeMap, BTreeSet, VecDeque};

use omena_abstract_value::{LinearProvenanceV0, NaturalCountProvenanceSemiringV0};
use serde::Serialize;

pub type OmenaCrossFileLinearProvenanceV0 = LinearProvenanceV0<NaturalCountProvenanceSemiringV0>;

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCrossFileSummaryV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub status: &'static str,
    pub summary_scope: &'static str,
    pub style_count: usize,
    pub summary_edge_count: usize,
    pub edge_kind_counts: Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0>,
    pub summary_hash: String,
    pub edges: Vec<OmenaQueryCrossFileSummaryEdgeV0>,
    pub capabilities: OmenaQueryCrossFileSummaryCapabilitiesV0,
    pub next_priorities: Vec<&'static str>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCrossFileSummaryEdgeKindCountV0 {
    pub edge_kind: &'static str,
    pub count: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaCrossFileSummaryViewReportV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub status: &'static str,
    pub raw_edge_kind_catalog_count: usize,
    pub node_role_catalog_count: usize,
    pub summary_edge_count: usize,
    pub existing_edge_kind_counts: Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0>,
    pub recomputed_edge_kind_counts: Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0>,
    pub invalid_raw_edge_kinds: Vec<String>,
    pub invalid_node_roles: Vec<String>,
    pub all_raw_edge_kinds_in_catalog: bool,
    pub all_node_roles_in_catalog: bool,
    pub edge_kind_counts_match_existing_field: bool,
    pub summary_view_ready: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaCrossFileGraphDeltaV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub status: &'static str,
    pub before_edge_count: usize,
    pub after_edge_count: usize,
    pub added_edges: Vec<OmenaCrossFileGraphDeltaEdgeV0>,
    pub removed_edges: Vec<OmenaCrossFileGraphDeltaEdgeV0>,
    pub invalid_delta_edge_ids: Vec<String>,
    pub all_delta_edges_typed: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaCrossFileGraphDeltaEdgeV0 {
    pub edge_id: String,
    pub raw_edge_kind: &'static str,
    pub folded_edge_kind: UnifiedHypergraphEdgeKindV0,
    pub folded_by_lossy_catch_all: bool,
    pub from_role: OmenaCrossFileSummaryNodeRoleV0,
    pub target_role: Option<OmenaCrossFileSummaryNodeRoleV0>,
    pub from_path: String,
    pub target_path: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCrossFileSummaryEdgeV0 {
    pub edge_id: String,
    pub edge_kind: &'static str,
    pub from_kind: &'static str,
    pub from_path: String,
    pub target_kind: Option<&'static str>,
    pub target_path: Option<String>,
    pub source: Option<String>,
    pub owner_selector_name: Option<String>,
    pub local_name: Option<String>,
    pub remote_name: Option<String>,
    pub target_names: Vec<String>,
    pub status: &'static str,
    pub provenance: Vec<&'static str>,
    pub linear_provenance: OmenaCrossFileLinearProvenanceV0,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum OmenaCrossFileSummaryNodeRoleV0 {
    Source,
    Style,
}

impl OmenaCrossFileSummaryNodeRoleV0 {
    pub const fn as_wire_label(self) -> &'static str {
        match self {
            Self::Source => "source",
            Self::Style => "style",
        }
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum OmenaCrossFileSummaryRawEdgeKindV0 {
    ComposesExternal,
    ComposesGlobal,
    ComposesLocal,
    CssModulesComposesClosure,
    CssModulesComposesImport,
    CssModulesIcssClosure,
    CssModulesIcssImport,
    CssModulesImport,
    CssModulesValueClosure,
    CssModulesValueImport,
    ForeignReference,
    Icss,
    LessImport,
    LessModuleGraphClosure,
    SassForward,
    SassImport,
    SassModuleGraphClosure,
    SassUse,
    SourceSelectorPrefixReference,
    SourceSelectorReference,
    StyleDesignTokenReference,
    Value,
}

impl OmenaCrossFileSummaryRawEdgeKindV0 {
    pub const fn as_wire_label(self) -> &'static str {
        match self {
            Self::ComposesExternal => "composesExternal",
            Self::ComposesGlobal => "composesGlobal",
            Self::ComposesLocal => "composesLocal",
            Self::CssModulesComposesClosure => "cssModulesComposesClosure",
            Self::CssModulesComposesImport => "cssModulesComposesImport",
            Self::CssModulesIcssClosure => "cssModulesIcssClosure",
            Self::CssModulesIcssImport => "cssModulesIcssImport",
            Self::CssModulesImport => "cssModulesImport",
            Self::CssModulesValueClosure => "cssModulesValueClosure",
            Self::CssModulesValueImport => "cssModulesValueImport",
            Self::ForeignReference => "foreignReference",
            Self::Icss => "icss",
            Self::LessImport => "lessImport",
            Self::LessModuleGraphClosure => "lessModuleGraphClosure",
            Self::SassForward => "sassForward",
            Self::SassImport => "sassImport",
            Self::SassModuleGraphClosure => "sassModuleGraphClosure",
            Self::SassUse => "sassUse",
            Self::SourceSelectorPrefixReference => "sourceSelectorPrefixReference",
            Self::SourceSelectorReference => "sourceSelectorReference",
            Self::StyleDesignTokenReference => "styleDesignTokenReference",
            Self::Value => "value",
        }
    }

    pub const fn folded_edge_kind(self) -> UnifiedHypergraphEdgeKindV0 {
        match self {
            Self::ComposesLocal => UnifiedHypergraphEdgeKindV0::ComposesLocal,
            Self::ComposesGlobal => UnifiedHypergraphEdgeKindV0::ComposesGlobal,
            Self::CssModulesComposesImport
            | Self::CssModulesComposesClosure
            | Self::ComposesExternal => UnifiedHypergraphEdgeKindV0::ComposesExternal,
            Self::SassUse => UnifiedHypergraphEdgeKindV0::SassUse,
            Self::SassForward => UnifiedHypergraphEdgeKindV0::SassForward,
            Self::SassImport => UnifiedHypergraphEdgeKindV0::SassImport,
            Self::LessImport => UnifiedHypergraphEdgeKindV0::LessImport,
            Self::LessModuleGraphClosure => UnifiedHypergraphEdgeKindV0::LessModuleGraphClosure,
            Self::CssModulesValueImport | Self::CssModulesValueClosure | Self::Value => {
                UnifiedHypergraphEdgeKindV0::Value
            }
            Self::CssModulesIcssImport | Self::CssModulesIcssClosure | Self::Icss => {
                UnifiedHypergraphEdgeKindV0::Icss
            }
            Self::CssModulesImport
            | Self::ForeignReference
            | Self::SassModuleGraphClosure
            | Self::SourceSelectorPrefixReference
            | Self::SourceSelectorReference
            | Self::StyleDesignTokenReference => UnifiedHypergraphEdgeKindV0::ForeignReference,
        }
    }

    pub const fn folded_by_lossy_catch_all(self) -> bool {
        matches!(
            self,
            Self::CssModulesImport
                | Self::ForeignReference
                | Self::SassModuleGraphClosure
                | Self::SourceSelectorPrefixReference
                | Self::SourceSelectorReference
                | Self::StyleDesignTokenReference
        )
    }

    pub const fn order_relevance(self) -> EdgeOrderRelevanceV0 {
        match self {
            Self::CssModulesImport => EdgeOrderRelevanceV0::OrderBearing,
            Self::ForeignReference
            | Self::SassModuleGraphClosure
            | Self::SourceSelectorPrefixReference
            | Self::SourceSelectorReference
            | Self::StyleDesignTokenReference => EdgeOrderRelevanceV0::OrderNeutral,
            _ => self.folded_edge_kind().order_relevance(),
        }
    }
}

pub const UNIFIED_HYPERGRAPH_EDGE_KIND_VARIANTS_V0: [UnifiedHypergraphEdgeKindV0; 11] = [
    UnifiedHypergraphEdgeKindV0::ComposesLocal,
    UnifiedHypergraphEdgeKindV0::ComposesGlobal,
    UnifiedHypergraphEdgeKindV0::ComposesExternal,
    UnifiedHypergraphEdgeKindV0::SassUse,
    UnifiedHypergraphEdgeKindV0::SassForward,
    UnifiedHypergraphEdgeKindV0::SassImport,
    UnifiedHypergraphEdgeKindV0::LessImport,
    UnifiedHypergraphEdgeKindV0::LessModuleGraphClosure,
    UnifiedHypergraphEdgeKindV0::Value,
    UnifiedHypergraphEdgeKindV0::Icss,
    UnifiedHypergraphEdgeKindV0::ForeignReference,
];

pub const CROSS_FILE_SUMMARY_RAW_EDGE_KIND_VARIANTS_V0: [OmenaCrossFileSummaryRawEdgeKindV0; 22] = [
    OmenaCrossFileSummaryRawEdgeKindV0::ComposesExternal,
    OmenaCrossFileSummaryRawEdgeKindV0::ComposesGlobal,
    OmenaCrossFileSummaryRawEdgeKindV0::ComposesLocal,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesComposesClosure,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesComposesImport,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesIcssClosure,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesIcssImport,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesImport,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesValueClosure,
    OmenaCrossFileSummaryRawEdgeKindV0::CssModulesValueImport,
    OmenaCrossFileSummaryRawEdgeKindV0::ForeignReference,
    OmenaCrossFileSummaryRawEdgeKindV0::Icss,
    OmenaCrossFileSummaryRawEdgeKindV0::LessImport,
    OmenaCrossFileSummaryRawEdgeKindV0::LessModuleGraphClosure,
    OmenaCrossFileSummaryRawEdgeKindV0::SassForward,
    OmenaCrossFileSummaryRawEdgeKindV0::SassImport,
    OmenaCrossFileSummaryRawEdgeKindV0::SassModuleGraphClosure,
    OmenaCrossFileSummaryRawEdgeKindV0::SassUse,
    OmenaCrossFileSummaryRawEdgeKindV0::SourceSelectorPrefixReference,
    OmenaCrossFileSummaryRawEdgeKindV0::SourceSelectorReference,
    OmenaCrossFileSummaryRawEdgeKindV0::StyleDesignTokenReference,
    OmenaCrossFileSummaryRawEdgeKindV0::Value,
];

pub const CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0: [&str; 22] = [
    "composesExternal",
    "composesGlobal",
    "composesLocal",
    "cssModulesComposesClosure",
    "cssModulesComposesImport",
    "cssModulesIcssClosure",
    "cssModulesIcssImport",
    "cssModulesImport",
    "cssModulesValueClosure",
    "cssModulesValueImport",
    "foreignReference",
    "icss",
    "lessImport",
    "lessModuleGraphClosure",
    "sassForward",
    "sassImport",
    "sassModuleGraphClosure",
    "sassUse",
    "sourceSelectorPrefixReference",
    "sourceSelectorReference",
    "styleDesignTokenReference",
    "value",
];

pub const CROSS_FILE_SUMMARY_NODE_ROLE_LABELS_V0: [&str; 2] = ["source", "style"];

pub fn parse_cross_file_summary_node_role_v0(
    label: &str,
) -> Option<OmenaCrossFileSummaryNodeRoleV0> {
    match label {
        "source" => Some(OmenaCrossFileSummaryNodeRoleV0::Source),
        "style" => Some(OmenaCrossFileSummaryNodeRoleV0::Style),
        _ => None,
    }
}

pub fn parse_cross_file_summary_raw_edge_kind_v0(
    label: &str,
) -> Option<OmenaCrossFileSummaryRawEdgeKindV0> {
    match label {
        "composesExternal" => Some(OmenaCrossFileSummaryRawEdgeKindV0::ComposesExternal),
        "composesGlobal" => Some(OmenaCrossFileSummaryRawEdgeKindV0::ComposesGlobal),
        "composesLocal" => Some(OmenaCrossFileSummaryRawEdgeKindV0::ComposesLocal),
        "cssModulesComposesClosure" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesComposesClosure)
        }
        "cssModulesComposesImport" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesComposesImport)
        }
        "cssModulesIcssClosure" => Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesIcssClosure),
        "cssModulesIcssImport" => Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesIcssImport),
        "cssModulesImport" => Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesImport),
        "cssModulesValueClosure" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesValueClosure)
        }
        "cssModulesValueImport" => Some(OmenaCrossFileSummaryRawEdgeKindV0::CssModulesValueImport),
        "foreignReference" => Some(OmenaCrossFileSummaryRawEdgeKindV0::ForeignReference),
        "icss" => Some(OmenaCrossFileSummaryRawEdgeKindV0::Icss),
        "lessImport" => Some(OmenaCrossFileSummaryRawEdgeKindV0::LessImport),
        "lessModuleGraphClosure" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::LessModuleGraphClosure)
        }
        "sassForward" => Some(OmenaCrossFileSummaryRawEdgeKindV0::SassForward),
        "sassImport" => Some(OmenaCrossFileSummaryRawEdgeKindV0::SassImport),
        "sassModuleGraphClosure" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::SassModuleGraphClosure)
        }
        "sassUse" => Some(OmenaCrossFileSummaryRawEdgeKindV0::SassUse),
        "sourceSelectorPrefixReference" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::SourceSelectorPrefixReference)
        }
        "sourceSelectorReference" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::SourceSelectorReference)
        }
        "styleDesignTokenReference" => {
            Some(OmenaCrossFileSummaryRawEdgeKindV0::StyleDesignTokenReference)
        }
        "value" => Some(OmenaCrossFileSummaryRawEdgeKindV0::Value),
        _ => None,
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCrossFileSummaryCapabilitiesV0 {
    pub css_modules_composes_edges_ready: bool,
    pub css_modules_value_edges_ready: bool,
    pub css_modules_icss_edges_ready: bool,
    pub sass_module_edges_ready: bool,
    pub style_design_token_reference_edges_ready: bool,
    pub source_selector_reference_edges_ready: bool,
    pub stable_summary_hash_ready: bool,
    pub linear_provenance_ready: bool,
    pub linear_provenance_round_trip_ready: bool,
    pub linear_provenance_semiring_laws_hold: bool,
}

#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ReverseDependencyIndexV0 {
    pub rev: BTreeMap<String, BTreeSet<String>>,
    pub edges_by_from: BTreeMap<String, BTreeSet<String>>,
}

impl OmenaQueryCrossFileSummaryEdgeV0 {
    pub fn linear_provenance_round_trips_legacy_labels(&self) -> bool {
        self.linear_provenance.labels() == self.provenance
    }
}

impl OmenaQueryCrossFileSummaryV0 {
    pub fn linear_provenance_round_trips_legacy_labels(&self) -> bool {
        self.edges
            .iter()
            .all(OmenaQueryCrossFileSummaryEdgeV0::linear_provenance_round_trips_legacy_labels)
    }

    pub fn recompute_stable_summary_hash(&self) -> String {
        stable_omena_query_cross_file_summary_hash(self.edges.as_slice())
    }
}

pub fn summarize_cross_file_summary_view_v0(
    summary: &OmenaQueryCrossFileSummaryV0,
) -> OmenaCrossFileSummaryViewReportV0 {
    let recomputed_edge_kind_counts =
        recompute_cross_file_summary_raw_edge_kind_counts_v0(summary.edges.as_slice());
    let invalid_raw_edge_kinds = invalid_raw_edge_kinds_for_summary(summary);
    let invalid_node_roles = invalid_node_roles_for_summary(summary);
    let edge_kind_counts_match_existing_field =
        recomputed_edge_kind_counts == summary.edge_kind_counts;
    let all_raw_edge_kinds_in_catalog = invalid_raw_edge_kinds.is_empty();
    let all_node_roles_in_catalog = invalid_node_roles.is_empty();
    let summary_view_ready = all_raw_edge_kinds_in_catalog
        && all_node_roles_in_catalog
        && edge_kind_counts_match_existing_field;

    OmenaCrossFileSummaryViewReportV0 {
        schema_version: "0",
        product: "omena-cross-file-summary.summary-view",
        status: if summary_view_ready {
            "ready"
        } else {
            "needsInput"
        },
        raw_edge_kind_catalog_count: CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0.len(),
        node_role_catalog_count: CROSS_FILE_SUMMARY_NODE_ROLE_LABELS_V0.len(),
        summary_edge_count: summary.summary_edge_count,
        existing_edge_kind_counts: summary.edge_kind_counts.clone(),
        recomputed_edge_kind_counts,
        invalid_raw_edge_kinds,
        invalid_node_roles,
        all_raw_edge_kinds_in_catalog,
        all_node_roles_in_catalog,
        edge_kind_counts_match_existing_field,
        summary_view_ready,
    }
}

pub fn recompute_cross_file_summary_raw_edge_kind_counts_v0(
    edges: &[OmenaQueryCrossFileSummaryEdgeV0],
) -> Vec<OmenaQueryCrossFileSummaryEdgeKindCountV0> {
    let mut counts = BTreeMap::<&'static str, usize>::new();
    for edge in edges {
        *counts.entry(edge.edge_kind).or_default() += 1;
    }
    counts
        .into_iter()
        .map(|(edge_kind, count)| OmenaQueryCrossFileSummaryEdgeKindCountV0 { edge_kind, count })
        .collect()
}

pub fn summarize_cross_file_graph_delta_v0(
    before: &OmenaQueryCrossFileSummaryV0,
    after: &OmenaQueryCrossFileSummaryV0,
) -> OmenaCrossFileGraphDeltaV0 {
    let before_edges = before
        .edges
        .iter()
        .map(|edge| (edge.edge_id.as_str(), edge))
        .collect::<BTreeMap<_, _>>();
    let after_edges = after
        .edges
        .iter()
        .map(|edge| (edge.edge_id.as_str(), edge))
        .collect::<BTreeMap<_, _>>();

    let mut invalid_delta_edge_ids = Vec::new();
    let mut added_edges = Vec::new();
    let mut removed_edges = Vec::new();

    for (edge_id, edge) in &after_edges {
        if before_edges.contains_key(edge_id) {
            continue;
        }
        if let Some(typed_edge) = typed_graph_delta_edge_from_summary_edge(edge) {
            added_edges.push(typed_edge);
        } else {
            invalid_delta_edge_ids.push((*edge_id).to_string());
        }
    }
    for (edge_id, edge) in &before_edges {
        if after_edges.contains_key(edge_id) {
            continue;
        }
        if let Some(typed_edge) = typed_graph_delta_edge_from_summary_edge(edge) {
            removed_edges.push(typed_edge);
        } else {
            invalid_delta_edge_ids.push((*edge_id).to_string());
        }
    }

    added_edges.sort_by_key(|edge| edge.edge_id.clone());
    removed_edges.sort_by_key(|edge| edge.edge_id.clone());
    invalid_delta_edge_ids.sort();
    let all_delta_edges_typed = invalid_delta_edge_ids.is_empty();

    OmenaCrossFileGraphDeltaV0 {
        schema_version: "0",
        product: "omena-cross-file-summary.graph-delta",
        status: if all_delta_edges_typed {
            "ready"
        } else {
            "needsInput"
        },
        before_edge_count: before.summary_edge_count,
        after_edge_count: after.summary_edge_count,
        added_edges,
        removed_edges,
        invalid_delta_edge_ids,
        all_delta_edges_typed,
    }
}

fn invalid_raw_edge_kinds_for_summary(summary: &OmenaQueryCrossFileSummaryV0) -> Vec<String> {
    summary
        .edges
        .iter()
        .filter(|edge| parse_cross_file_summary_raw_edge_kind_v0(edge.edge_kind).is_none())
        .map(|edge| edge.edge_kind.to_string())
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect()
}

fn invalid_node_roles_for_summary(summary: &OmenaQueryCrossFileSummaryV0) -> Vec<String> {
    let mut invalid = BTreeSet::new();
    for edge in &summary.edges {
        if parse_cross_file_summary_node_role_v0(edge.from_kind).is_none() {
            invalid.insert(edge.from_kind.to_string());
        }
        if let Some(target_kind) = edge.target_kind
            && parse_cross_file_summary_node_role_v0(target_kind).is_none()
        {
            invalid.insert(target_kind.to_string());
        }
    }
    invalid.into_iter().collect()
}

fn typed_graph_delta_edge_from_summary_edge(
    edge: &OmenaQueryCrossFileSummaryEdgeV0,
) -> Option<OmenaCrossFileGraphDeltaEdgeV0> {
    let raw_edge_kind = parse_cross_file_summary_raw_edge_kind_v0(edge.edge_kind)?;
    let from_role = parse_cross_file_summary_node_role_v0(edge.from_kind)?;
    let target_role = match edge.target_kind {
        Some(target_kind) => Some(parse_cross_file_summary_node_role_v0(target_kind)?),
        None => None,
    };
    Some(OmenaCrossFileGraphDeltaEdgeV0 {
        edge_id: edge.edge_id.clone(),
        raw_edge_kind: raw_edge_kind.as_wire_label(),
        folded_edge_kind: raw_edge_kind.folded_edge_kind(),
        folded_by_lossy_catch_all: raw_edge_kind.folded_by_lossy_catch_all(),
        from_role,
        target_role,
        from_path: edge.from_path.clone(),
        target_path: edge.target_path.clone(),
    })
}

pub fn reverse_dependency_index_from_edges_v0(
    edges: &[OmenaQueryCrossFileSummaryEdgeV0],
) -> ReverseDependencyIndexV0 {
    let mut index = ReverseDependencyIndexV0 {
        rev: BTreeMap::new(),
        edges_by_from: BTreeMap::new(),
    };
    for edge in edges {
        let Some(target_path) = edge.target_path.as_ref() else {
            continue;
        };
        index
            .edges_by_from
            .entry(edge.from_path.clone())
            .or_default()
            .insert(target_path.clone());
        index
            .rev
            .entry(target_path.clone())
            .or_default()
            .insert(edge.from_path.clone());
    }
    index
}

pub fn apply_reverse_dependency_delta_v0(
    index: &mut ReverseDependencyIndexV0,
    next_edges: &[OmenaQueryCrossFileSummaryEdgeV0],
) -> usize {
    let next_groups = reverse_dependency_groups_by_from_path(next_edges);
    let mut from_paths = index.edges_by_from.keys().cloned().collect::<BTreeSet<_>>();
    from_paths.extend(next_groups.keys().cloned());

    let mut patched_groups = 0;
    for from_path in from_paths {
        let old_targets = index
            .edges_by_from
            .get(from_path.as_str())
            .cloned()
            .unwrap_or_default();
        let new_targets = next_groups
            .get(from_path.as_str())
            .cloned()
            .unwrap_or_default();
        if old_targets == new_targets {
            continue;
        }
        patched_groups += 1;
        for target in &old_targets {
            if let Some(dependents) = index.rev.get_mut(target.as_str()) {
                dependents.remove(from_path.as_str());
                if dependents.is_empty() {
                    index.rev.remove(target.as_str());
                }
            }
        }
        if new_targets.is_empty() {
            index.edges_by_from.remove(from_path.as_str());
        } else {
            for target in &new_targets {
                index
                    .rev
                    .entry(target.clone())
                    .or_default()
                    .insert(from_path.clone());
            }
            index.edges_by_from.insert(from_path, new_targets);
        }
    }
    patched_groups
}

pub fn reverse_dependency_closure_v0(
    index: &ReverseDependencyIndexV0,
    seeds: &BTreeSet<String>,
) -> BTreeSet<String> {
    let mut visited = BTreeSet::new();
    let mut queue = seeds.iter().cloned().collect::<VecDeque<_>>();
    while let Some(path) = queue.pop_front() {
        if let Some(dependents) = index.rev.get(path.as_str()) {
            for dependent in dependents {
                if visited.insert(dependent.clone()) {
                    queue.push_back(dependent.clone());
                }
            }
        }
    }
    visited
}

/// The declared read-set of ONE style target's workspace diagnostics, as a
/// path set over the summary's edge graph: the target itself, its FORWARD
/// closure (modules whose contents the target's resolution, token, cascade,
/// replica-ensemble, and reachability arms read), and its DIRECT reverse
/// neighbors (style and source files whose references decide the target's
/// usage-derived diagnostics). This is the verifying-trace manifest for the
/// disk diagnostics cache: completeness is oracle-gated in the LSP crate
/// (a manifest-verified hit must be byte-identical to a fresh compute), so
/// any diagnostics arm that grows a wider read window fails the oracle
/// instead of silently serving stale shards.
pub fn diagnostics_read_set_for_target_v0(
    index: &ReverseDependencyIndexV0,
    target_path: &str,
) -> BTreeSet<String> {
    let mut read_set = BTreeSet::from([target_path.to_string()]);
    let mut queue = VecDeque::from([target_path.to_string()]);
    while let Some(path) = queue.pop_front() {
        if let Some(targets) = index.edges_by_from.get(path.as_str()) {
            for next in targets {
                if read_set.insert(next.clone()) {
                    queue.push_back(next.clone());
                }
            }
        }
    }
    if let Some(dependents) = index.rev.get(target_path) {
        read_set.extend(dependents.iter().cloned());
    }
    read_set
}

fn reverse_dependency_groups_by_from_path(
    edges: &[OmenaQueryCrossFileSummaryEdgeV0],
) -> BTreeMap<String, BTreeSet<String>> {
    let mut groups = BTreeMap::<String, BTreeSet<String>>::new();
    for edge in edges {
        let Some(target_path) = edge.target_path.as_ref() else {
            continue;
        };
        groups
            .entry(edge.from_path.clone())
            .or_default()
            .insert(target_path.clone());
    }
    groups
}

#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum UnifiedHypergraphEdgeKindV0 {
    ComposesLocal,
    ComposesGlobal,
    ComposesExternal,
    SassUse,
    SassForward,
    SassImport,
    LessImport,
    LessModuleGraphClosure,
    Value,
    Icss,
    ForeignReference,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub enum EdgeOrderRelevanceV0 {
    OrderBearing,
    OrderNeutral,
}

impl EdgeOrderRelevanceV0 {
    pub const fn as_wire_label(self) -> &'static str {
        match self {
            Self::OrderBearing => "orderBearing",
            Self::OrderNeutral => "orderNeutral",
        }
    }
}

impl UnifiedHypergraphEdgeKindV0 {
    pub const fn as_wire_label(self) -> &'static str {
        match self {
            Self::ComposesLocal => "composesLocal",
            Self::ComposesGlobal => "composesGlobal",
            Self::ComposesExternal => "composesExternal",
            Self::SassUse => "sassUse",
            Self::SassForward => "sassForward",
            Self::SassImport => "sassImport",
            Self::LessImport => "lessImport",
            Self::LessModuleGraphClosure => "lessModuleGraphClosure",
            Self::Value => "value",
            Self::Icss => "icss",
            Self::ForeignReference => "foreignReference",
        }
    }

    pub const fn order_relevance(self) -> EdgeOrderRelevanceV0 {
        match self {
            Self::ComposesLocal
            | Self::ComposesGlobal
            | Self::ComposesExternal
            | Self::SassUse
            | Self::SassForward
            | Self::SassImport
            | Self::LessImport
            | Self::Value
            | Self::Icss => EdgeOrderRelevanceV0::OrderBearing,
            Self::LessModuleGraphClosure | Self::ForeignReference => {
                EdgeOrderRelevanceV0::OrderNeutral
            }
        }
    }

    pub const fn is_order_significant(self) -> bool {
        matches!(self.order_relevance(), EdgeOrderRelevanceV0::OrderBearing)
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct UnifiedHypergraphHyperedgeV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub layer_marker: &'static str,
    pub feature_gate: &'static str,
    pub hyperedge_id: String,
    pub edge_kind: UnifiedHypergraphEdgeKindV0,
    pub source_summary_edge_id: String,
    pub source_edge_kind: &'static str,
    pub source_status: &'static str,
    pub tail_node_ids: Vec<String>,
    pub head_node_id: String,
    pub order_significant_tail: bool,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HypergraphIFDSSummaryEdgeV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub layer_marker: &'static str,
    pub feature_gate: &'static str,
    pub summary_edge_id: String,
    pub projection_edge_id: String,
    pub hyperedge_id: String,
    pub from_node_id: String,
    pub to_node_id: String,
    pub edge_kind: UnifiedHypergraphEdgeKindV0,
    pub status: &'static str,
    pub provenance: Vec<&'static str>,
    pub linear_provenance: OmenaCrossFileLinearProvenanceV0,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryUnifiedCrossFileHypergraphV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub status: &'static str,
    pub layer_marker: &'static str,
    pub feature_gate: &'static str,
    pub node_count: usize,
    pub hyperedge_count: usize,
    pub summary_edge_count: usize,
    pub projection_edge_ids: Vec<String>,
    pub hyperedges: Vec<UnifiedHypergraphHyperedgeV0>,
    pub summary_edges: Vec<HypergraphIFDSSummaryEdgeV0>,
    pub gate_predicates: Vec<&'static str>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryCrossFileSccEvidenceV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub feature_gate: &'static str,
    pub claim_level: &'static str,
    pub theorem_claimed: bool,
    pub connectivity_backend: &'static str,
    pub polylog_bound_scope: &'static str,
    pub scc_id: String,
    pub node_count: usize,
    pub directed_edge_count: usize,
    pub cross_file: bool,
    pub node_ids: Vec<String>,
    pub style_paths: Vec<String>,
    pub edge_kinds: Vec<&'static str>,
    pub summary_edge_ids: Vec<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct OmenaQueryUnifiedCrossFileSccReportV0 {
    pub schema_version: &'static str,
    pub product: &'static str,
    pub feature_gate: &'static str,
    pub claim_level: &'static str,
    pub theorem_claimed: bool,
    pub connectivity_backend: &'static str,
    pub polylog_bound_scope: &'static str,
    pub node_count: usize,
    pub directed_edge_count: usize,
    pub cyclic_scc_count: usize,
    pub sccs: Vec<OmenaQueryCrossFileSccEvidenceV0>,
    pub gate_predicates: Vec<&'static str>,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct HypergraphClosurePath<N> {
    pub origin: N,
    pub target: N,
    pub depth: usize,
    pub path_labels: Vec<String>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum HypergraphClosureMode {
    CanonicalFirstTarget,
    RawAllPaths,
}

pub trait OmenaUnifiedHypergraphConnectivityOracle {
    fn reachable_node_ids(
        &self,
        start_node_id: &str,
        hyperedges: &[UnifiedHypergraphHyperedgeV0],
    ) -> Vec<String>;
}

#[derive(Debug, Clone, Copy, Default)]
pub struct BatchHypergraphConnectivityOracle;

impl OmenaUnifiedHypergraphConnectivityOracle for BatchHypergraphConnectivityOracle {
    fn reachable_node_ids(
        &self,
        start_node_id: &str,
        hyperedges: &[UnifiedHypergraphHyperedgeV0],
    ) -> Vec<String> {
        collect_reachable_node_ids(start_node_id, &build_adjacency(hyperedges))
    }
}

/// The single shared reachability BFS loop for the cross-file engine: forward closure over a
/// deterministic `BTreeMap` adjacency, returned sorted (BTreeSet order). Generic over the
/// adjacency key type so each caller keeps its OWN adjacency builder (the distinct node spaces
/// comment-2 point 4 demands) while sharing exactly one traversal loop. (The substrate diagnostics
/// reachability is a separate borrowed-`&str` DFS over inline-filtered `resolved` edges and is
/// intentionally NOT one of the two BFS impls this collapses.)
pub fn collect_reachable_node_ids<K>(
    start_node_id: &str,
    adjacency: &BTreeMap<K, BTreeSet<String>>,
) -> Vec<String>
where
    K: Ord + std::borrow::Borrow<str>,
{
    let mut seen = BTreeSet::new();
    let mut pending = VecDeque::from([start_node_id.to_string()]);
    while let Some(current) = pending.pop_front() {
        for target in adjacency.get(current.as_str()).into_iter().flatten() {
            if seen.insert(target.clone()) {
                pending.push_back(target.clone());
            }
        }
    }
    seen.into_iter().collect()
}

pub fn collect_reachable_node_ids_bitset<K>(
    start_node_id: &str,
    adjacency: &BTreeMap<K, BTreeSet<String>>,
) -> Vec<String>
where
    K: Ord + std::borrow::Borrow<str>,
{
    let dense_index = DenseNodeIndexV0::from_adjacency(start_node_id, adjacency);
    let Some(start_index) = dense_index.index_of(start_node_id) else {
        return Vec::new();
    };
    let dense_adjacency = dense_index.dense_adjacency(adjacency);
    let mut seen = DenseBitsetV0::new(dense_index.len());
    let mut pending = VecDeque::from([start_index]);
    while let Some(current) = pending.pop_front() {
        for target in dense_adjacency
            .get(current)
            .into_iter()
            .flat_map(|targets| targets.iter().copied())
        {
            if seen.insert(target) {
                pending.push_back(target);
            }
        }
    }
    dense_index.ids_for_bitset(&seen)
}

#[derive(Debug, Clone)]
struct DenseNodeIndexV0 {
    ids: Vec<String>,
    positions: BTreeMap<String, usize>,
}

impl DenseNodeIndexV0 {
    fn from_adjacency<K>(start_node_id: &str, adjacency: &BTreeMap<K, BTreeSet<String>>) -> Self
    where
        K: Ord + std::borrow::Borrow<str>,
    {
        let mut ids = BTreeSet::from([start_node_id.to_string()]);
        for (source, targets) in adjacency {
            ids.insert(source.borrow().to_string());
            ids.extend(targets.iter().cloned());
        }
        let ids = ids.into_iter().collect::<Vec<_>>();
        let positions = ids
            .iter()
            .enumerate()
            .map(|(index, node_id)| (node_id.clone(), index))
            .collect::<BTreeMap<_, _>>();
        Self { ids, positions }
    }

    fn len(&self) -> usize {
        self.ids.len()
    }

    fn index_of(&self, node_id: &str) -> Option<usize> {
        self.positions.get(node_id).copied()
    }

    fn dense_adjacency<K>(&self, adjacency: &BTreeMap<K, BTreeSet<String>>) -> Vec<Vec<usize>>
    where
        K: Ord + std::borrow::Borrow<str>,
    {
        let mut dense_adjacency = vec![Vec::new(); self.ids.len()];
        for (source, targets) in adjacency {
            let Some(source_index) = self.index_of(source.borrow()) else {
                continue;
            };
            dense_adjacency[source_index] = targets
                .iter()
                .filter_map(|target| self.index_of(target))
                .collect();
        }
        dense_adjacency
    }

    fn ids_for_bitset(&self, bitset: &DenseBitsetV0) -> Vec<String> {
        self.ids
            .iter()
            .enumerate()
            .filter(|(index, _)| bitset.contains(*index))
            .map(|(_, node_id)| node_id.clone())
            .collect()
    }
}

#[derive(Debug, Clone)]
struct DenseBitsetV0 {
    words: Vec<u64>,
}

impl DenseBitsetV0 {
    fn new(len: usize) -> Self {
        Self {
            words: vec![0; len.div_ceil(64)],
        }
    }

    fn insert(&mut self, index: usize) -> bool {
        let word_index = index / 64;
        let mask = 1u64 << (index % 64);
        let word = &mut self.words[word_index];
        let was_empty = *word & mask == 0;
        *word |= mask;
        was_empty
    }

    fn contains(&self, index: usize) -> bool {
        self.words
            .get(index / 64)
            .is_some_and(|word| word & (1u64 << (index % 64)) != 0)
    }
}

pub fn tabulate_hypergraph_ifds_summary_edges(
    hyperedges: &[UnifiedHypergraphHyperedgeV0],
    projected_edges: Vec<HypergraphIFDSSummaryEdgeV0>,
) -> Vec<HypergraphIFDSSummaryEdgeV0> {
    let hyperedge_ids = hyperedges
        .iter()
        .map(|edge| edge.hyperedge_id.as_str())
        .collect::<BTreeSet<_>>();
    let mut edges = projected_edges
        .into_iter()
        .filter(|edge| hyperedge_ids.contains(edge.hyperedge_id.as_str()))
        .collect::<Vec<_>>();
    edges.sort_by(|left, right| {
        left.projection_edge_id
            .cmp(&right.projection_edge_id)
            .then(left.hyperedge_id.cmp(&right.hyperedge_id))
    });
    edges
}

pub fn summarize_omena_query_unified_cross_file_scc_report(
    hypergraph: &OmenaQueryUnifiedCrossFileHypergraphV0,
) -> OmenaQueryUnifiedCrossFileSccReportV0 {
    let adjacency = build_directed_projection_adjacency(&hypergraph.summary_edges);
    let mut sccs = collect_directed_graph_sccs(&adjacency)
        .into_iter()
        .filter_map(|node_ids| summarize_cyclic_scc(&node_ids, &hypergraph.summary_edges))
        .collect::<Vec<_>>();
    sccs.sort_by(|left, right| {
        left.node_ids
            .cmp(&right.node_ids)
            .then(left.summary_edge_ids.cmp(&right.summary_edge_ids))
    });
    for (index, scc) in sccs.iter_mut().enumerate() {
        scc.scc_id = format!("exact-tarjan-scc:{}", index + 1);
    }

    OmenaQueryUnifiedCrossFileSccReportV0 {
        schema_version: "0",
        product: "omena-query.unified-cross-file-scc-report",
        feature_gate: "cross-file-scc-v0",
        claim_level: "fixtureWitnessExactTarjanScc",
        theorem_claimed: false,
        connectivity_backend: "exactTarjanScc",
        polylog_bound_scope: "notClaimedExactTraversal",
        node_count: adjacency.len(),
        directed_edge_count: hypergraph
            .summary_edges
            .iter()
            .filter(|edge| summary_edge_has_supported_target(edge.status))
            .count(),
        cyclic_scc_count: sccs.len(),
        sccs,
        gate_predicates: vec![
            "exactTarjanSccBackend",
            "theorem_claimed=false",
            "polylog_bound_scope=notClaimedExactTraversal",
        ],
    }
}

pub fn summarize_omena_query_unified_cross_file_hypergraph(
    summary: &OmenaQueryCrossFileSummaryV0,
) -> OmenaQueryUnifiedCrossFileHypergraphV0 {
    let mut builder = UnifiedCrossFileHypergraphBuilder::default();
    for edge in &summary.edges {
        builder.add_summary_edge(edge);
    }
    builder.finish()
}

pub fn collect_hypergraph_transitive_closure_paths<N, F>(
    graph: &BTreeMap<N, BTreeSet<N>>,
    mut label: F,
) -> (Vec<HypergraphClosurePath<N>>, Vec<Vec<String>>)
where
    N: Clone + Ord,
    F: FnMut(&N) -> String,
{
    collect_hypergraph_transitive_closure_paths_with_mode(
        graph,
        &mut label,
        HypergraphClosureMode::CanonicalFirstTarget,
    )
}

pub fn collect_hypergraph_transitive_closure_paths_with_mode<N, F>(
    graph: &BTreeMap<N, BTreeSet<N>>,
    label: &mut F,
    mode: HypergraphClosureMode,
) -> (Vec<HypergraphClosurePath<N>>, Vec<Vec<String>>)
where
    N: Clone + Ord,
    F: FnMut(&N) -> String,
{
    let mut closure_paths = Vec::new();
    let mut cycle_paths = Vec::new();
    let mut seen_cycles = BTreeSet::new();
    let first_target = mode == HypergraphClosureMode::CanonicalFirstTarget;

    for start in graph.keys() {
        let mut visited = BTreeSet::new();
        let mut pending = VecDeque::from([(start.clone(), vec![start.clone()])]);
        while let Some((current, path)) = pending.pop_front() {
            for target in graph.get(&current).into_iter().flatten() {
                if let Some(cycle_start) = path.iter().position(|node| node == target) {
                    let mut cycle = path[cycle_start..].to_vec();
                    cycle.push(target.clone());
                    let mut labels = cycle.iter().map(&mut *label).collect::<Vec<_>>();
                    if first_target {
                        labels = canonical_hypergraph_cycle_labels(labels);
                    }
                    if !labels.is_empty() && seen_cycles.insert(labels.clone()) {
                        cycle_paths.push(labels);
                    }
                    continue;
                }
                if first_target && !visited.insert(target.clone()) {
                    continue;
                }
                let mut edge_path = path.clone();
                edge_path.push(target.clone());
                closure_paths.push(HypergraphClosurePath {
                    origin: start.clone(),
                    target: target.clone(),
                    depth: edge_path.len().saturating_sub(1),
                    path_labels: edge_path.iter().map(&mut *label).collect(),
                });
                pending.push_back((target.clone(), edge_path));
            }
        }
    }
    (closure_paths, cycle_paths)
}

/// Generous per-SCC enumeration work budget; real module-graph SCCs are tiny (a cycle is a user
/// error to report), so the cap is a backstop that never fires in practice.
const DEFAULT_CYCLE_ENUMERATION_WORK_CAP: usize = 1 << 16;

/// All elementary directed circuits of `adjacency`, found per strongly-connected component:
/// partition with `collect_directed_graph_sccs`, then enumerate the simple cycles CONFINED to each
/// non-trivial SCC (a back-edge to the start closes a circuit). Each circuit is canonicalized via
/// `canonical_hypergraph_cycle_labels` (lex-smallest rotation, emitted CLOSED so a consumer's
/// `windows(2)` successor lookup resolves), deduped and sorted. This is the cross-file CYCLE owner,
/// decoupled from the all-paths closure scan so the latter can be replaced without touching cycles.
pub fn collect_directed_graph_cycles(
    adjacency: &BTreeMap<String, BTreeSet<String>>,
) -> Vec<Vec<String>> {
    collect_directed_graph_cycles_with_work_cap(adjacency, DEFAULT_CYCLE_ENUMERATION_WORK_CAP)
}

/// `collect_directed_graph_cycles` with an explicit per-SCC work cap (for tests). On cap-hit a
/// dense SCC degrades to its lex-smallest representative circuit — a witnessed shrink, NEVER a
/// silent drop.
pub fn collect_directed_graph_cycles_with_work_cap(
    adjacency: &BTreeMap<String, BTreeSet<String>>,
    per_scc_work_cap: usize,
) -> Vec<Vec<String>> {
    let mut circuits = BTreeSet::new();
    for scc in collect_directed_graph_sccs(adjacency) {
        let self_loop = scc.len() == 1
            && adjacency
                .get(scc[0].as_str())
                .is_some_and(|targets| targets.contains(&scc[0]));
        if scc.len() < 2 && !self_loop {
            continue;
        }
        let scc_nodes = scc.iter().map(String::as_str).collect::<BTreeSet<_>>();
        let mut found = BTreeSet::new();
        let mut work = 0usize;
        let mut capped = false;
        'starts: for start in &scc {
            // BFS over simple paths so the shortest circuits surface first (so the cap-fallback
            // representative is a real, short circuit).
            let mut pending = VecDeque::from([(start.clone(), vec![start.clone()])]);
            while let Some((current, path)) = pending.pop_front() {
                work += 1;
                if work > per_scc_work_cap {
                    capped = true;
                    break 'starts;
                }
                for target in adjacency.get(current.as_str()).into_iter().flatten() {
                    if !scc_nodes.contains(target.as_str()) {
                        continue;
                    }
                    if target == start {
                        let mut ring = path.clone();
                        ring.push(target.clone());
                        let canonical = canonical_hypergraph_cycle_labels(ring);
                        if !canonical.is_empty() {
                            found.insert(canonical);
                        }
                    } else if !path.iter().any(|node| node == target) {
                        let mut next = path.clone();
                        next.push(target.clone());
                        pending.push_back((target.clone(), next));
                    }
                }
            }
        }
        if capped {
            circuits.extend(found.into_iter().next());
        } else {
            circuits.extend(found);
        }
    }
    circuits.into_iter().collect()
}

fn canonical_hypergraph_cycle_labels(mut labels: Vec<String>) -> Vec<String> {
    if labels.len() > 1 && labels.first() == labels.last() {
        labels.pop();
    }
    if labels.is_empty() {
        return labels;
    }
    let mut best = labels.clone();
    for offset in 1..labels.len() {
        let mut rotated = labels[offset..].to_vec();
        rotated.extend_from_slice(&labels[..offset]);
        best = best.min(rotated);
    }
    best.push(best[0].clone());
    best
}

fn build_adjacency(
    hyperedges: &[UnifiedHypergraphHyperedgeV0],
) -> BTreeMap<&str, BTreeSet<String>> {
    let mut adjacency = BTreeMap::<&str, BTreeSet<String>>::new();
    for edge in hyperedges {
        for tail in &edge.tail_node_ids {
            adjacency
                .entry(tail.as_str())
                .or_default()
                .insert(edge.head_node_id.clone());
        }
    }
    adjacency
}

#[derive(Default)]
struct UnifiedCrossFileHypergraphBuilder {
    node_ids: BTreeSet<String>,
    hyperedges: Vec<UnifiedHypergraphHyperedgeV0>,
    summary_edges: Vec<HypergraphIFDSSummaryEdgeV0>,
}

impl UnifiedCrossFileHypergraphBuilder {
    fn add_summary_edge(&mut self, edge: &OmenaQueryCrossFileSummaryEdgeV0) {
        let edge_kind = unified_edge_kind_for_summary_edge(edge);
        let from_node_id = endpoint_node_id(edge, false);
        let to_node_id = endpoint_node_id(edge, true);
        let tail_node_ids = if edge_kind.is_order_significant() && !edge.target_names.is_empty() {
            edge.target_names
                .iter()
                .map(|target_name| {
                    node_id(
                        "styleSymbol",
                        edge.target_path
                            .as_deref()
                            .unwrap_or(edge.from_path.as_str()),
                        Some(target_name),
                    )
                })
                .collect::<Vec<_>>()
        } else {
            vec![from_node_id.clone()]
        };
        self.node_ids.insert(from_node_id.clone());
        self.node_ids.insert(to_node_id.clone());
        self.node_ids.extend(tail_node_ids.iter().cloned());

        let hyperedge_id = format!(
            "hyperedge:{}|{}|{}",
            edge_kind.as_wire_label(),
            edge.edge_id,
            tail_node_ids.join(">")
        );
        self.hyperedges.push(UnifiedHypergraphHyperedgeV0 {
            schema_version: "0",
            product: "omena-query.unified-hypergraph-hyperedge",
            layer_marker: "hypergraph-ifds",
            feature_gate: "hypergraph-ifds",
            hyperedge_id: hyperedge_id.clone(),
            edge_kind,
            source_summary_edge_id: edge.edge_id.clone(),
            source_edge_kind: edge.edge_kind,
            source_status: edge.status,
            tail_node_ids,
            head_node_id: to_node_id.clone(),
            order_significant_tail: edge_kind.is_order_significant(),
        });
        self.summary_edges.push(HypergraphIFDSSummaryEdgeV0 {
            schema_version: "0",
            product: "omena-query.hypergraph-ifds-summary-edge",
            layer_marker: "hypergraph-ifds",
            feature_gate: "hypergraph-ifds",
            summary_edge_id: format!("ifds-summary:{}", edge.edge_id),
            projection_edge_id: edge.edge_id.clone(),
            hyperedge_id,
            from_node_id,
            to_node_id,
            edge_kind,
            status: edge.status,
            provenance: edge.provenance.clone(),
            linear_provenance: edge.linear_provenance.clone(),
        });
    }

    fn finish(mut self) -> OmenaQueryUnifiedCrossFileHypergraphV0 {
        self.hyperedges
            .sort_by_key(|edge| edge.hyperedge_id.clone());
        let summary_edges =
            tabulate_hypergraph_ifds_summary_edges(&self.hyperedges, self.summary_edges);
        let projection_edge_ids = summary_edges
            .iter()
            .map(|edge| edge.projection_edge_id.clone())
            .collect::<Vec<_>>();

        OmenaQueryUnifiedCrossFileHypergraphV0 {
            schema_version: "0",
            product: "omena-query.unified-cross-file-hypergraph",
            status: "hypergraphIfdsProjection",
            layer_marker: "hypergraph-ifds",
            feature_gate: "hypergraph-ifds",
            node_count: self.node_ids.len(),
            hyperedge_count: self.hyperedges.len(),
            summary_edge_count: summary_edges.len(),
            projection_edge_ids,
            hyperedges: self.hyperedges,
            summary_edges,
            gate_predicates: vec![
                "P1.typeIntroduction",
                "P2.byteEqualAdjacencyProjection",
                "P3.sccUnification",
                "P4.summaryEdgeSetEquality",
                "P5.projectionHelper",
                "P6.closureBodySwitchOver",
                "P7.v0Publication",
                "batchConnectivityOracle",
                "streamingOracleWireCompatible",
                "composesTailOrderingUsesVec",
            ],
        }
    }
}

fn endpoint_node_id(edge: &OmenaQueryCrossFileSummaryEdgeV0, target: bool) -> String {
    let (kind, path, symbol) = if target {
        (
            node_kind_for_summary_kind(edge.target_kind.unwrap_or(edge.from_kind), true),
            edge.target_path
                .as_deref()
                .unwrap_or(edge.from_path.as_str()),
            edge.remote_name
                .as_deref()
                .or_else(|| edge.target_names.first().map(String::as_str)),
        )
    } else {
        (
            node_kind_for_summary_kind(edge.from_kind, false),
            edge.from_path.as_str(),
            edge.owner_selector_name
                .as_deref()
                .or(edge.local_name.as_deref()),
        )
    };
    node_id(kind, path, symbol)
}

fn node_id(kind: &'static str, path: &str, symbol: Option<&str>) -> String {
    format!("{}|{}|{}", kind, path, symbol.unwrap_or("-"))
}

fn node_kind_for_summary_kind(kind: &str, target: bool) -> &'static str {
    match (kind, target) {
        ("style", false) => "styleModule",
        ("style", true) => "styleSymbol",
        ("source", false) => "sourceModule",
        ("source", true) => "sourceSymbol",
        _ => "foreignSymbol",
    }
}

fn unified_edge_kind_for_summary_edge(
    edge: &OmenaQueryCrossFileSummaryEdgeV0,
) -> UnifiedHypergraphEdgeKindV0 {
    match edge.edge_kind {
        "composesLocal" => UnifiedHypergraphEdgeKindV0::ComposesLocal,
        "composesGlobal" => UnifiedHypergraphEdgeKindV0::ComposesGlobal,
        "cssModulesComposesImport" | "cssModulesComposesClosure" | "composesExternal" => {
            UnifiedHypergraphEdgeKindV0::ComposesExternal
        }
        "sassUse" => UnifiedHypergraphEdgeKindV0::SassUse,
        "sassForward" => UnifiedHypergraphEdgeKindV0::SassForward,
        "sassImport" => UnifiedHypergraphEdgeKindV0::SassImport,
        "lessImport" => UnifiedHypergraphEdgeKindV0::LessImport,
        "lessModuleGraphClosure" => UnifiedHypergraphEdgeKindV0::LessModuleGraphClosure,
        "cssModulesValueImport" | "cssModulesValueClosure" | "value" => {
            UnifiedHypergraphEdgeKindV0::Value
        }
        "cssModulesIcssImport" | "cssModulesIcssClosure" | "icss" => {
            UnifiedHypergraphEdgeKindV0::Icss
        }
        _ => UnifiedHypergraphEdgeKindV0::ForeignReference,
    }
}

fn build_directed_projection_adjacency(
    summary_edges: &[HypergraphIFDSSummaryEdgeV0],
) -> BTreeMap<String, BTreeSet<String>> {
    let mut adjacency = BTreeMap::<String, BTreeSet<String>>::new();
    for edge in summary_edges {
        if !summary_edge_has_supported_target(edge.status) {
            continue;
        }
        let from_node_id = canonical_scc_node_id(edge.from_node_id.as_str());
        let to_node_id = canonical_scc_node_id(edge.to_node_id.as_str());
        adjacency.entry(from_node_id.clone()).or_default();
        adjacency.entry(to_node_id.clone()).or_default();
        adjacency
            .entry(from_node_id)
            .or_default()
            .insert(to_node_id);
    }
    adjacency
}

/// The single shared strongly-connected-components primitive for the cross-file engine: exact
/// Tarjan over a deterministic `BTreeMap` adjacency, each component sorted, components in Tarjan
/// reverse-topological discovery order. Consumed by both this crate's unified SCC report and
/// `omena-streaming-ifds` (which previously carried a byte-identical duplicate).
pub fn collect_directed_graph_sccs(
    adjacency: &BTreeMap<String, BTreeSet<String>>,
) -> Vec<Vec<String>> {
    let mut state = TarjanState::default();
    for node_id in adjacency.keys() {
        if !state.indices.contains_key(node_id) {
            state.visit(node_id, adjacency);
        }
    }
    state.components
}

#[derive(Default)]
struct TarjanState {
    next_index: usize,
    stack: Vec<String>,
    on_stack: BTreeSet<String>,
    indices: BTreeMap<String, usize>,
    lowlinks: BTreeMap<String, usize>,
    components: Vec<Vec<String>>,
}

impl TarjanState {
    fn visit(&mut self, node_id: &str, adjacency: &BTreeMap<String, BTreeSet<String>>) {
        let index = self.next_index;
        self.next_index += 1;
        self.indices.insert(node_id.to_string(), index);
        self.lowlinks.insert(node_id.to_string(), index);
        self.stack.push(node_id.to_string());
        self.on_stack.insert(node_id.to_string());

        if let Some(targets) = adjacency.get(node_id) {
            for target in targets {
                if !self.indices.contains_key(target.as_str()) {
                    self.visit(target, adjacency);
                    let target_lowlink = self.lowlinks[target.as_str()];
                    let current_lowlink = self.lowlinks[node_id];
                    self.lowlinks
                        .insert(node_id.to_string(), current_lowlink.min(target_lowlink));
                } else if self.on_stack.contains(target.as_str()) {
                    let target_index = self.indices[target.as_str()];
                    let current_lowlink = self.lowlinks[node_id];
                    self.lowlinks
                        .insert(node_id.to_string(), current_lowlink.min(target_index));
                }
            }
        }

        if self.lowlinks[node_id] == self.indices[node_id] {
            let mut component = Vec::new();
            while let Some(stack_node) = self.stack.pop() {
                self.on_stack.remove(stack_node.as_str());
                let done = stack_node == node_id;
                component.push(stack_node);
                if done {
                    break;
                }
            }
            component.sort();
            self.components.push(component);
        }
    }
}

fn summarize_cyclic_scc(
    node_ids: &[String],
    summary_edges: &[HypergraphIFDSSummaryEdgeV0],
) -> Option<OmenaQueryCrossFileSccEvidenceV0> {
    let node_set = node_ids.iter().map(String::as_str).collect::<BTreeSet<_>>();
    let internal_edges = summary_edges
        .iter()
        .filter(|edge| summary_edge_has_supported_target(edge.status))
        .filter(|edge| {
            let from_node_id = canonical_scc_node_id(edge.from_node_id.as_str());
            let to_node_id = canonical_scc_node_id(edge.to_node_id.as_str());
            node_set.contains(from_node_id.as_str()) && node_set.contains(to_node_id.as_str())
        })
        .collect::<Vec<_>>();
    let has_self_loop = internal_edges.iter().any(|edge| {
        canonical_scc_node_id(edge.from_node_id.as_str())
            == canonical_scc_node_id(edge.to_node_id.as_str())
    });
    if node_ids.len() < 2 && !has_self_loop {
        return None;
    }

    let style_paths = node_ids
        .iter()
        .filter_map(|node_id| style_path_from_node_id(node_id))
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect::<Vec<_>>();
    let edge_kinds = internal_edges
        .iter()
        .map(|edge| edge.edge_kind.as_wire_label())
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect::<Vec<_>>();
    let summary_edge_ids = internal_edges
        .iter()
        .map(|edge| edge.projection_edge_id.clone())
        .collect::<BTreeSet<_>>()
        .into_iter()
        .collect::<Vec<_>>();

    Some(OmenaQueryCrossFileSccEvidenceV0 {
        schema_version: "0",
        product: "omena-query.cross-file-scc-evidence",
        feature_gate: "cross-file-scc-v0",
        claim_level: "fixtureWitnessExactTarjanScc",
        theorem_claimed: false,
        connectivity_backend: "exactTarjanScc",
        polylog_bound_scope: "notClaimedExactTraversal",
        scc_id: String::new(),
        node_count: node_ids.len(),
        directed_edge_count: internal_edges.len(),
        cross_file: style_paths.len() > 1,
        node_ids: node_ids.to_vec(),
        style_paths,
        edge_kinds,
        summary_edge_ids,
    })
}

fn style_path_from_node_id(node_id: &str) -> Option<String> {
    let mut parts = node_id.splitn(3, '|');
    let _kind = parts.next()?;
    let path = parts.next()?;
    Some(path.to_string())
}

fn canonical_scc_node_id(node_id: &str) -> String {
    let mut parts = node_id.splitn(3, '|');
    let Some(kind) = parts.next() else {
        return node_id.to_string();
    };
    let Some(path) = parts.next() else {
        return node_id.to_string();
    };
    let Some(symbol) = parts.next() else {
        return node_id.to_string();
    };
    if kind == "styleModule" && symbol != "-" {
        return format!("styleSymbol|{path}|{symbol}");
    }
    node_id.to_string()
}

fn summary_edge_has_supported_target(status: &str) -> bool {
    matches!(
        status,
        "resolved" | "reachable" | "localResolved" | "importResolved" | "external"
    )
}

fn stable_omena_query_cross_file_summary_hash(
    edges: &[OmenaQueryCrossFileSummaryEdgeV0],
) -> String {
    let mut hash = 0xcbf29ce484222325u64;
    stable_omena_query_hash_piece(&mut hash, "omena-query.cross-file-summary");
    stable_omena_query_hash_piece(&mut hash, "0");
    for edge in edges {
        stable_omena_query_hash_piece(&mut hash, edge.edge_id.as_str());
        stable_omena_query_hash_piece(&mut hash, edge.status);
        stable_omena_query_hash_piece(&mut hash, edge.linear_provenance.semiring_identifier());
        let term_count = edge.linear_provenance.term_count.to_string();
        stable_omena_query_hash_piece(&mut hash, term_count.as_str());
        for term in &edge.linear_provenance.terms {
            let coefficient = term.coefficient.to_string();
            stable_omena_query_hash_piece(&mut hash, coefficient.as_str());
            stable_omena_query_hash_piece(&mut hash, term.label);
        }
    }
    format!("{hash:016x}")
}

fn stable_omena_query_hash_piece(hash: &mut u64, piece: &str) {
    for byte in piece.as_bytes() {
        *hash ^= u64::from(*byte);
        *hash = hash.wrapping_mul(0x100000001b3);
    }
    *hash ^= 0xff;
    *hash = hash.wrapping_mul(0x100000001b3);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn bitset_reachability_matches_btreeset_closure_order_and_cycles() {
        let adjacency = BTreeMap::from([
            (
                "module:root".to_string(),
                BTreeSet::from(["symbol:base".to_string(), "symbol:theme".to_string()]),
            ),
            (
                "symbol:base".to_string(),
                BTreeSet::from(["symbol:terminal".to_string()]),
            ),
            (
                "symbol:theme".to_string(),
                BTreeSet::from(["module:root".to_string(), "symbol:terminal".to_string()]),
            ),
        ]);

        let btreeset = collect_reachable_node_ids("module:root", &adjacency);
        let bitset = collect_reachable_node_ids_bitset("module:root", &adjacency);

        assert_eq!(
            bitset,
            vec![
                "module:root".to_string(),
                "symbol:base".to_string(),
                "symbol:terminal".to_string(),
                "symbol:theme".to_string(),
            ]
        );
        assert_eq!(bitset, btreeset);
    }

    #[test]
    fn reverse_dependency_delta_matches_from_scratch_index_across_edge_edits() {
        let sequences = reverse_dependency_edit_sequences();
        assert!(sequences.len() >= 12);
        assert!(
            sequences
                .iter()
                .any(|sequence| sequence_has_add_and_remove_for_same_origin(sequence)),
            "fixture corpus must include add/remove edits for an existing origin"
        );

        for sequence in sequences {
            let mut incremental = reverse_dependency_index_from_edges_v0(&[]);
            let mut patched_total = 0;
            for next_edges in &sequence {
                patched_total += apply_reverse_dependency_delta_v0(&mut incremental, next_edges);
            }
            let final_edges = sequence.last().map(Vec::as_slice).unwrap_or(&[]);
            let from_scratch = reverse_dependency_index_from_edges_v0(final_edges);

            assert_eq!(incremental, from_scratch);
            assert_eq!(
                reverse_dependency_index_fingerprint(&incremental),
                reverse_dependency_index_fingerprint(&from_scratch)
            );
            assert!(patched_total > 0);
            assert_eq!(
                apply_reverse_dependency_delta_v0(&mut incremental, final_edges),
                0,
                "unchanged edge groups must not be patched"
            );
        }
    }

    #[test]
    fn reverse_dependency_closure_keeps_transitive_source_dependents() {
        let edges = vec![
            fixture_edge(
                "style",
                "/workspace/src/Mid.module.scss",
                "style",
                "/workspace/src/Base.module.scss",
            ),
            fixture_edge(
                "source",
                "/workspace/src/App.tsx",
                "style",
                "/workspace/src/Mid.module.scss",
            ),
            fixture_edge(
                "source",
                "/workspace/src/Other.tsx",
                "style",
                "/workspace/src/Other.module.scss",
            ),
        ];
        let index = reverse_dependency_index_from_edges_v0(edges.as_slice());
        let seeds = BTreeSet::from(["/workspace/src/Base.module.scss".to_string()]);
        let closure = reverse_dependency_closure_v0(&index, &seeds);

        assert!(closure.contains("/workspace/src/Mid.module.scss"));
        assert!(closure.contains("/workspace/src/App.tsx"));
        assert!(!closure.contains("/workspace/src/Other.tsx"));
    }

    #[test]
    fn typed_vocabulary_keeps_raw_catalog_and_lossy_fold_visible() {
        assert_eq!(UNIFIED_HYPERGRAPH_EDGE_KIND_VARIANTS_V0.len(), 11);
        assert_eq!(CROSS_FILE_SUMMARY_RAW_EDGE_KIND_VARIANTS_V0.len(), 22);
        assert_eq!(CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0.len(), 22);
        assert_eq!(
            CROSS_FILE_SUMMARY_RAW_EDGE_KIND_VARIANTS_V0
                .iter()
                .map(|kind| kind.as_wire_label())
                .collect::<Vec<_>>(),
            CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0
        );
        assert!(
            CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0.contains(&"sourceSelectorPrefixReference")
        );

        let prefix_kind =
            parse_cross_file_summary_raw_edge_kind_v0("sourceSelectorPrefixReference");
        assert_eq!(
            prefix_kind.map(OmenaCrossFileSummaryRawEdgeKindV0::folded_edge_kind),
            Some(UnifiedHypergraphEdgeKindV0::ForeignReference)
        );
        assert_eq!(
            prefix_kind.map(OmenaCrossFileSummaryRawEdgeKindV0::folded_by_lossy_catch_all),
            Some(true)
        );
        assert!(parse_cross_file_summary_raw_edge_kind_v0("strayEdgeKind").is_none());
        assert!(parse_cross_file_summary_node_role_v0("runtime").is_none());
    }

    #[test]
    fn raw_edge_catalog_has_total_order_relevance() {
        let classified = CROSS_FILE_SUMMARY_RAW_EDGE_KIND_VARIANTS_V0
            .iter()
            .map(|kind| (kind.as_wire_label(), kind.order_relevance().as_wire_label()))
            .collect::<Vec<_>>();

        assert_eq!(
            classified.len(),
            CROSS_FILE_SUMMARY_RAW_EDGE_KIND_LABELS_V0.len()
        );
        assert!(classified.iter().all(|(kind, relevance)| {
            !kind.is_empty() && matches!(*relevance, "orderBearing" | "orderNeutral")
        }));
        assert_eq!(
            OmenaCrossFileSummaryRawEdgeKindV0::CssModulesImport.order_relevance(),
            EdgeOrderRelevanceV0::OrderBearing
        );
        assert_eq!(
            OmenaCrossFileSummaryRawEdgeKindV0::SourceSelectorReference.order_relevance(),
            EdgeOrderRelevanceV0::OrderNeutral
        );
    }

    #[test]
    fn summary_view_recomputes_raw_counts_from_edges() {
        let edges = vec![
            fixture_edge_with_kind(
                "cssModulesComposesImport",
                "style",
                "/workspace/src/Button.module.scss",
                "style",
                "/workspace/src/Base.module.scss",
            ),
            fixture_edge_with_kind(
                "sourceSelectorPrefixReference",
                "source",
                "/workspace/src/Button.tsx",
                "style",
                "/workspace/src/Button.module.scss",
            ),
        ];
        let summary = summary_from_edges(edges);
        let view = summarize_cross_file_summary_view_v0(&summary);
        assert!(view.summary_view_ready);
        assert_eq!(view.recomputed_edge_kind_counts, summary.edge_kind_counts);

        let mut perturbed = summary.clone();
        perturbed.edge_kind_counts = vec![OmenaQueryCrossFileSummaryEdgeKindCountV0 {
            edge_kind: "cssModulesComposesImport",
            count: 99,
        }];
        let perturbed_view = summarize_cross_file_summary_view_v0(&perturbed);
        assert!(!perturbed_view.edge_kind_counts_match_existing_field);
        assert_eq!(
            perturbed_view.recomputed_edge_kind_counts,
            summary.edge_kind_counts
        );

        let invalid = summary_from_edges(vec![fixture_edge_with_kind(
            "strayEdgeKind",
            "style",
            "/workspace/src/Button.module.scss",
            "style",
            "/workspace/src/Base.module.scss",
        )]);
        let invalid_view = summarize_cross_file_summary_view_v0(&invalid);
        assert!(!invalid_view.all_raw_edge_kinds_in_catalog);
        assert_eq!(invalid_view.invalid_raw_edge_kinds, vec!["strayEdgeKind"]);
    }

    #[test]
    fn graph_delta_records_typed_added_and_removed_edges() {
        let stable_edge = fixture_edge_with_kind(
            "sourceSelectorReference",
            "source",
            "/workspace/src/App.tsx",
            "style",
            "/workspace/src/App.module.scss",
        );
        let removed_edge = fixture_edge_with_kind(
            "cssModulesValueImport",
            "style",
            "/workspace/src/Tokens.module.scss",
            "style",
            "/workspace/src/LegacyTokens.module.scss",
        );
        let added_edge = fixture_edge_with_kind(
            "cssModulesComposesImport",
            "style",
            "/workspace/src/Button.module.scss",
            "style",
            "/workspace/src/Base.module.scss",
        );
        let before = summary_from_edges(vec![stable_edge.clone(), removed_edge.clone()]);
        let after = summary_from_edges(vec![stable_edge, added_edge.clone()]);
        let delta = summarize_cross_file_graph_delta_v0(&before, &after);

        assert!(delta.all_delta_edges_typed);
        assert_eq!(delta.added_edges.len(), 1);
        assert_eq!(delta.removed_edges.len(), 1);
        assert_eq!(delta.added_edges[0].edge_id, added_edge.edge_id);
        assert_eq!(
            delta.added_edges[0].raw_edge_kind,
            "cssModulesComposesImport"
        );
        assert_eq!(
            delta.added_edges[0].folded_edge_kind,
            UnifiedHypergraphEdgeKindV0::ComposesExternal
        );
        assert_eq!(delta.removed_edges[0].edge_id, removed_edge.edge_id);
    }

    fn reverse_dependency_edit_sequences() -> Vec<Vec<Vec<OmenaQueryCrossFileSummaryEdgeV0>>> {
        let empty = Vec::new();
        let source_a = fixture_edge(
            "source",
            "/workspace/src/App.tsx",
            "style",
            "/workspace/src/A.module.scss",
        );
        let source_b = fixture_edge(
            "source",
            "/workspace/src/App.tsx",
            "style",
            "/workspace/src/B.module.scss",
        );
        let other_b = fixture_edge(
            "source",
            "/workspace/src/Other.tsx",
            "style",
            "/workspace/src/B.module.scss",
        );
        let mid_a = fixture_edge(
            "style",
            "/workspace/src/Mid.module.scss",
            "style",
            "/workspace/src/A.module.scss",
        );
        let source_mid = fixture_edge(
            "source",
            "/workspace/src/App.tsx",
            "style",
            "/workspace/src/Mid.module.scss",
        );
        let leaf_mid = fixture_edge(
            "style",
            "/workspace/src/Leaf.module.scss",
            "style",
            "/workspace/src/Mid.module.scss",
        );
        let source_leaf = fixture_edge(
            "source",
            "/workspace/src/Deep.tsx",
            "style",
            "/workspace/src/Leaf.module.scss",
        );
        let value_a = fixture_edge(
            "style",
            "/workspace/src/Value.module.scss",
            "style",
            "/workspace/src/A.module.scss",
        );

        vec![
            vec![
                empty.clone(),
                vec![source_a.clone()],
                vec![source_a.clone(), other_b.clone()],
            ],
            vec![
                vec![source_a.clone()],
                vec![source_b.clone()],
                vec![source_b.clone(), other_b.clone()],
            ],
            vec![
                vec![source_a.clone(), other_b.clone()],
                vec![other_b.clone()],
                vec![source_a.clone(), other_b.clone()],
            ],
            vec![
                vec![mid_a.clone()],
                vec![mid_a.clone(), source_mid.clone()],
                vec![source_mid.clone()],
            ],
            vec![
                vec![mid_a.clone(), source_mid.clone()],
                vec![mid_a.clone(), source_mid.clone(), leaf_mid.clone()],
                vec![leaf_mid.clone(), source_leaf.clone()],
            ],
            vec![
                vec![source_leaf.clone()],
                vec![source_leaf.clone(), value_a.clone()],
                vec![value_a.clone()],
            ],
            vec![
                empty.clone(),
                vec![source_b.clone(), other_b.clone()],
                vec![source_a.clone(), other_b.clone()],
            ],
            vec![vec![value_a.clone()], empty.clone(), vec![value_a.clone()]],
            vec![
                vec![leaf_mid.clone()],
                vec![leaf_mid.clone(), source_leaf.clone()],
                vec![source_leaf.clone()],
            ],
            vec![
                vec![source_mid.clone(), source_leaf.clone()],
                vec![source_mid.clone()],
                vec![source_mid.clone(), source_leaf.clone()],
            ],
            vec![
                vec![mid_a.clone(), value_a.clone()],
                vec![value_a.clone()],
                vec![mid_a.clone(), value_a.clone()],
            ],
            vec![
                vec![source_a.clone()],
                vec![source_a.clone(), mid_a.clone()],
                vec![mid_a, source_mid],
            ],
        ]
    }

    fn sequence_has_add_and_remove_for_same_origin(
        sequence: &[Vec<OmenaQueryCrossFileSummaryEdgeV0>],
    ) -> bool {
        sequence.windows(3).any(|window| {
            let first = reverse_dependency_groups_by_from_path(window[0].as_slice());
            let second = reverse_dependency_groups_by_from_path(window[1].as_slice());
            let third = reverse_dependency_groups_by_from_path(window[2].as_slice());
            first.keys().any(|from_path| {
                let first_targets = first.get(from_path).cloned().unwrap_or_default();
                let second_targets = second.get(from_path).cloned().unwrap_or_default();
                let third_targets = third.get(from_path).cloned().unwrap_or_default();
                first_targets != second_targets
                    && first_targets == third_targets
                    && !first_targets.is_empty()
            })
        })
    }

    fn fixture_edge(
        from_kind: &'static str,
        from_path: &str,
        target_kind: &'static str,
        target_path: &str,
    ) -> OmenaQueryCrossFileSummaryEdgeV0 {
        fixture_edge_with_kind(
            "fixtureDependency",
            from_kind,
            from_path,
            target_kind,
            target_path,
        )
    }

    fn fixture_edge_with_kind(
        edge_kind: &'static str,
        from_kind: &'static str,
        from_path: &str,
        target_kind: &'static str,
        target_path: &str,
    ) -> OmenaQueryCrossFileSummaryEdgeV0 {
        OmenaQueryCrossFileSummaryEdgeV0 {
            edge_id: format!("{from_kind}:{from_path}->{target_kind}:{target_path}"),
            edge_kind,
            from_kind,
            from_path: from_path.to_string(),
            target_kind: Some(target_kind),
            target_path: Some(target_path.to_string()),
            source: None,
            owner_selector_name: None,
            local_name: None,
            remote_name: None,
            target_names: Vec::new(),
            status: "resolved",
            provenance: vec!["omena-query.cross-file-summary.fixture"],
            linear_provenance: OmenaCrossFileLinearProvenanceV0::from_static_labels(&[
                "omena-query.cross-file-summary.fixture",
            ]),
        }
    }

    fn summary_from_edges(
        edges: Vec<OmenaQueryCrossFileSummaryEdgeV0>,
    ) -> OmenaQueryCrossFileSummaryV0 {
        OmenaQueryCrossFileSummaryV0 {
            schema_version: "0",
            product: "omena-query.cross-file-summary",
            status: "fixtureSummary",
            summary_scope: "workspaceStyleAndSource",
            style_count: 1,
            summary_edge_count: edges.len(),
            edge_kind_counts: recompute_cross_file_summary_raw_edge_kind_counts_v0(
                edges.as_slice(),
            ),
            summary_hash: stable_omena_query_cross_file_summary_hash(edges.as_slice()),
            edges,
            capabilities: OmenaQueryCrossFileSummaryCapabilitiesV0 {
                css_modules_composes_edges_ready: true,
                css_modules_value_edges_ready: true,
                css_modules_icss_edges_ready: true,
                sass_module_edges_ready: true,
                style_design_token_reference_edges_ready: true,
                source_selector_reference_edges_ready: true,
                stable_summary_hash_ready: true,
                linear_provenance_ready: true,
                linear_provenance_round_trip_ready: true,
                linear_provenance_semiring_laws_hold: true,
            },
            next_priorities: Vec::new(),
        }
    }

    fn reverse_dependency_index_fingerprint(index: &ReverseDependencyIndexV0) -> String {
        let mut parts = Vec::new();
        for (target, dependents) in &index.rev {
            parts.push(format!(
                "rev:{target}={}",
                dependents.iter().cloned().collect::<Vec<_>>().join(",")
            ));
        }
        for (from_path, targets) in &index.edges_by_from {
            parts.push(format!(
                "from:{from_path}={}",
                targets.iter().cloned().collect::<Vec<_>>().join(",")
            ));
        }
        parts.join("|")
    }
}