Crate cu29_logstream 

Transport-independent Copper log framing and continuous-stream recovery.

The crate owns bounded FEC, pacing, and autonomous recovery repetition above packet transports. The host driver consumes encoded records from existing semantic output workers; runtime ownership handoff stays outside this layer.

Re-exports

pub use structured::StructuredLogStream;

Modules

capture

Generated selective native codecs. Optional verification runs on output workers.

feedback

Optional advisory feedback. All accounting and adaptation run on stream workers. Sender and receiver must be built with matching feedback layouts.

structured

Static structured-log fan-out at the local encoder’s byte boundary.

telemetry

Bounded ground-side delivery to caller-owned telemetry consumers. Pull-based delivery after native archival, independent of UI processing.

twin

Ordered, bounded live replay, independent of archive writes and presentation loss.

Structs

ApplicationOutputSchema

ApplicationSchema

Minimal application schema required to interpret recovered CopperList slots.

CaptureArchive

Capture-aware native archive. Synthesized payloads never enter this writer. Native CopperList metadata retains both original and captured presence planes; StreamContinuity retains the reconstruction contract and source gaps.

ContinuousCopperListSink

Immediate, unpaced CopperList sink backed by continuous RLC. Generated applications use scheduled_sinks for bounded packet scheduling.

ContinuousDecoder

Stateful, bounded RFC 8681 decoder and ordered CopperList assembler.

ContinuousEncoder

Stateful RFC 8681 encoder for a continuous CopperList lane.

ContinuousRecoveryStats

Observed delivery and recovery behavior for one continuous stream.

ContinuousSenderConfig

Configuration for the continuous CopperList sender lane.

ContinuousSenderStats

Sender-side delivery counters. Transport backpressure is observable but never blocks.

CopperListGap

An inclusive range of unrecoverable CopperList identifiers.

CuTwin

Running Copper twin. The separately owned reader can be paused or dropped without affecting recording. stop() closes the archive and drains admitted replay; dropping the handle also stops and joins Copper’s workers.

CuTwinBuilder

Builder for a generated application’s live twin. Copper owns all worker, routing, archive, and recovery plumbing; callers supply a packet transport. Receiver bounds match the default 1200-byte-MTU, 64-symbol streaming profile. One handle accepts one sender session, with a fresh archive path.

CuTwinStatus

Receiver and reconstruction health, available even when the view is paused.

DecodedRecord

A verified semantic record borrowing its recovered payload.

DensityThreshold

An RFC 8681 coding-coefficient density threshold in the range 0..=15.

EncodingSymbolId

A wrapping RFC 8681 Encoding Symbol ID (ESI).

FiniteObjectDecoder

Bounded assembler for independently reorderable finite RaptorQ objects.

FiniteObjectEncoder

RaptorQ encoder for immutable framed semantic records.

FiniteObjectLimits

Receiver-local limits checked before any RaptorQ decoder is constructed.

FiniteObjectRecoveryStats

Observed finite-object receive behavior.

FiniteObjectSenderConfig

Sender policy for one finite-object lane.

LogStreamPlan

Link and codec policy after RON validation and MTU resolution.

LogStreamSenderConfig

Complete sender configuration for continuous CopperLists and recovery points.

NativeArchive

One application-typed archive per (session id, sender id). Pass all ordered router events for that sender to accept. The expected schema comes from P’s generated output specs, independently of the remote manifest. CaptureArchive applies the generated selective codec for a live twin. A write failure poisons the writer: do not retry a partially committed event.

OneWay

Static autonomous wiring. There is no feedback polling or capability discovery.

PacingConfig

Shared destination budget. Counts complete Copper packets, excluding carrier overhead.

ReceivedManifest

A decoded manifest bound to its verified, immutable wire record.

ReceivedStructuredLog

One original robot log entry, published only after native archival succeeds.

ReceiverLimits

Receiver-side bounds for one continuous stream.

ReceiverOccupancy

Current bounded receiver occupancy, exposed for monitoring and tests.

ReceiverRequirements

Continuous decoder geometry and record bounds carried by a session manifest. Receiver-local limits still cap admission; sender pacing and repair policy stay local.

RecoveredRecord

One fully assembled and digest-verified semantic record.

RecoveryPoint

A stream restart boundary binding a manifest and a task-state keyframe.

RecoveryPointSink

Immediate, unpaced sink emitting keyframes and their recovery points. Intended for codec tests and custom drivers. Generated applications use scheduled_sinks to share a destination budget.

RecoverySenderConfig

Finite-object recovery policy and the canonical manifest record repeated at every recovery point.

RecoverySenderStats

Sender counters for repeated manifests, keyframes, and recovery points.

ResolvedContinuousFec

ResolvedObjectFec

RlcConfig

The active parameters for an RLC encoder or decoder.

ScheduledCopperListSink

Encodes directly into a sender-owned buffer on the existing CL output worker.

ScheduledKeyFrameSink

Bounded keyframe encoding; capture objects are released before pacing begins.

ScheduledStructuredLogSink

A bounded destination for bytes produced by the local structured-log encoder. It does not own the sender thread: dropping the CL and keyframe sinks still drains and joins that worker, even while the global logger holds this sink.

SenderCore

A destination’s single packet scheduler and retained recovery state.

SenderMonitor

Final counters remain readable after both output sinks have been dropped.

SenderSnapshot

Live worker snapshot. Publication uses try_lock at 10 Hz, never on the RT path.

SenderStats

Counters distinguish queue shedding from carrier backpressure.

SeparateFeedback

Explicit feedback wiring for separate logical endpoints. The endpoints may be resource handles backed by one carrier; physical out-of-band links are optional.

SessionManifest

Control object carrying receiver requirements and application schema checks.

SessionRouter

Discovers sender identities and routes packets using the recovered manifest. Event payloads remain in receiver storage until the callback succeeds.

SessionRouterLimits

SessionRouterStats

StreamIdentity

Identity shared by one sender’s continuous stream.

WireHeader

Fixed-endian metadata repeated on every independently reorderable symbol.

WirePacket

Owned packet for callers that retain or edit payloads. Receiver parsing uses WirePacketRef to borrow the datagram instead.

WirePacketRef

Structurally validated packet view borrowing the transport’s receive buffer.

Enums

ContinuousReceiveEvent

Ordered output from a continuous receiver.

CuStreamRxError

Failure to receive one complete logstream packet.

CuStreamTxError

Failure to submit one complete logstream packet.

CuTwinRecordingState

Recording state is independent of reconstruction and display consumption.

Error

FecScheme

FecSymbolKind

Field

The finite field used for repair-symbol coefficients.

GapReason

Why a range of CopperLists can no longer be reconstructed exactly.

Lane

Independently scheduled transport lanes.

ReceiveError

Separates malformed stream input from a downstream consumer failure.

RecordKind

Semantic record families carried by the log stream.

ResolvedRlcField

SessionEvent

Session events borrow receiver storage during delivery. Use to_owned only when an application deliberately needs to retain encoded history.

Constants

DEFAULT_MAX_SYMBOL_SIZE

Maximum source-symbol storage used by generated runtime integration.

DEFAULT_MAX_WINDOW_SYMBOLS

Maximum RLC coding-window storage used by generated runtime integration.

PACKET_HEADER_LEN

Maximum packet header length, used to bound storage and the shared FEC symbol size. RaptorQ uses 51 bytes; RLC uses 32 for source packets and 36 for repair packets.

RECOVERY_REPEAT_INTERVAL

Autonomous repetition period, measured by the sender’s local RobotClock. Repetition is coalesced while the previous transmission is still pending.

Traits

CuFeedbackRx

Optional advisory receive direction. This logical interface may share the physical stream carrier. A shared endpoint must have one receive owner and route complete packet kinds; cloned competing readers cannot provide routing. Protocol decoding, capability negotiation, and feedback policy belong above it.

CuFeedbackTx

Optional advisory transmit direction; same atomic, bounded, complete-packet integrity contract as CuStreamTx. Acceptance guarantees neither delivery nor ordering. A raw byte stream needs a framing and integrity adapter.

CuStreamRx

Nonblocking reception of complete logstream packets.

CuStreamTx

One-way, fire-and-forget transmission of complete logstream packets.

Functions

decode_copperlist

Decodes one application-typed full or partial CopperList.

decode_keyframe

Decodes a complete keyframe payload and rejects trailing bytes.

decode_record

Validates and decodes one complete semantic record envelope.

decode_recovery_point

Decodes a complete recovery point payload and rejects trailing bytes.

encode_copperlist

Serializes the generated CopperList view selected by its application codec.

encode_copperlist_record_into

Serializes and frames one CopperList directly into reusable caller-owned storage.

encode_keyframe

Encodes a runtime keyframe as its canonical bincode semantic payload.

encode_keyframe_and_recovery_point

Creates the separately transportable keyframe and recovery point records.

encode_packet_into

Encodes one packet into caller-owned storage and returns its exact length.

encode_record

Frame and digest one semantic payload before FEC is applied.

encode_recovery_point

Encodes a recovery point as its canonical bincode semantic payload.

new_session_id

Creates a process-local session identity without adding configuration or environment inputs.

scheduled_feedback_sinks

Explicitly enable the advisory receive direction; the manifest must advertise it.

scheduled_sinks

Start one autonomous worker with an explicitly selected local RobotClock. A real carrier must use a running clock even when application time is mocked. Drops of both sinks stop repetition, then drain at most max_latency in local clock time. No application object, serialization, or wait is added to the RT path.

Type Aliases

CuTwinLogReader

Independent bounded log reader; a stalled reader never delays native recording.

CuTwinReader

Reader for a generated graph’s reconstructed frames and recording status.

DefaultContinuousCopperListSink

Concrete sender shape emitted by generated applications.

Result

SessionEventRef

A callback-scoped view; retaining it requires an explicit allocating to_owned call.