Struct SpliceState 

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

Splice state machine. Construct one per serialization pass with the body_plan slice (the dispatch plan’s body entries, post any doc-scope prefix the format consumes separately). The event walk calls advance_at_start on every StartAnnotation, advance_at_end on every EndAnnotation, and should_skip on every other event to decide whether the event falls inside a handler-owned subtree.

Implementations

impl<'a> SpliceState<'a>

pub fn new(plan: Option<&'a [RenderedNode]>) -> Self

New splice state. None means “no splicing” — every advance_at_start returns None and should_skip is always false, so the event walk emits its default rendering for every annotation. Some(plan) engages splicing against the supplied plan.

pub fn advance_at_start(&mut self, label: &str) -> Option<&str>

Call on every Event::StartAnnotation. Returns Some(rendered) if this annotation should be replaced by raw passthrough content (and enters skip-state so the body events emit nothing). Returns None to fall through to default rendering.

The cursor advances only when the next plan entry’s label matches the event’s label. An unregistered annotation arriving from the event walker (one without a schema, so no plan entry) leaves the cursor untouched — otherwise an unknown.label arriving before a registered acme.task would shift the cursor past the acme.task entry and the handler output would never splice.

Inside an active splice (skip-depth > 0), nested annotations with their own plan entries (the dispatch walker visits every annotation regardless of nesting) also advance the cursor so the post-splice cursor lands on the next outer entry.

Known limitation: renderable verbatim plan entries don’t correspond to a StartAnnotation event, so they aren’t advanced past by this method. The HTML and markdown event walkers don’t splice verbatim renders today either, so the limitation is confined to scenarios with both a renderable verbatim and a downstream registered annotation in the same document — a pattern not exercised by any current test.

pub fn should_skip(&self) -> bool

True if the current event arrives inside a handler-owned subtree and should be suppressed. Inspect Start/EndAnnotation even when this is true (they advance the depth counter); skip every other event.

pub fn advance_at_end(&mut self)

Call on every Event::EndAnnotation. Pops one level of skip-depth; the splice region ends when this reaches zero.