Enum SetDepsError 

pub enum SetDepsError {
    SelfDependency {
        n: NodeId,
    },
    WouldCreateCycle {
        n: NodeId,
        added_dep: NodeId,
        path: Vec<NodeId>,
    },
    UnknownNode(NodeId),
    NotComputeNode(NodeId),
    TerminalNode {
        n: NodeId,
    },
    TerminalDep {
        n: NodeId,
        dep: NodeId,
    },
    ReentrantOnFiringNode {
        n: NodeId,
    },
    PartitionMigrationDuringFire {
        n: NodeId,
        firing: NodeId,
    },
}

Errors returnable by Core::set_deps.

Per ~/src/graphrefly-ts/docs/research/rewire-design-notes.md and the Phase 13.8 Q1 lock:

• SelfDependency — n in newDeps (self-loops are pathological without explicit fixed-point semantics, which GraphReFly does not provide).
• WouldCreateCycle { path } — adding the new edge would create a cycle. The path field reports the offending dep chain for debuggability.
• UnknownNode / NotComputeNode — invariant violations from the caller.
• TerminalNode — n itself has emitted COMPLETE/ERROR; rewiring a terminal stream is a category error (terminal is one-shot at this layer; recovery is the resubscribable path on a fresh subscribe).
• TerminalDep — a newly-added dep is terminal AND not resubscribable. Resubscribable terminal deps are accepted because the subscribe path resets their lifecycle. Non-resubscribable terminal deps would deliver their already-emitted terminal directly to n’s dep_terminals slot, which is rarely intended.

Variants

SelfDependency

n appeared in new_deps (self-loop rejection).

Fields

n: NodeId

WouldCreateCycle

Adding the new dep would create a cycle. path is the chain [added_dep, ..., n] reachable via existing deps.

Fields

n: NodeId

added_dep: NodeId

path: Vec<NodeId>

UnknownNode(NodeId)

NotComputeNode(NodeId)

TerminalNode

n itself has terminated (COMPLETE / ERROR). Rewiring a terminal node is rejected — the stream has ended at this layer. To recover, mark the node resubscribable before terminate; a fresh subscribe will then reset its lifecycle.

Fields

n: NodeId

TerminalDep

A newly-added dep is terminal AND non-resubscribable. Per Phase 13.8 Q1, this is rejected; resubscribable terminal deps are allowed because the subscribe path resets them when activated. Already-present terminal deps are unaffected (their terminal status was accepted at the time they terminated).

Fields

n: NodeId

dep: NodeId

ReentrantOnFiringNode

n itself is currently mid-fire — a user fn for n re-entered Core via set_deps(n, ...) from inside n’s own invoke_fn / project_each / predicate_each / etc. Phase 1 of the dispatcher snapshotted dep_handles BEFORE the lock-released callback; the callback returning a tracked set indexed against THAT ordering would corrupt indices if the rewire re-orders deps mid-fire. Rejected to preserve the dynamic-tracked-indices invariant (D1).

Workaround: schedule the rewire from a different node’s fn (via Core::emit on a state node and observing the emit downstream), or perform the rewire after the wave completes (e.g. from a sink callback that is itself outside any fn-fire scope).

Slice F (2026-05-07) — A6.

Fields

n: NodeId

PartitionMigrationDuringFire

set_deps(n, ...) would trigger a partition migration (union or split in the per-subgraph union-find registry) that affects the partition of a node currently mid-fire on this thread. Distinct from Self::ReentrantOnFiringNode: that variant rejects set_deps(n, ...) where n itself is firing; this variant rejects set_deps(n, ...) on some OTHER node whose union/split shifts a firing node’s partition root mid-wave.

Why this matters: Y1’s wave engine holds an Arc<crate::subgraph::SubgraphLockBox> for the firing node’s partition for the wave’s duration. A union mid-wave swaps the box-identity for one of the two affected partitions; a split (Y1+ post-Phase-F) extracts a fresh box for the orphan side. Either way the held Arc would diverge from the registry’s current root for that partition, so the wave would lose serialization against the box’s true partition mid-flight.

Per SESSION-rust-port-d3-per-subgraph-parallelism.md Q3 = (a-strict): mid-wave migration is rejected at edge-mutation time. If a real consumer surfaces pressure to support mid-wave migration, lift via state-migration logic in a follow-up — but the v1 contract is “the partition a wave runs in cannot change shape mid-flight.”

n is the node whose set_deps was rejected; firing is the concretely-identified firing node whose partition would be migrated. Workaround: schedule the rewire outside the wave (e.g. emit a state-change that triggers set_deps from a sink callback running post-flush).

Slice Y1 (D3 / D091, 2026-05-08).

Fields

n: NodeId

firing: NodeId

Trait Implementations

impl Clone for SetDepsError

fn clone(&self) -> SetDepsError

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SetDepsError

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

Formats the value using the given formatter.

impl Display for SetDepsError

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

Formats the value using the given formatter.

impl Error for SetDepsError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl PartialEq for SetDepsError

fn eq(&self, other: &SetDepsError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for SetDepsError