Struct CycleWires 

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

WireSource over a per-fiber kernel handle that supports the full read surface — inputs, scope-init constants, AND computed outputs (which need a memoizing pull(&mut state, …) to fire the eval cone). Wraps a &mut ScopeKernel in a Mutex so the trait stays &self-callable (and Sync) while still permitting pull’s &mut requirement.

The Mutex is uncontended in practice: per-fiber-per-cycle dispatch is single-threaded by construction (the fiber owns the kernel slot exclusively for the duration of the cycle), so lock() always succeeds without spinning. Using Mutex rather than RefCell is a Sync requirement — async futures returned by OpDispenser::execute are Send, which means &ExecCtx (and through it &dyn WireSource) must be Send, which means dyn WireSource must be Sync.

Cells held here have the lifetime of one cycle dispatch — constructed at cycle entry from the firing dispenser’s per-fiber kernel slot, dropped after the dispenser returns.

Resolution order on get(name):

1. Output (memoizing pull through the eval cone).
2. Input slot (cell-aware read).
3. Scope-init constant.

None when the name doesn’t appear on this kernel — callers surface as an unresolved-bindpoint error per SRD-68 I-1.

The kernel may be on any engine. Names resolve on program, the interpreter program the kernel runs or was imaged from, whose indices it shares (fiber_engine::agrees); the kernel is then driven by index, so a compiled kernel pays no name lookup.

One value per name per cycle: an output read is kept for the life of these wires — one cycle’s dispatch — so an op that references a volatile binding twice renders one reading, although polydat re-evaluates a volatile step on every pull. A write, a reset, or an advance forgets every kept reading, so a read after one sees the kernel as it is now.

Implementations

impl<'a> CycleWires<'a>

pub fn new<K: ProgramKernel + ?Sized>(kernel: &'a mut K) -> Self

Wrap a scope kernel (or an interpreter kernel) for cycle-time reads; names resolve on its program. The caller holds the only outstanding borrow on the kernel for the duration of this cycle.

pub fn over(kernel: &'a mut dyn Kernel, program: Arc<PolydatProgram>) -> Self

Wrap a kernel of any engine whose inputs and outputs are program’s, in the same order.

pub fn of(kernel: &'a mut dyn Kernel) -> Self

Wrap a kernel of any engine, resolving names on the kernel itself. For a holder with no interpreter program in hand — an adapter probing a fork of its Arc<dyn Kernel> parent; a compiled kernel’s name lookup is a scan, so a per-cycle path uses Self::over.

Trait Implementations

impl<'a> WireSource for CycleWires<'a>

fn get(&self, name: &str) -> Option<Value>

Look up name in this kernel’s scope. Returns the current value (cloned, owned) or None when the name is not declared here. Callers do not retry against another kernel — a None is the resolution result, full stop.

fn names(&self) -> Box<dyn Iterator<Item = String> + '_>

Iterate declared names. Order is implementation-defined. Used by validators and diagnostic renderers.

fn reset(&self, name: &str) -> WriteOutcome

Reset the named input slot to its DECLARED initial value — the author’s identity element for that wire. The capture layer uses this for min/max-of-nothing (SRD-93-era fold totality): an empty measurement restores the wire to its declared unit rather than parking Value::None on a typed slot, where every downstream consumer would have to be None-aware. Default impl returns NoSlot (read-only sources have nothing to reset).

fn write(&self, name: &str, value: Value) -> WriteOutcome

Write value into the named input slot of this kernel. Returns WriteOutcome::Stored when the slot exists and the value was written, WriteOutcome::NoSlot when the kernel’s program has no input slot named name.

fn advance(&self, coord: u64)

Advance the underlying kernel state to coordinate coord and invalidate any memoized pulls so subsequent get calls produce values for this coord.