Enum SerializableVMValue 

pub enum SerializableVMValue {
    Int(i64),
    Number(f64),
    Decimal(Decimal),
    String(String),
    Bool(bool),
    None,
    Some(Box<SerializableVMValue>),
    Unit,
    Timeframe(Timeframe),
    Duration(Duration),
    Time(DateTime<FixedOffset>),
    TimeSpan(i64),
    TimeReference(TimeReference),
    DateTimeExpr(DateTimeExpr),
    DataDateTimeRef(DataDateTimeRef),
    Array(Vec<SerializableVMValue>),
    Function(u16),
    TypeAnnotation(TypeAnnotation),
    TypeAnnotatedValue {
        type_name: String,
        value: Box<SerializableVMValue>,
    },
    Enum(EnumValueSnapshot),
    Closure {
        function_id: u32,
        type_id: u32,
        upvalues: Vec<SerializableVMValue>,
    },
    ModuleFunction(String),
    TypedObject {
        schema_id: u64,
        slot_data: Vec<SerializableVMValue>,
        heap_mask: u64,
    },
    Range {
        start: Option<Box<SerializableVMValue>>,
        end: Option<Box<SerializableVMValue>>,
        inclusive: bool,
    },
    Ok(Box<SerializableVMValue>),
    Err(Box<SerializableVMValue>),
    PrintResult(PrintableSnapshot),
    SimulationCall {
        name: String,
        params: HashMap<String, SerializableVMValue>,
    },
    FunctionRef {
        name: String,
        closure: Option<Box<SerializableVMValue>>,
    },
    DataReference {
        datetime: DateTime<FixedOffset>,
        id: String,
        timeframe: Timeframe,
    },
    Future(u64),
    DataTable(BlobRef),
    TypedTable {
        schema_id: u64,
        table: BlobRef,
    },
    RowView {
        schema_id: u64,
        table: BlobRef,
        row_idx: usize,
    },
    ColumnRef {
        schema_id: u64,
        table: BlobRef,
        col_id: u32,
    },
    IndexedTable {
        schema_id: u64,
        table: BlobRef,
        index_col: u32,
    },
    TypedArray {
        element_kind: TypedArrayElementKind,
        blob: BlobRef,
        len: usize,
    },
    Matrix {
        blob: BlobRef,
        rows: u32,
        cols: u32,
    },
    HashMap {
        keys: Vec<SerializableVMValue>,
        values: Vec<SerializableVMValue>,
    },
    SidecarRef {
        sidecar_id: u32,
        blob_kind: BlobKind,
        original_hash: HashDigest,
        meta_a: u32,
        meta_b: u32,
    },
    HashSet {
        keys: Vec<String>,
    },
    IteratorOpaque,
    ResultData {
        is_ok: bool,
        payload: Box<SerializableVMValue>,
    },
    OptionData {
        is_some: bool,
        payload: Option<Box<SerializableVMValue>>,
    },
    DequeOpaque {
        len: usize,
    },
    ChannelOpaque {
        closed: bool,
        len: usize,
    },
    PriorityQueueHeap {
        heap: Vec<i64>,
    },
    ReferenceOpaque,
    FilterExprOpaque,
    SharedCellOpaque,
    MutexOpaque {
        has_value: bool,
    },
    AtomicI64 {
        value: i64,
    },
    LazyOpaque {
        is_initialized: bool,
    },
    Char(char),
    BigInt(i64),
}

Variants

Int(i64)

Number(f64)

Decimal(Decimal)

String(String)

Bool(bool)

None

Some(Box<SerializableVMValue>)

Unit

Timeframe(Timeframe)

Duration(Duration)

Time(DateTime<FixedOffset>)

TimeSpan(i64)

TimeReference(TimeReference)

DateTimeExpr(DateTimeExpr)

DataDateTimeRef(DataDateTimeRef)

Array(Vec<SerializableVMValue>)

Function(u16)

TypeAnnotation(TypeAnnotation)

TypeAnnotatedValue

Fields

type_name: String

value: Box<SerializableVMValue>

Enum(EnumValueSnapshot)

Closure

A closure value carrying the function body id, its capture signature id, and the raw capture payloads.

Track A.2A: function_id is widened to u32 (from u16) to match the raw TypedClosureHeader field width, and a new type_id: u32 carries the ClosureTypeId needed to re-resolve the ClosureLayout side-table on the receiver. Deserialization hard- errors when no layout is available — no legacy HeapValue::Closure fallback exists per the v2 closure closeout directive.

Fields

function_id: u32

type_id: u32

upvalues: Vec<SerializableVMValue>

ModuleFunction(String)

TypedObject

Fields

schema_id: u64

slot_data: Vec<SerializableVMValue>

Serialized slots: each slot is 8 bytes (raw bits for simple, serialized heap values for heap slots)

heap_mask: u64

Range

Fields

start: Option<Box<SerializableVMValue>>

end: Option<Box<SerializableVMValue>>

inclusive: bool

Ok(Box<SerializableVMValue>)

Err(Box<SerializableVMValue>)

PrintResult(PrintableSnapshot)

SimulationCall

Fields

name: String

params: HashMap<String, SerializableVMValue>

FunctionRef

Fields

name: String

closure: Option<Box<SerializableVMValue>>

DataReference

Fields

datetime: DateTime<FixedOffset>

id: String

timeframe: Timeframe

Future(u64)

DataTable(BlobRef)

TypedTable

Fields

schema_id: u64

table: BlobRef

RowView

Fields

schema_id: u64

table: BlobRef

row_idx: usize

ColumnRef

Fields

schema_id: u64

table: BlobRef

col_id: u32

IndexedTable

Fields

schema_id: u64

table: BlobRef

index_col: u32

TypedArray

Binary-serialized typed array (raw bytes via BlobRef).

Fields

element_kind: TypedArrayElementKind

blob: BlobRef

len: usize

Matrix

Binary-serialized matrix (raw f64 bytes, row-major).

Fields

blob: BlobRef

rows: u32

cols: u32

HashMap

Dedicated HashMap variant preserving type identity.

Fields

keys: Vec<SerializableVMValue>

values: Vec<SerializableVMValue>

SidecarRef

Placeholder for sidecar-split large blobs (Phase 3B). Metadata fields preserve TypedArray len and Matrix rows/cols so reassembly can reconstruct the exact original variant.

Fields

sidecar_id: u32

blob_kind: BlobKind

original_hash: HashDigest

meta_a: u32

For TypedArray: element count. For Matrix: row count. Otherwise 0.

meta_b: u32

For Matrix: column count. Otherwise 0.

HashSet

HeapKind::HashSet — string-keyed insertion-ordered set (Wave 13). Round-trips the key array verbatim (per ADR-006 §2.7.15 string- only keyspace).

Fields

keys: Vec<String>

IteratorOpaque

HeapKind::Iterator — lazy iterator carrier (W13 §2.7.16). Iterator state carries (a) a closure-self share for transform closures and (b) source-buffer references; serializing the graph requires walking the closure capture set, which re- introduces the Arc generic serializer shape §2.7.5.1 forbids. Stored opaquely; resume surfaces an error citing the W17-snapshot-iterator follow-up.

ResultData

HeapKind::Result — typed-Arc Result<T,E> carrier (Wave 14 §2.7.17). Ok / Err arms already exist for the pre-bulldozer scalar-payload form; this arm wraps a KindedSlot-payloaded ResultData per the post-§2.7.17 typed-Arc shape: the discriminator (is_ok) plus the inner serializable payload.

Fields

is_ok: bool

payload: Box<SerializableVMValue>

OptionData

HeapKind::Option — typed-Arc Option carrier (Wave 14 §2.7.17). Mirror of ResultData: the discriminator (is_some) plus the inner payload (or None sentinel when is_some == false).

Fields

is_some: bool

payload: Option<Box<SerializableVMValue>>

DequeOpaque

HeapKind::Deque — heterogeneous-element double-ended queue (Wave 15 §2.7.19). The element-payload storage is Arc<HeapValue> per the ADR-005 §1 single-discriminator shape; the items array is round-trippable as Vec<SerializableVMValue> once each element is projected through slot_to_serializable. Opaque at landing — per-element projection over an arbitrary Arc<HeapValue> walks the same generic-serializer shape §2.7.5.1 forbids; the per-element kinded path lands when the Deque method-tier wires its KindedSlot return-shape.

Fields

len: usize

ChannelOpaque

HeapKind::Channel — concurrency-primitive carrier (Wave 15 §2.7.20). The inner queue holds KindedSlot payloads of arbitrary kinds; same per-element-projection blocker as DequeOpaque. Closed-flag round-trips; queue contents land in the W17-snapshot-channel-queue follow-up.

Fields

closed: bool

len: usize

PriorityQueueHeap

HeapKind::PriorityQueue — i64-priority min-heap (Wave 15 §2.7.18). i64-priority-only storage means full payload round-trip — the heap-ordered i64 vec encodes losslessly.

Fields

heap: Vec<i64>

ReferenceOpaque

HeapKind::Reference — &expr / &mut expr reference handle (Wave 8). The reference’s target lives inside the same VM’s heap; round-tripping requires tracking target identity across snapshot boundaries which is unspecified by ADR-006 §2.7. The W17-snapshot-references follow-up answers the identity question.

FilterExprOpaque

HeapKind::FilterExpr — query-DSL AST tree (Wave-γ §2.7.9). Carries Arc<FilterNode> whose And/Or/Not branches recurse into other FilterExpr shares — round-tripping requires a dedicated AST serializer per the §2.7.9 pure-discriminator shape. Opaque at landing; the W17-snapshot-filter-expr follow-up lands the tree serializer.

SharedCellOpaque

HeapKind::SharedCell — binding-storage interior-mutability carrier (Wave 8 §2.7.8). Carries the parallel-kind track and reaches into the cell payload’s HeapKind dispatch; same per- element-projection blocker as Deque/Channel. Round-tripping also bumps into the binding-identity question (two var x bindings that share a cell observe each other’s mutations, so cell identity must survive the snapshot).

MutexOpaque

HeapKind::Mutex — single-typed-payload exclusion cell (Wave 2.5 §2.7.25). Inner Option<KindedSlot> payload of arbitrary kind; round-trip requires per-kind projection. The MutexEmpty discriminator distinguishes “no inner payload” (transient post-take) from “payload present, opaque on landing”.

Fields

has_value: bool

AtomicI64

HeapKind::Atomic — atomic i64 cell (Wave 2.5 §2.7.25). Full payload round-trip — AtomicI64::load(SeqCst) reads the value, AtomicI64::new(value) restores. Memory ordering is SeqCst per the §2.7.25 ruling.

Fields

value: i64

LazyOpaque

HeapKind::Lazy — initialize-once cell (Wave 2.5 §2.7.25). Carries an initializer-closure KindedSlot (kind Ptr(HeapKind::Closure)) and a cached-value slot. Both halves land opaque pending the W17-snapshot-closure follow-up which also blocks SerializableVMValue::Closure deep round-trip (the existing Closure arm carries function_id + type_id + upvalues as Vec<SerializableVMValue> — restoration requires the ClosureLayout side-table on the receiver, which is itself part of the snapshot’s program payload).

Fields

is_initialized: bool

Char(char)

HeapKind::Char — single Unicode scalar value (Wave 12 §2.7.13). Full payload round-trip — char already serializes via serde.

BigInt(i64)

HeapKind::BigInt — arbitrary-precision int (currently Arc<i64> per the Phase-2 deletion of the full bigint impl). Round-trips as i64; a future typed-payload BigInt rebuild updates the wire format.

Trait Implementations

impl Clone for SerializableVMValue

fn clone(&self) -> SerializableVMValue

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SerializableVMValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SerializableVMValue

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for SerializableVMValue

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

where __S: Serializer,

Serialize this value into the given Serde serializer.