Struct OpBuilder 

pub struct OpBuilder { /* private fields */ }

Shared op builder that distributes per-fiber builders.

Holds the activity’s source kernel (immutable, shared). Each executor fiber calls create_fiber_builder() to get its own FiberBuilder with private kernels — no locks, no contention on the hot path.

Implementations

impl OpBuilder

pub fn new(kernel: impl IntoSharedScope) -> Self

Create an OpBuilder from a kernel.

If the kernel has scope values (set via materialize_wiring_from_outer or directly via kernel.state().set_input), they are captured and propagated into every fiber’s kernels.

pub fn with_op_template_programs( self, programs: HashMap<String, Arc<PolydatProgram>>, ) -> Self

Install per-op-template kernel programs (SRD-13d Phase 9). The runner builds these from the scope tree’s cached_kernel slots for materialised op-template scopes and threads them here so wrappers can look up the right program when constructing their fixtures.

pub fn with_op_template_modules( self, modules: impl IntoIterator<Item = (String, Arc<OpTemplateModule>)>, ) -> Self

Instantiate per-op kernels from modules, the op-template scope modules of this phase. A module whose fiber-engine image disagrees with its program is left out, and its per-op kernels stay on the interpreter.

pub fn program_for_op(&self, name: &str) -> Arc<PolydatProgram>

Look up the kernel program for op name. Returns the per-op-template program if Phase 9 produced one for this op (i.e. materialised and bindings non-empty); otherwise returns the activity-wide program (the flatten path).

pub fn program(&self) -> Arc<PolydatProgram>

The activity-wide kernel program. Used by callers that need the source program shape (output names, manifest) without rebuilding a fresh kernel.

pub fn source_kernel(&self) -> &Arc<ScopeKernel>

The activity-wide source kernel — the Polydat context every op-template subscope is built upon. Adapters’ map_op implementations receive a kernel of this scope (see Self::canonical_kernel_for_op) as the parent argument, to bind their own canonical op-template kernel under (SRD-68 invariant I-3) or to retain when their op has no matter to add.

pub fn canonical_kernel_for_op(&self, op_name: &str) -> Arc<dyn Kernel>

Build the canonical op-template kernel for op_name — the Polydat context the dispenser owns and that per-fiber instances are materialised from (SRD-68 invariants I-3, I-4). Built once at dispenser construction time.

When op_name has a registered op-template program (phase bindings:, op-level bindings:, result: block — the matter assembled by the synthesis pipeline before the activity runs), the canonical is that program bound under source_kernel: instantiated from its module on the fiber engine when it has one, on the interpreter otherwise. Otherwise the canonical is a fork of the source kernel (its program, state and cells), which covers the flattened-op-template path (no per-op matter). Either way the adapter holds a kernel of any engine, whose program_id this builder recognizes.

pub fn create_fiber_builder(&self) -> FiberBuilder

Create a per-fiber builder. No locks, no sharing — the fiber owns its kernels exclusively. Scope values (per-iteration inputs from for_each / for_combinations / outer scope constants) are written into the main kernel’s inputs and remembered on the builder so reset_captures (called at stanza boundaries) can re-apply them — otherwise the blanket “reset all non-coord inputs” pass would clobber the iteration’s bound values.