Enum StrategyTag 

pub enum StrategyTag {
    UserHint,
    Exact,
    ExactSuffix,
    EdgeLabel,
    Alias,
    TokenSimilarity,
    DescriptionSimilarity,
    TypeSignature,
    WrapUnwrap,
    Coerce,
    Neighborhood,
    WlRefinement,
    Structural,
    Llm,
}

Tag identifying which strategy produced an anchor.

Variants

UserHint

User-supplied correspondence.

Exact

Kind-compatible name equality.

ExactSuffix

Kind-compatible terminal dot-segment equality. Recovers anchors for namespaced identifiers that share the same local prop or field name under disjoint prefixes.

EdgeLabel

Same-label same-kind edge on each side with compatible child vertex kinds. Catches pairs of children reached via labeled edges whose parents have disjoint identifiers.

Alias

Name match modulo alias dictionary + casing variants.

TokenSimilarity

Token-bag Jaccard + character-n-gram cosine above threshold.

DescriptionSimilarity

Token similarity of vertex descriptions (constraint sort description) above threshold. Only fires on schemas whose vertices carry description annotations.

TypeSignature

Matching sort carrier shapes (edge-kind signatures + cardinality).

WrapUnwrap

Wrap/unwrap detection between record shapes.

Coerce

Sort-coercion via a registered witness lens (Iso, Retraction, or Projection). Distinct from StrategyTag::TypeSignature so that conflict resolution ranks same-kind signatures above cross-kind bridges.

Neighborhood

Neighborhood propagation: child-pair scoring seeded from an already-aligned parent pair via edge-label similarity, edge-kind equality, kind-and-constraints compatibility, and degree overlap.

WlRefinement

Weisfeiler-Leman color refinement: structural signatures from iterated neighborhood hashing. Emits anchors for singleton color classes on both sides.

Structural

Pure degree-and-kind-signature matching (last resort).

Llm

LM-proposed alignment supplied by an external caller.

Implementations

impl StrategyTag

pub const fn priority(self) -> u8

Priority ordering over strategies. Higher is better.

The numbers are spaced rather than consecutive so a new strategy can be slotted between two existing ones without renumbering the table, and only their order is read: StrategyTag::rank is the position in that order, and the band arithmetic goes through the rank.

The table is uncalibrated. It encodes a judgement about which kind of evidence is stronger, not a measurement, and it has never been validated against labelled data.

pub const fn rank(self) -> u32

Position in descending priority order, from 0 for the strongest tag to 13 for the weakest.

This is the index into PRIORITY_ORDER, and it is what the band arithmetic reads: the bands must partition [0, 1] exactly, which a spaced priority table cannot do and a dense rank can.

pub fn band(self) -> (f64, f64)

The closed interval of aggregated evidence this tag can occupy, as (lo, hi).

The 14 tags cut [0, 1] into 14 bands of width 1/14 in descending priority order, and their union is the whole interval. An anchor’s confidence, capped by its provenance, positions it within its band and never outside it, which is what makes the priority ordering dominate confidence rather than merely break ties under it.

The bands meet, they do not overlap

Both endpoints are attainable. A tag reaches its hi at capped confidence 1, and reaches its lo at capped confidence 0, so each hi is bit-identical to the lo of the band above it: all 13 adjacent boundaries coincide exactly. The bands are therefore closed intervals that meet at their endpoints rather than half-open intervals that are disjoint.

Nothing about the ordering is lost by that, because no band’s interior is reachable from another tag: priority dominance holds as ≥, and a higher-priority anchor is never scored below a lower-priority one. What is lost is strictness at the seam. A strongest possible claim by one tag and a weakest possible claim by the tag above it aggregate to the same number, so the max within a family selects a tie rather than the higher-priority member. That case is reachable and not exotic: adjust_anchors_by_required_sets clamps to exactly 0 and 1, which is precisely where the seam is.

pub fn ceiling(self) -> f64

The most aggregated evidence an anchor with this tag can ever carry, which is the top of its StrategyTag::band.

This is the quantity priority dominance is stated over: for tags a and b with a.priority() > b.priority(), every a anchor scores at least b.ceiling(), whatever the two confidences are.

pub const fn family(self) -> Family

Which input this tag’s anchors are read from.

Family::of is the function the aggregation actually uses: it agrees with this one except on StrategyTag::Alias, whose two emission branches read two different inputs and are told apart by the anchor’s Anchor::provenance. This method reports the family of the leaf branch, which is the one the tag is named for.

One family per tag, and why two candidates for a split did not get one

The partition is total and each tag lands in exactly one family, which is what makes the fixed-arity mean well defined. Two tags read inputs that arguably straddle a family boundary, and both are filed whole:

• StrategyTag::Neighborhood is seeded from an already-aligned parent, so the identifier and edge-label evidence that produced the seed is already counted in those families. Filing it under Family::Structure is what stops it being counted twice.
• StrategyTag::WrapUnwrap scores a correlated group of fields by how well their labels cover one another, so its confidence is entirely a label-coverage measure and Family::EdgeLabel is where it belongs. It selects a parent pair, which is why an identifier reading is tempting, but nothing about the parents’ own identifiers enters the number.

Splitting either would need a provenance that tells the branches apart, as Alias has. Both stamp a single provenance unconditionally, so Family::of could not act on a split even if one were wanted.

Trait Implementations

impl Clone for StrategyTag

fn clone(&self) -> StrategyTag

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for StrategyTag

impl Debug for StrategyTag

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StrategyTag

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for StrategyTag

impl Hash for StrategyTag

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for StrategyTag

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for StrategyTag

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for StrategyTag