Struct LogicalSignal 

pub struct LogicalSignal {
    pub signal_id: SignalId,
    pub source: Option<SignalSourceKind>,
    pub target: SignalTarget,
    pub urgency: Option<SignalUrgency>,
    pub payload: BoundedJson,
    pub source_timestamp_ms: Option<WireU64>,
    pub dedupe_key: Option<String>,
    pub escalate_after_ms: Option<WireU64>,
}

Fields

signal_id: SignalId

source: Option<SignalSourceKind>

target: SignalTarget

urgency: Option<SignalUrgency>

payload: BoundedJson

source_timestamp_ms: Option<WireU64>

Metadata only. TTL, deadlines and admission all use the envelope’s accepted time.

dedupe_key: Option<String>

escalate_after_ms: Option<WireU64>

How long this signal may wait before its urgency is raised one tier — a duration, not an instant.

A duration is the only shape that can be a canonical input. The deadline it implies is anchored to the envelope’s accepted time, which the kernel already owns, so a redelivery of the same bytes anchors identically; an absolute deadline_ms would be a second host clock on the wire (DEC-2, §11.2) and would make the same intent decode to a different deadline on every retry.

Inert unless signal_policy.deadline_escalation is on — that switch is the operation’s statement that it wants waiting to change priority at all. Some(0) is a legitimate value: escalate on admission.

Implementations

impl LogicalSignal

pub fn new(signal_id: SignalId) -> Self

pub fn effective_urgency(&self, escalation_enabled: bool) -> SignalUrgency

The urgency this delivery reaches at admission, once a due escalate_after_ms is applied.

The kernel has to know this before the router moves: the one effect a delivery can publish is PreemptTasks, and DEC-8 says an undeclared effect is refused with nothing mutated. Reading the wire urgency alone would let an escalated-to-critical signal reach the router and only then discover the host cannot stop its children.

Trait Implementations

impl Clone for LogicalSignal

fn clone(&self) -> LogicalSignal

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LogicalSignal

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LogicalSignal

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LogicalSignal

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for LogicalSignal

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LogicalSignal