Struct OperatorVariantModel 

pub struct OperatorVariantModel {
    pub generator_id: NodeId,
    pub dimension: GenerationDimension,
    pub active_nodes: BTreeMap<String, BTreeSet<NodeId>>,
    pub variant_labels: BTreeMap<String, String>,
}

An operator-level variant model lowered from a single operator-level generator (Mechanism B’s PipelineDslStep::Generator): a GenerationDimension whose every choice carries an active_subsequence (the choice’s namespace key) — never param_overrides — paired with the EXACT set of namespaced node ids that choice activates.

The dimension is the search-space shape; active_nodes is the authoritative per-choice active set. Each entry is keyed by the choice’s active_subsequence (identical to the matching choice’s active_subsequence) and holds the node ids minted by namespace_generated_sequence for that choice — collected at the deterministic minting point, never by prefix-matching node id strings. enumerate_variants over dimension’s parent spec yields one VariantPlan per operator choice.

This model is produced by a NEW, opt-in compile entry point. It is NOT folded into CompiledPipelineDsl.generation / search_space_fingerprint, so the existing Mechanism B compilation (graph, OOF lanes, fingerprints) stays byte-identical.

Fields

generator_id: NodeId

The generator id this model lowers (the PipelineDslStep::Generator id).

dimension: GenerationDimension

The operator dimension: one active_subsequence-only choice per operator sub-sequence.

active_nodes: BTreeMap<String, BTreeSet<NodeId>>

active_subsequence (choice key) -> the exact namespaced node ids that choice activates.

variant_labels: BTreeMap<String, String>

active_subsequence (choice key) -> the choice’s variant_label: the cross-language content fingerprint (hex sha256) of that choice’s LOWERED operator sub-sequence (Phase 5). The host recomputes the SAME bytes from its own operator-choice config (via the public operator_variant_label, exposed through the dag-ml-py binding) to map a per-variant report back to the config, so the canonical form is a strict cross-language CONTRACT. Empty (default) for an operator model carrying no labels; otherwise it is a strict bijection with the choices’ active_subsequence, exactly parallel to active_nodes.

Implementations

impl OperatorVariantModel

pub fn validate(&self) -> Result<(), DagMlError>

Validate the operator dimension and its active-node-id sets.

Beyond GenerationDimension::validate, this enforces a STRICT BIJECTION between the choices and active_nodes: every choice is operator-only (an active_subsequence, no param_overrides); the choices’ active_subsequence values are unique; every choice has exactly one non-empty active_nodes entry keyed by its active_subsequence; and active_nodes carries no stray key that does not correspond to a choice.

pub fn generation_spec(&self) -> GenerationSpec

Build a single-dimension GenerationSpec (cartesian over the one operator dimension) so enumerate_variants yields one VariantPlan per operator choice.

The constraints are intentionally default() (empty): under ADR-17 Option A the operator dimension’s CHOICES are ALREADY the constraint-pruned survivor set — _mutex_/_requires_/ _exclude_ are applied during sequence-build (expand_or_generator_sequences / expand_cartesian_generator_sequences), so each surviving multi-operator sequence becomes one constraint-free choice. The model therefore stays a single, constraint-free dimension and the existing prune/score/refit path works unchanged.

Trait Implementations

impl Clone for OperatorVariantModel

fn clone(&self) -> OperatorVariantModel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for OperatorVariantModel

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OperatorVariantModel

fn deserialize<__D>( __deserializer: __D, ) -> Result<OperatorVariantModel, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OperatorVariantModel

fn eq(&self, other: &OperatorVariantModel) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OperatorVariantModel

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OperatorVariantModel