Enum OutputPart 

pub enum OutputPart {
    Text(String),
    LineRef {
        container_idx: u32,
        line_idx: u16,
        slots: Vec<Value>,
        flags: LineFlags,
    },
    ValueRef(Value),
    Newline,
    Spring,
    Glue,
    Checkpoint,
    Tag(String),
    ElementAttach(String, String),
    ElementAttachEnd,
}

A part of accumulated output.

Output parts are structural references that resolve at read time against the current line tables and plural resolver. This enables locale-hot-swap: the same transcript can be re-rendered in different languages without re-executing the story.

PartialEq (issue #746): structural equality over the part’s own fields — used by the .brkt transcript round-trip law (brink-runtime/tests/law_transcript_roundtrip.rs) to assert decoded parts equal the originals. Every field type already implements it (Value’s hand-written impl, LineFlags’s derive).

Variants

Text(String)

Eagerly-resolved text. Not produced by the VM in production — used in tests and available for external transcript construction.

LineRef

Deferred line reference — resolved at read time against the current line tables and plural resolver.

Fields

container_idx: u32

line_idx: u16

slots: Vec<Value>

flags: LineFlags

ValueRef(Value)

Deferred value — stringified at read time.

Newline

Spring

Word break — renders as a single space between content parts.

Glue

Checkpoint

Marks the start of a captured region (string eval, tag, or function call).

Tag(String)

A tag associated with the current line of output.

ElementAttach(String, String)

One field of an attach = StructName convention handler’s return value, merged into the run currently open (issue #2108, docs/decision-log.md 2026-08-03 “The element output model: attachment is block-level metadata, delivery is per-line”). Embedded in the SAME append-only stream as Tag, rather than mutated on Flow directly, for the identical reason tags are: the output buffer defers a Newline’s commitment until later content proves no Glue reaches back over it (OutputBuffer::has_completed_line’s own doc), so by the time a line is finally drained the VM may already have stepped past several MORE opcodes (including a later run’s own ElementAttach/ElementAttachEnd). Reading a live, continuously- mutated Flow field at drain time would misattribute a LATER run’s data to an EARLIER, still-buffered line — embedding the merge as its own transcript entry, at the exact point it actually happened, avoids that entirely: [resolve_lines_annotated] rebuilds the correct per-line snapshot by walking the stream in order, the same way it already does for Tag.

Unlike Tag (which resets every line), this ACCUMULATES across multiple lines until a matching Self::ElementAttachEnd closes the run — ruling item 4/5: “the run IS the block” and “every line in it carries a copy.”

Not part of the persisted .brkt format (crate::transcript’s is_persisted) — like Self::Checkpoint, this is in-memory-only bookkeeping. Issue #2108 is explicitly scoped to “the in-memory half” (see its own tracked follow-up on save/resume); a transcript replayed from a .brkt file loses element attachment, matching that scope.

ElementAttachEnd

Closes the run an Self::ElementAttach opened, clearing the accumulated data so content after this point is never misattributed to a run it wasn’t part of. See Self::ElementAttach’s doc for why this lives in the transcript stream rather than on Flow, and for its non-persisted status.

Implementations

impl OutputPart

pub fn resolve( &self, program: &Program, line_tables: &[Vec<LineEntry>], resolver: Option<&dyn PluralResolver>, ) -> String

Resolve this output part to its text representation.

Text parts pass through. LineRef and ValueRef are resolved using the provided program, line tables, and plural resolver. Structural parts (Newline, Spring, Glue, Checkpoint, Tag) resolve to empty string — they are handled by the resolution pipeline.

Trait Implementations

impl Clone for OutputPart

fn clone(&self) -> OutputPart

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OutputPart

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

Formats the value using the given formatter.

impl PartialEq for OutputPart

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for OutputPart