Struct ScopeKernel 

pub struct ScopeKernel<M> { /* private fields */ }

Typed wrapper around an Arc<PolydatKernel>.

Construction via this type goes through the SRD-67 protocol (subcontext_builder → finalize → spawn); direct construction from a PolydatKernel is pub(crate) for the Phase 1 internal bridge.

Implementations

impl<M> ScopeKernel<M>

pub fn shared_cells_in_scope(&self) -> Vec<SharedCellInScope>

Enumerate every shared cell visible at this scope. Delegates to PolydatKernel::shared_cells_in_scope — the carrier lives at the kernel layer so it survives any wrap/unwrap dance the activity layer does. The SharedCellInScope re-export is kept for callers in the SRD-67 builder; it’s a thin alias over the kernel layer’s SharedCellEntry.

pub fn name(&self) -> &ChildName

The structured name this kernel was spawned under (for child kernels) or its self-label (for root kernels).

pub fn site(&self) -> &SourceContext

Diagnostic site for this kernel’s construction.

pub fn lock_inner(&self) -> MutexGuard<'_, PolydatKernel>

Borrow the underlying PolydatKernel for read-only operations. The lock is released when the returned guard is dropped. Exposed for callers that drive the kernel directly (the builder’s finalize does, as do tests).

pub fn consumers(&self) -> Vec<RegisteredPullConsumer>

The pull consumers registered with this kernel. Used by the activity-side fixture adapter at seal time.

pub fn has_child(&self, name: &ChildName) -> bool

Whether name is recorded in this kernel’s named-child registry. Diagnostic; Phase 1 tests assert against this.

pub fn release_child(&self, name: &ChildName)

Drop the named child from this kernel’s registry. The child kernel itself is unaffected — only the registry entry. After release, the same name may be spawned again (typical for comprehension scopes that re-traverse per iteration). See SRD-67 §“Release semantics”.

pub fn subcontext_builder(self: Arc<Self>) -> SubcontextBuilder<M>

Begin construction of a child sub-context. Per SRD-67 §“Step 1 — Parent yields a builder”: the builder borrows an Arc of the parent, accumulates module matter, and produces a closed ScopeModule artifact at finalize.

pub fn spawn( self: &Arc<Self>, name: ChildName, artifact: ScopeModule<Child<M>>, ) -> Result<ScopeKernel<Child<M>>, ContractViolation>

Spawn a child kernel from a closed ScopeModule artifact. Per SRD-67 §“Step 4 — Parent spawns the child kernel”: this is the single chokepoint where every cross- binding is resolved.

The artifact arrives with Rule 1 (name closure) and Rule 2 (the shared write-through rewrite) already applied by SubcontextBuilder::finalize. Spawn materializes the closed program under this parent via PolydatKernel::materialize_subscope, whose materialize_wiring_from_outer (kernel/state.rs) does the live binding: attaches every parent-visible SharedCell to a matching child slot and forwards the rest as transit (Rule 2’s cell attach, SC8), value-copies or cell-attaches parent outputs into child externs (Rules 4 and 5), pulls every const output once after wiring so scope-init values see post-bind inputs (Rule 3), and freezes the scope coordinates. Per-cycle publication to the cells is Self::commit_write_throughs.

pub fn write_throughs(&self) -> &[WriteThroughBinding]

The Rule 2 write-through bindings carried by this kernel. Empty for the vast majority of kernels; populated only when the artifact’s finalize rewrote a child export to a parent shared cell write.

pub fn commit_write_throughs(&self) -> Result<(), String>

Per-cycle Rule 2 commit: pulls every write-through’s synthetic source output (__write_<X>) and stores its value through the corresponding child input slot for <X>. Because materialize_wiring_from_outer attached the parent’s SharedCell to that slot, the write propagates to the cell, where it becomes visible to the parent and to any sibling that shares the same cell.

No-op for kernels with no write-throughs.

TYPE-STABLE (scope_model.md §“Type stability”): each pending value passes the same boundary as crate::kernel::PolydatKernel::commit_write_throughs — matching types pass, catalog adapters heal (widening), and an unhealable mismatch is an Err at the write site.

Trait Implementations

impl<M> Debug for ScopeKernel<M>

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

Formats the value using the given formatter.