Struct SystemRanker 

pub struct SystemRanker<'a> { /* private fields */ }

Personalized PageRank over the HETEROGENEOUS entity reference graph.

Nodes are every rankable entity (id-sorted for determinism): symbols, components, subsystems, services, flows, contracts, state, reactive, routes, topics, queues, stores, schemas and files. Edges are trusted relationships whose both endpoints are rankable entities and whose predicate normalizes to a reference kind; weights follow the spec formula. The global vector is computed once per epoch (Main caches the SystemRanker); task vectors personalize from TaskSeeds with a warm start blended from the global vector.

Implementations

impl<'a> SystemRanker<'a>

pub fn new(view: &'a TrustedGraphView<'a>) -> SystemRanker<'a>

Build the ranker from the trusted view. Deterministic; O(E) edges.

pub fn with_edge_adjust<F>( view: &'a TrustedGraphView<'a>, adjust: F, ) -> SystemRanker<'a>

where F: for<'x, 'y, 'z> Fn(&'x str, &'y str, &'z str, f64) -> Option<(String, f64)>,

Build the ranker with a per-edge weight adjust hook (DoD 23): adjust(subject, predicate, object, base) -> Option<(mode, value)>. Modes: add | multiply | replace | veto. None keeps the base weight. Veto (or non-positive/non-finite result) drops the edge. Deterministic for a deterministic hook; every other construction step is unchanged.

pub fn nodes(&self) -> &[String]

Rankable entity ids in rank order (index i in every vector maps to nodes()[i]; symbols are a subset).

pub fn symbols(&self) -> Vec<String>

Ranked symbol entity ids (subset of SystemRanker::nodes), id-sorted. Symbol-only callers use this to walk the symbol slice of the heterogeneous vectors.

pub fn index_of(&self, id: &str) -> Option<usize>

Node index for a rankable entity id, if it is in the universe.

pub fn in_degree(&self, id: &str) -> usize

Distinct referencing sources of a node id (0 when absent).

pub fn global_vector(&self) -> Vec<f64>

Precomputed global PageRank vector (architecturally seeded; see SystemRanker::global_personalization). Main caches the ranker per epoch and reads this.

pub fn project_to_symbols(&self, vector: &[f64]) -> Vec<(String, f64)>

Project the heterogeneous node scores to surface-relevant symbol scores: a symbol’s score = its own score + 0.4 × the sum of the scores of the entities it OWNS/REGISTERS/PUBLISHES/READS/WRITES/ PARTICIPATES_IN/HANDLES/DEFINES, with the total bonus capped at 0.5. This is how component/flow/contract/state importance reaches the surface — and, via the HANDLES/DEFINES projection, how a hot Route/Schema node (task seed or PPR) reaches its handler/definer symbol. Deterministic: nodes and projection edges are id-sorted.

Returns (symbol id, projected score) pairs, id-sorted.

pub fn task_vector(&self, seeds: &[TaskSeed]) -> Vec<f64>

Task-personalized PageRank vector. Seeds come from TaskSeeds whose id is a rankable entity id; the seed vector carries weight at each matched index. Warm start: 0.3 × global + 0.7 × normalized seeds. Unresolvable seed sets fall back to the global vector (never panic).