Struct Compiler 

pub struct Compiler { /* private fields */ }

Turns a Blueprint into a CompiledBlueprint by resolving every AgentDef against a SpawnerRegistry. One-shot: build a fresh Compiler per compile() call (or reuse it — it holds no per-compile state).

Implementations

impl Compiler

pub fn new(registry: SpawnerRegistry) -> Self

Build a Compiler around the given SpawnerRegistry, with no default spawner (unresolved flow refs are an error unless with_default is chained on).

pub fn with_default(self, sp: Arc<dyn SpawnerAdapter>) -> Self

Set a default spawner — used for flow refs (and unregistered AgentKinds under non-strict strategy) that don’t resolve against any AgentDef/SpawnerRegistry entry.

pub fn compile(&self, bp: &Blueprint) -> Result<CompiledBlueprint, CompileError>

Resolve every Blueprint.agents entry through the registry, validate operator_refs and flow refs per Blueprint.strategy, and return the routing table alongside the untouched flow and metadata.

pub fn compile_bound( &self, bp: &Blueprint, bound_agents: &[BoundAgent], ) -> Result<CompiledBlueprint, CompileError>

Compile with an already-resolved immutable binding snapshot. Resume paths use this entry point so a mutable Blueprint registry cannot silently change the Runner, prompt, contract, or static context policy between the original Run and its continuation.

pub fn compile_bound_pinned( &self, bp: &Blueprint, bound_agents: &[BoundAgent], operator_pin: Option<&str>, ) -> Result<CompiledBlueprint, CompileError>

Self::compile_bound plus a launch-scoped Operator session pin.

operator_pin is the session id (S-<hex>) this launch is bound to. When Some, every kind = Operator agent is compiled against that session instead of whichever session currently holds the agent’s spec.operator_ref role — the Blueprint keeps naming the logical role, and which session it means becomes a launch-time fact. The pin travels as a compile-synthesized build hint (same mechanism as the Subprocess template hint, see [resolve_subprocess_template_hint]); spec.operator_ref itself is never rewritten, so design-time validation and the OperatorDef.kind cascade keep reading the declared role.

None reproduces Self::compile_bound byte-for-byte.