Struct RuleDef 

pub struct RuleDef {
    pub name: String,
    pub src_label: String,
    pub dst_label: String,
    pub predicate: Predicate,
    pub edge_type: String,
    pub weight_prop: Option<String>,
    pub max_edges: Option<u64>,
    pub approximate: bool,
    pub via_label: Option<String>,
    pub via_edge: Option<String>,
    pub via_dir: Option<Direction>,
    pub namespace: Option<String>,
}

Fields

name: String

src_label: String

dst_label: String

predicate: Predicate

edge_type: String

weight_prop: Option<String>

max_edges: Option<u64>

Per-rule provenance cap. None uses the engine default (1_000_000).

APPENDED field. bincode is positional, so this breaks decode of CreateRule WAL records and snapshot rule_defs written before this field existed. Pre-alpha no-migration ruling: accepted; no decoder compat. #[serde(default)] cannot help — bincode does not skip missing positional fields.

approximate: bool

Opt-in IVF-Flat approximate candidate selection.

false (default) → exact ScanAll path; semantics and derived edges are byte-identical to pre-T4 behaviour for all existing rules.

true → VectorClusters candidate path: k-means partitions the dst (and src) side at backfill/rebuild time; only members of the P nearest clusters are evaluated. Recall ≥ 0.90 quiesced, ≥ 0.85 on any crash-recovery state — not exact. Only valid when the predicate is VectorSimilar-rooted (VectorSimilar itself, or All whose first element is VectorSimilar); validate() rejects other combinations.

APPENDED field — same pre-alpha no-migration ruling as max_edges: WAL/snapshot records written before this field break positional bincode decode. Accepted for pre-1.0 builds; no decoder compat.

via_label: Option<String>

Optional intermediate hop. When set, src matches via_label via via_edge, then the existing predicate is evaluated between via node and dst (not src and dst). Derived edge is still src → dst with edge_type.

via_label and via_edge must both be Some or both None; validate() rejects a half-set combination. via_dir defaults to Out when the via fields are set (src → via); supply Some(In) to reverse the hop (src ← via). Semantics: for each src, expand via_edge one hop in via_dir to via-nodes carrying via_label; run predicate between via and dst; fire src → dst if any via satisfies; score = max over via; top-k still per src.

APPENDED field — same pre-alpha no-migration ruling as max_edges and approximate: WAL/snapshot records written before this field break positional bincode decode. Accepted for pre-1.0 builds; no decoder compat. #[serde(default)] covers JSON only.

via_edge: Option<String>

See via_label.

APPENDED field — same pre-alpha no-migration ruling as via_label.

via_dir: Option<Direction>

Direction to traverse via_edge from src. None treated as Out (src → via) at evaluation time. See via_label.

APPENDED field — same pre-alpha no-migration ruling as via_label.

namespace: Option<String>

The namespace this rule operates in.

None = global: the rule sees every node and its derived edges may cross namespaces. Some(ns) = scoped: it sees only nodes in ns — src, via and dst alike — so every edge it derives is intra-namespace by construction, with no pair-level check anywhere.

APPENDED field — same pre-alpha no-migration ruling as max_edges, approximate and via_dir (def.rs:33, :51): a rule bincoded before this field existed breaks positional decode. #[serde(default)] covers JSON only.

Implementations

impl RuleDef

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

pub fn sees_namespace(&self, namespace: &str) -> bool

Whether a node in namespace is visible to this rule.

Always true for a global rule, which is what keeps every rule written before namespaces existed on exactly the code path it had.

pub fn watched_fields(&self) -> BTreeSet<String>

Trait Implementations

impl Clone for RuleDef

fn clone(&self) -> RuleDef

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RuleDef

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RuleDef

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RuleDef

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RuleDef

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 RuleDef