Struct StepNaming 

pub struct StepNaming { /* private fields */ }

GH #23 — the single addressing-space table for one Blueprint’s dispatched steps. See the module doc for the construction site and storage/accessor threading; this doc covers the resolution rules.

Canonical / alias resolution

For every distinct Step.ref appearing anywhere in the flow (Seq / Branch / Fanout / Loop / Try nesting all walked — see Self::from_blueprint):

• canonical = the dispatching agent’s AgentMeta.projection_name when declared, else the Step.ref itself (byte-identical to pre-GH-#23 behavior for undeclared Blueprints).
• aliases = {Step.ref} ∪ every out Path expr’s top-level segment seen across every occurrence of that ref in the flow ("$.plan" → "plan", "$.a.b" → "a"; a non-Path out contributes nothing — best-effort, mirroring blueprint::compiler’s existing static-walk convention of skipping what can’t be inspected structurally), minus any WEAK claim another step contests (below).

Strong and weak claims

Not every name a step could claim is claimed with the same strength:

• strong claim — the Step.ref, the declared projection_name, and an out that is exactly $.T (depth 1, so the step OWNS the whole T subtree).
• weak claim — the top segment T of an out writing UNDER it ($.T.x…, depth ≥ 2). The step owns a lane inside T, not T.

A weak claim registers only when no other step claims that name at all. The moment a second step claims it — strongly or weakly — every weak claim on the name is dropped (silently, at tracing::debug! level: a shared nesting root is ordinary Blueprint shape, not a defect). The name then resolves to whichever step claims it strongly, or to nothing when the contest was weak-vs-weak. That deliberate miss replaces the pre-existing behavior of handing out one arbitrary lane’s output under the shared root’s name.

Every strong claim (canonical + every strongly-claimed alias) is checked for cross-step collisions. A clash where either side declared projection_name is a hard StepNamingError (registration is rejected outright). A clash between two undeclared steps is a soft StepNamingWarning: the pre-GH-#23 union rule’s “data-plane wins” precedence is preserved by letting the step whose OWN ref equals the contested name own it in Self::resolve — an alias derived merely from another step’s out segment never displaces it.

The resulting boundaries:

Blueprint shape	result
$.r.a / $.r.b / … written by different steps (a shared nesting root)	"r" is nobody’s alias; no warning. Each lane is addressed by its own ref / projection_name
two steps whose out is the identical $.r	soft warning + data-plane priority (a genuine ambiguity)
ref: "r" on one step, $.r.x on another	the weak claim yields: no warning, resolve("r") is the "r" step
projection_name: "r" on one step, $.r.x on another	the weak claim yields: compiles (no hard error)
$.r.a written by exactly one step	"r" stays that step’s alias (unchanged)

Implementations

impl StepNaming

pub fn resolve(&self, name: &str) -> Option<&str>

Resolve name (canonical or alias) to its canonical name.

pub fn canonical_of_producer(&self, ref_name: &str) -> Option<&str>

Resolve a Step’s data-plane producer name (Step.ref / AgentDef.name) to its canonical name.

pub fn names(&self) -> impl Iterator<Item = &str>

Every canonical name this table declares (subtask-2/3 enumeration consumers, e.g. McpQueryAdapter::enumerate_steps).

pub fn entries(&self) -> impl Iterator<Item = &StepNameEntry>

Every full StepNameEntry (canonical + aliases) this table holds.

pub fn from_blueprint( bp: &Blueprint, ) -> Result<(StepNaming, Vec<StepNamingWarning>), StepNamingError>

Build the table from a Blueprint’s flow + agents — the sole construction site (see the module + struct docs). Returns the table plus any soft StepNamingWarnings (the caller decides how to log them, typically via tracing::warn!); a hard collision returns StepNamingError instead.

Trait Implementations

impl Clone for StepNaming

fn clone(&self) -> StepNaming

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StepNaming

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

Formats the value using the given formatter.

impl Default for StepNaming

fn default() -> StepNaming

Returns the “default value” for a type.