module.ae

// std.msgpack — MessagePack serialization and deserialization library (RFC 9562 equivalent / Portions copyright 3Hren/msgpack-rust).
// Import with: import std.msgpack
//
// Memory model
// ------------
// A MsgValue tree owns its string/binary payloads through a std.bytes
// buffer (s_bytes), NOT through a refcounted AetherString field. Storing
// an AetherString in a heap.new struct field leaks: heap.free(struct) frees
// only the struct, never the string, and manually releasing the field
// double-frees (the escape walker does not follow a string into a struct
// field). std.bytes is malloc-backed with an explicit bytes.free, which is
// leak-clean the same way the crypto modules' byte buffers are. So every
// str/bin/ext payload is an owned AetherBytes; free() reclaims it with
// bytes.free alongside the structs and lists. get_string / get_bin mint a
// fresh caller-owned AetherString from those bytes on demand (the caller
// releases that copy; the tree keeps its buffer). On unpack the cursor's
// read_slice already returns a freshly-owned AetherBytes, so the payload is
// adopted directly with no extra copy.

import std.bytes
import std.bytes.cursor
import std.string
import std.list
import std.heap
import std.mem

exports(
    nil_value, boolean, from_int, num, str, bin, arr, map, ext,
    get_type, get_bool, get_int, get_float, get_string, get_bin,
    array_size, array_get, array_add,
    map_size, map_get_key, map_get_value, map_get, map_set,
    free, pack, unpack,
    TYPE_NIL, TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STR, TYPE_BIN, TYPE_ARRAY, TYPE_MAP, TYPE_EXT
)

const TYPE_NIL = 0
const TYPE_BOOL = 1
const TYPE_INT = 2
const TYPE_FLOAT = 3
const TYPE_STR = 4
const TYPE_BIN = 5
const TYPE_ARRAY = 6
const TYPE_MAP = 7
const TYPE_EXT = 8

struct MsgValue {
    type_id: int
    b_val: bool
    i_val: long
    f_val: float
    s_bytes: ptr // owned AetherBytes for str/bin/ext payload (null if empty); freed in free()
    s_len: int // payload byte length
    ext_type: int
    arr_val: ptr // list pointer (*std.list.List)
    map_keys: ptr // list pointer (*std.list.List)
    map_values: ptr // list pointer (*std.list.List)
}

// Reconstitute an IEEE-754 single-precision float from its 32 raw bits and
// widen it to a double. Pure Aether over std.mem's double bit-cast — no C
// binding needed (double<->bits and float64<->bits are already in std.mem).
fn float32_from_bits(val: long) -> float {
    sign = (val >> 31) & 1
    exp = (val >> 23) & 255
    frac = val & 8388607

    if exp == 0 {
        if frac == 0 {
            if sign == 1 { return -0.0 }
            return 0.0
        }
        // subnormal single -> normalized double
        while (frac & 8388608) == 0 {
            frac = frac << 1
            exp = exp - 1
        }
        exp = exp + 1
        frac = frac & 8388607
        real_exp = exp - 127 + 1023
        dbits = ((sign as long) << 63) | ((real_exp as long) << 52) | ((frac as long) << 29)
        return mem.float_from_bits(dbits)
    }
    if exp == 255 {
        if frac == 0 {
            if sign == 1 { return mem.float_from_bits(-4503599627370496 as long) }
            return mem.float_from_bits(9218868437227405312 as long)
        }
        return mem.float_from_bits(9221120237041090560 as long)
    }
    real_exp = exp - 127 + 1023
    dbits = ((sign as long) << 63) | ((real_exp as long) << 52) | ((frac as long) << 29)
    return mem.float_from_bits(dbits)
}

// ---- Internal payload helpers ----

// Store `len` bytes of `src` (an AetherString) as a value's owned payload.
// A zero-length payload records s_bytes = null / s_len = 0 (no allocation).
fn set_payload(v: *MsgValue, src: string, len: int) {
    if len <= 0 {
        v.s_bytes = null
        v.s_len = 0
        return
    }
    let b = bytes.new(len)
    bytes.copy_from_string(b, 0, src, len)
    v.s_bytes = b
    v.s_len = len
}

// Materialize a fresh caller-owned AetherString from a value's payload.
// Non-consuming: the value keeps owning its AetherBytes buffer.
fn payload_string(v: *MsgValue) -> string {
    if v.s_bytes == null || v.s_len <= 0 {
        return ""
    }
    return bytes.to_string(v.s_bytes, v.s_len)
}

// ---- Builders ----

nil_value() -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_NIL
    return v as ptr
}

boolean(val: bool) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_BOOL
    v.b_val = val
    return v as ptr
}

from_int(val: long) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_INT
    v.i_val = val
    return v as ptr
}

num(val: float) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_FLOAT
    v.f_val = val
    return v as ptr
}

str(val: string) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_STR
    set_payload(v as *MsgValue, val, string.length(val))
    return v as ptr
}

bin(val: string) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_BIN
    set_payload(v as *MsgValue, val, string.length(val))
    return v as ptr
}

arr() -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_ARRAY
    v.arr_val = list.list_new()
    return v as ptr
}

map() -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_MAP
    v.map_keys = list.list_new()
    v.map_values = list.list_new()
    return v as ptr
}

ext(type_id: int, data: string) -> ptr {
    let v = heap.new(MsgValue)
    v.type_id = TYPE_EXT
    v.ext_type = type_id
    set_payload(v as *MsgValue, data, string.length(data))
    return v as ptr
}

// ---- Getters / Setters ----

get_type(val: ptr) -> int {
    if val == null { return TYPE_NIL }
    return (val as *MsgValue).type_id
}

get_bool(val: ptr) -> bool {
    if val == null { return false }
    return (val as *MsgValue).b_val
}

get_int(val: ptr) -> long {
    if val == null { return 0 }
    return (val as *MsgValue).i_val
}

get_float(val: ptr) -> float {
    if val == null { return 0.0 }
    return (val as *MsgValue).f_val
}

// Returns a fresh, caller-owned string copy of the payload. Release it
// like any other string.
get_string(val: ptr) -> string {
    if val == null { return "" }
    return payload_string(val as *MsgValue)
}

// Returns a fresh, caller-owned string copy of the binary payload.
get_bin(val: ptr) -> string {
    if val == null { return "" }
    return payload_string(val as *MsgValue)
}

array_size(val: ptr) -> int {
    if val == null { return -1 }
    let m = val as *MsgValue
    if m.type_id != TYPE_ARRAY { return -1 }
    return list.list_size(m.arr_val)
}

array_get(val: ptr, index: int) -> ptr {
    if val == null { return null }
    let m = val as *MsgValue
    if m.type_id != TYPE_ARRAY { return null }
    if index < 0 || index >= list.list_size(m.arr_val) { return null }
    return list.list_get_raw(m.arr_val, index)
}

array_add(val: ptr, item: ptr) -> int {
    if val == null || item == null { return 0 }
    let m = val as *MsgValue
    if m.type_id != TYPE_ARRAY { return 0 }
    list.list_add_raw(m.arr_val, item)
    return 1
}

map_size(val: ptr) -> int {
    if val == null { return -1 }
    let m = val as *MsgValue
    if m.type_id != TYPE_MAP { return -1 }
    return list.list_size(m.map_keys)
}

map_get_key(val: ptr, index: int) -> ptr {
    if val == null { return null }
    let m = val as *MsgValue
    if m.type_id != TYPE_MAP { return null }
    if index < 0 || index >= list.list_size(m.map_keys) { return null }
    return list.list_get_raw(m.map_keys, index)
}

map_get_value(val: ptr, index: int) -> ptr {
    if val == null { return null }
    let m = val as *MsgValue
    if m.type_id != TYPE_MAP { return null }
    if index < 0 || index >= list.list_size(m.map_values) { return null }
    return list.list_get_raw(m.map_values, index)
}

// Compare a string-typed key node's payload against `key` byte-for-byte.
// Mints a temporary string for the comparison and releases it, so no
// AetherString escapes.
fn key_matches(k: *MsgValue, key: string) -> bool {
    if k == null || k.type_id != TYPE_STR { return false }
    if k.s_len != string.length(key) { return false }
    if k.s_len == 0 { return true }
    let ks = payload_string(k)
    let eq = ks == key
    string.release(ks)
    return eq
}

map_get(val: ptr, key: string) -> ptr {
    if val == null { return null }
    let m = val as *MsgValue
    if m.type_id != TYPE_MAP { return null }
    let sz = list.list_size(m.map_keys)
    let i = 0
    while i < sz {
        let k = list.list_get_raw(m.map_keys, i) as *MsgValue
        if key_matches(k, key) {
            return list.list_get_raw(m.map_values, i)
        }
        i = i + 1
    }
    return null
}

map_set(val: ptr, key: string, value: ptr) -> int {
    if val == null || value == null { return 0 }
    let m = val as *MsgValue
    if m.type_id != TYPE_MAP { return 0 }
    let sz = list.list_size(m.map_keys)
    let i = 0
    while i < sz {
        let k = list.list_get_raw(m.map_keys, i) as *MsgValue
        if key_matches(k, key) {
            let old_val = list.list_get_raw(m.map_values, i)
            if old_val != null { free(old_val) }
            list.list_set(m.map_values, i, value)
            return 1
        }
        i = i + 1
    }
    let new_key = str(key)
    list.list_add_raw(m.map_keys, new_key)
    list.list_add_raw(m.map_values, value)
    return 1
}

// ---- Recursive Free ----

free(val: ptr) {
    if val == null { return }
    let m = val as *MsgValue
    if m.type_id == TYPE_ARRAY {
        if m.arr_val != null {
            let sz = list.list_size(m.arr_val)
            let i = 0
            while i < sz {
                let item = list.list_get_raw(m.arr_val, i)
                if item != null { free(item) }
                i = i + 1
            }
            list.list_free(m.arr_val)
        }
    } else if m.type_id == TYPE_MAP {
        if m.map_keys != null {
            let sz = list.list_size(m.map_keys)
            let i = 0
            while i < sz {
                let k = list.list_get_raw(m.map_keys, i)
                let v = list.list_get_raw(m.map_values, i)
                if k != null { free(k) }
                if v != null { free(v) }
                i = i + 1
            }
            list.list_free(m.map_keys)
            list.list_free(m.map_values)
        }
    }
    if m.s_bytes != null {
        bytes.free(m.s_bytes)
        m.s_bytes = null
    }
    heap.free(m)
}

// ---- Pack / Unpack ----

pack(val: ptr) -> string {
    let b = bytes.new(64)
    let end = pack_val(val, b, 0)
    let res = bytes.finish(b, end)
    return res
}

unpack(bytes_str: string) -> ptr! {
    let ok = ""
    let len = string.length(bytes_str)
    if len == 0 {
        return null, "empty input"
    }
    let b = bytes.new(len)
    bytes.copy_from_string(b, 0, bytes_str, len)
    defer bytes.free(b)

    let c, err_c = cursor.new(b)
    if err_c != "" {
        return null, err_c
    }
    defer cursor.free(c)

    let val, err = unpack_inner(c)
    if err != "" {
        return null, err
    }
    // unpack_inner's success path returns a fresh heap "" in the error
    // slot; we discard it here (returning our own ok), so release it or
    // it leaks one byte per unpack call.
    string.release(err)
    return val, ok
}

// ---- Packing implementation helper ----

// Write a value's str/bin/ext payload bytes into the output buffer.
fn pack_payload(m: *MsgValue, b: ptr, offset: int) {
    if m.s_len > 0 && m.s_bytes != null {
        bytes.copy_from_bytes(b, offset, m.s_bytes, 0, m.s_len)
    }
}

fn pack_val(val: ptr, b: ptr, offset: int) -> int {
    if val == null {
        bytes.set(b, offset, 0xc0)
        return offset + 1
    }
    let m = val as *MsgValue
    if m.type_id == 0 { // TYPE_NIL
        bytes.set(b, offset, 0xc0)
        return offset + 1
    }
    if m.type_id == 1 { // TYPE_BOOL
        if m.b_val {
            bytes.set(b, offset, 0xc3)
        } else {
            bytes.set(b, offset, 0xc2)
        }
        return offset + 1
    }
    if m.type_id == 2 { // TYPE_INT
        let i = m.i_val
        if i >= 0 {
            if i <= 127 {
                bytes.set(b, offset, i)
                return offset + 1
            }
            if i <= 255 {
                bytes.set(b, offset, 0xcc)
                bytes.set(b, offset + 1, i)
                return offset + 2
            }
            if i <= 65535 {
                bytes.set(b, offset, 0xcd)
                bytes.set_be16(b, offset + 1, i)
                return offset + 3
            }
            if i <= 4294967295 {
                bytes.set(b, offset, 0xce)
                bytes.set_be32(b, offset + 1, i)
                return offset + 5
            }
            bytes.set(b, offset, 0xcf)
            bytes.set_be64(b, offset + 1, i)
            return offset + 9
        } else {
            if i >= -32 {
                bytes.set(b, offset, 0xe0 | (i & 31))
                return offset + 1
            }
            if i >= -128 {
                bytes.set(b, offset, 0xd0)
                bytes.set(b, offset + 1, i & 255)
                return offset + 2
            }
            if i >= -32768 {
                bytes.set(b, offset, 0xd1)
                bytes.set_be16(b, offset + 1, i)
                return offset + 3
            }
            if i >= -2147483648 {
                bytes.set(b, offset, 0xd2)
                bytes.set_be32(b, offset + 1, i)
                return offset + 5
            }
            bytes.set(b, offset, 0xd3)
            bytes.set_be64(b, offset + 1, i)
            return offset + 9
        }
    }
    if m.type_id == 3 { // TYPE_FLOAT
        let bits = mem.bits_of_float(m.f_val)
        bytes.set(b, offset, 0xcb)
        bytes.set_be64(b, offset + 1, bits)
        return offset + 9
    }
    if m.type_id == 4 { // TYPE_STR
        let len = m.s_len
        let next_off = offset
        if len <= 31 {
            bytes.set(b, offset, 0xa0 | len)
            next_off = offset + 1
        } else if len <= 255 {
            bytes.set(b, offset, 0xd9)
            bytes.set(b, offset + 1, len)
            next_off = offset + 2
        } else if len <= 65535 {
            bytes.set(b, offset, 0xda)
            bytes.set_be16(b, offset + 1, len)
            next_off = offset + 3
        } else {
            bytes.set(b, offset, 0xdb)
            bytes.set_be32(b, offset + 1, len)
            next_off = offset + 5
        }
        pack_payload(m, b, next_off)
        return next_off + len
    }
    if m.type_id == 5 { // TYPE_BIN
        let len = m.s_len
        let next_off = offset
        if len <= 255 {
            bytes.set(b, offset, 0xc4)
            bytes.set(b, offset + 1, len)
            next_off = offset + 2
        } else if len <= 65535 {
            bytes.set(b, offset, 0xc5)
            bytes.set_be16(b, offset + 1, len)
            next_off = offset + 3
        } else {
            bytes.set(b, offset, 0xc6)
            bytes.set_be32(b, offset + 1, len)
            next_off = offset + 5
        }
        pack_payload(m, b, next_off)
        return next_off + len
    }
    if m.type_id == 6 { // TYPE_ARRAY
        let sz = list.list_size(m.arr_val)
        let next_off = offset
        if sz <= 15 {
            bytes.set(b, offset, 0x90 | sz)
            next_off = offset + 1
        } else if sz <= 65535 {
            bytes.set(b, offset, 0xdc)
            bytes.set_be16(b, offset + 1, sz)
            next_off = offset + 3
        } else {
            bytes.set(b, offset, 0xdd)
            bytes.set_be32(b, offset + 1, sz)
            next_off = offset + 5
        }
        let i = 0
        while i < sz {
            let item = list.list_get_raw(m.arr_val, i)
            next_off = pack_val(item, b, next_off)
            i = i + 1
        }
        return next_off
    }
    if m.type_id == 7 { // TYPE_MAP
        let sz = list.list_size(m.map_keys)
        let next_off = offset
        if sz <= 15 {
            bytes.set(b, offset, 0x80 | sz)
            next_off = offset + 1
        } else if sz <= 65535 {
            bytes.set(b, offset, 0xde)
            bytes.set_be16(b, offset + 1, sz)
            next_off = offset + 3
        } else {
            bytes.set(b, offset, 0xdf)
            bytes.set_be32(b, offset + 1, sz)
            next_off = offset + 5
        }
        let i = 0
        while i < sz {
            let k = list.list_get_raw(m.map_keys, i)
            let v = list.list_get_raw(m.map_values, i)
            next_off = pack_val(k, b, next_off)
            next_off = pack_val(v, b, next_off)
            i = i + 1
        }
        return next_off
    }
    if m.type_id == 8 { // TYPE_EXT
        let len = m.s_len
        let next_off = offset
        if len == 1 {
            bytes.set(b, offset, 0xd4)
            bytes.set(b, offset + 1, m.ext_type & 255)
            next_off = offset + 2
        } else if len == 2 {
            bytes.set(b, offset, 0xd5)
            bytes.set(b, offset + 1, m.ext_type & 255)
            next_off = offset + 2
        } else if len == 4 {
            bytes.set(b, offset, 0xd6)
            bytes.set(b, offset + 1, m.ext_type & 255)
            next_off = offset + 2
        } else if len == 8 {
            bytes.set(b, offset, 0xd7)
            bytes.set(b, offset + 1, m.ext_type & 255)
            next_off = offset + 2
        } else if len == 16 {
            bytes.set(b, offset, 0xd8)
            bytes.set(b, offset + 1, m.ext_type & 255)
            next_off = offset + 2
        } else if len <= 255 {
            bytes.set(b, offset, 0xc7)
            bytes.set(b, offset + 1, len)
            bytes.set(b, offset + 2, m.ext_type & 255)
            next_off = offset + 3
        } else if len <= 65535 {
            bytes.set(b, offset, 0xc8)
            bytes.set_be16(b, offset + 1, len)
            bytes.set(b, offset + 3, m.ext_type & 255)
            next_off = offset + 4
        } else {
            bytes.set(b, offset, 0xc9)
            bytes.set_be32(b, offset + 1, len)
            bytes.set(b, offset + 5, m.ext_type & 255)
            next_off = offset + 6
        }
        pack_payload(m, b, next_off)
        return next_off + len
    }
    return offset
}

// ---- Unpacking implementation helper ----

// Read `len` payload bytes from the cursor and adopt the resulting slice
// buffer as `v`'s owned payload (read_slice returns a freshly-owned
// AetherBytes, so no copy is needed). Records an empty payload for len==0.
// Returns an error string ("" on success); on failure the value's payload
// is left empty and the caller frees the value.
fn read_payload(v: *MsgValue, c: ptr, len: int, what: string) -> string {
    if len <= 0 {
        v.s_bytes = null
        v.s_len = 0
        return ""
    }
    let slice = cursor.read_slice(c, len)
    if slice == null {
        return what
    }
    v.s_bytes = slice
    v.s_len = len
    return ""
}

fn unpack_inner(c: ptr) -> (ptr, string) {
    // Single tracked empty-error binding reused for every success return.
    // A bare `""` literal in the error slot mints a fresh 1-byte heap
    // string per call that the caller discards — leaking one byte per
    // decoded value (see std.yaml / std.asn1 for the same pattern).
    let ok = ""
    let m = cursor.read_u8(c)
    if m < 0 {
        return null, "EOF"
    }

    // 1. Positive FixInt
    if m >= 0x00 && m <= 0x7f {
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = m
        return v as ptr, ok
    }

    // 2. FixMap
    if m >= 0x80 && m <= 0x8f {
        let sz = m & 0x0f
        let v = heap.new(MsgValue)
        v.type_id = TYPE_MAP
        v.map_keys = list.list_new()
        v.map_values = list.list_new()
        let i = 0
        while i < sz {
            let key, err_k = unpack_inner(c)
            if err_k != "" {
                free(v)
                return null, err_k
            }
            string.release(err_k) // success-path heap "" from the child; discard
            let val, err_v = unpack_inner(c)
            if err_v != "" {
                free(key)
                free(v)
                return null, err_v
            }
            string.release(err_v)
            list.list_add_raw(v.map_keys, key)
            list.list_add_raw(v.map_values, val)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 3. FixArray
    if m >= 0x90 && m <= 0x9f {
        let sz = m & 0x0f
        let v = heap.new(MsgValue)
        v.type_id = TYPE_ARRAY
        v.arr_val = list.list_new()
        let i = 0
        while i < sz {
            let item, err = unpack_inner(c)
            if err != "" {
                free(v)
                return null, err
            }
            string.release(err) // success-path heap "" from the child; discard
            list.list_add_raw(v.arr_val, item)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 4. FixStr
    if m >= 0xa0 && m <= 0xbf {
        let len = m & 0x1f
        let v = heap.new(MsgValue)
        v.type_id = TYPE_STR
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading FixStr data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 5. Nil
    if m == 0xc0 {
        let v = heap.new(MsgValue)
        v.type_id = TYPE_NIL
        return v as ptr, ok
    }

    // Reserved
    if m == 0xc1 {
        return null, "reserved marker 0xc1 encountered"
    }

    // 6. False
    if m == 0xc2 {
        let v = heap.new(MsgValue)
        v.type_id = TYPE_BOOL
        v.b_val = false
        return v as ptr, ok
    }

    // 7. True
    if m == 0xc3 {
        let v = heap.new(MsgValue)
        v.type_id = TYPE_BOOL
        v.b_val = true
        return v as ptr, ok
    }

    // 8. Bin 8
    if m == 0xc4 {
        if cursor.remaining(c) < 1 { return null, "EOF reading bin 8 length" }
        let len = cursor.read_u8(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_BIN
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading bin 8 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 9. Bin 16
    if m == 0xc5 {
        if cursor.remaining(c) < 2 { return null, "EOF reading bin 16 length" }
        let len = cursor.read_be_u16(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_BIN
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading bin 16 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 10. Bin 32
    if m == 0xc6 {
        if cursor.remaining(c) < 4 { return null, "EOF reading bin 32 length" }
        let len = cursor.read_be_u32(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_BIN
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading bin 32 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 11. Ext 8
    if m == 0xc7 {
        if cursor.remaining(c) < 2 { return null, "EOF reading ext 8 length/type" }
        let len = cursor.read_u8(c)
        let et = cursor.read_u8(c)
        // ext_type is signed i8
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading ext 8 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 12. Ext 16
    if m == 0xc8 {
        if cursor.remaining(c) < 3 { return null, "EOF reading ext 16 length/type" }
        let len = cursor.read_be_u16(c)
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading ext 16 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 13. Ext 32
    if m == 0xc9 {
        if cursor.remaining(c) < 5 { return null, "EOF reading ext 32 length/type" }
        let len = cursor.read_be_u32(c)
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading ext 32 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 14. Float 32
    if m == 0xca {
        if cursor.remaining(c) < 4 { return null, "EOF reading float 32" }
        let raw = cursor.read_be_u32(c)
        // Mask to 32 unsigned bits: read_be_u32 returns an int, and widening
        // an int with bit 31 set to long would sign-extend, corrupting the
        // float's sign/exponent. float32_from_bits wants the raw 32 bits.
        let bits: long = (raw as long) & 4294967295
        let f = float32_from_bits(bits)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_FLOAT
        v.f_val = f
        return v as ptr, ok
    }

    // 15. Float 64
    if m == 0xcb {
        if cursor.remaining(c) < 8 { return null, "EOF reading float 64" }
        let bits = cursor.read_be_u64(c)
        let f = mem.float_from_bits(bits)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_FLOAT
        v.f_val = f
        return v as ptr, ok
    }

    // 16. U8
    if m == 0xcc {
        if cursor.remaining(c) < 1 { return null, "EOF reading u8" }
        let i = cursor.read_u8(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 17. U16
    if m == 0xcd {
        if cursor.remaining(c) < 2 { return null, "EOF reading u16" }
        let i = cursor.read_be_u16(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 18. U32
    if m == 0xce {
        if cursor.remaining(c) < 4 { return null, "EOF reading u32" }
        let i = cursor.read_be_u32(c)
        let val: long = i
        if val < 0 {
            val = val + 4294967296
        }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = val
        return v as ptr, ok
    }

    // 19. U64
    if m == 0xcf {
        if cursor.remaining(c) < 8 { return null, "EOF reading u64" }
        let i = cursor.read_be_u64(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 20. I8
    if m == 0xd0 {
        if cursor.remaining(c) < 1 { return null, "EOF reading i8" }
        let i = cursor.read_u8(c)
        if i >= 128 { i = i - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 21. I16
    if m == 0xd1 {
        if cursor.remaining(c) < 2 { return null, "EOF reading i16" }
        let i = cursor.read_be_u16(c)
        if i >= 32768 { i = i - 65536 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 22. I32
    if m == 0xd2 {
        if cursor.remaining(c) < 4 { return null, "EOF reading i32" }
        let i = cursor.read_be_u32(c)
        let val: long = i
        if val >= 2147483648 { val = val - 4294967296 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = val
        return v as ptr, ok
    }

    // 23. I64
    if m == 0xd3 {
        if cursor.remaining(c) < 8 { return null, "EOF reading i64" }
        let i = cursor.read_be_u64(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    // 24. FixExt 1
    if m == 0xd4 {
        if cursor.remaining(c) < 2 { return null, "EOF reading fixext 1" }
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, 1, "EOF reading fixext 1 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 25. FixExt 2
    if m == 0xd5 {
        if cursor.remaining(c) < 3 { return null, "EOF reading fixext 2" }
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, 2, "EOF reading fixext 2 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 26. FixExt 4
    if m == 0xd6 {
        if cursor.remaining(c) < 5 { return null, "EOF reading fixext 4" }
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, 4, "EOF reading fixext 4 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 27. FixExt 8
    if m == 0xd7 {
        if cursor.remaining(c) < 9 { return null, "EOF reading fixext 8" }
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, 8, "EOF reading fixext 8 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 28. FixExt 16
    if m == 0xd8 {
        if cursor.remaining(c) < 17 { return null, "EOF reading fixext 16" }
        let et = cursor.read_u8(c)
        let ext_type = et
        if ext_type >= 128 { ext_type = ext_type - 256 }
        let v = heap.new(MsgValue)
        v.type_id = TYPE_EXT
        v.ext_type = ext_type
        let perr = read_payload(v as *MsgValue, c, 16, "EOF reading fixext 16 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 29. Str 8
    if m == 0xd9 {
        if cursor.remaining(c) < 1 { return null, "EOF reading str 8 length" }
        let len = cursor.read_u8(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_STR
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading str 8 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 30. Str 16
    if m == 0xda {
        if cursor.remaining(c) < 2 { return null, "EOF reading str 16 length" }
        let len = cursor.read_be_u16(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_STR
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading str 16 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 31. Str 32
    if m == 0xdb {
        if cursor.remaining(c) < 4 { return null, "EOF reading str 32 length" }
        let len = cursor.read_be_u32(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_STR
        let perr = read_payload(v as *MsgValue, c, len, "EOF reading str 32 data")
        if perr != "" {
            heap.free(v)
            return null, perr
        }
        return v as ptr, ok
    }

    // 32. Array 16
    if m == 0xdc {
        if cursor.remaining(c) < 2 { return null, "EOF reading array 16 size" }
        let sz = cursor.read_be_u16(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_ARRAY
        v.arr_val = list.list_new()
        let i = 0
        while i < sz {
            let item, err = unpack_inner(c)
            if err != "" {
                free(v)
                return null, err
            }
            string.release(err) // success-path heap "" from the child; discard
            list.list_add_raw(v.arr_val, item)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 33. Array 32
    if m == 0xdd {
        if cursor.remaining(c) < 4 { return null, "EOF reading array 32 size" }
        let sz = cursor.read_be_u32(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_ARRAY
        v.arr_val = list.list_new()
        let i = 0
        while i < sz {
            let item, err = unpack_inner(c)
            if err != "" {
                free(v)
                return null, err
            }
            string.release(err) // success-path heap "" from the child; discard
            list.list_add_raw(v.arr_val, item)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 34. Map 16
    if m == 0xde {
        if cursor.remaining(c) < 2 { return null, "EOF reading map 16 size" }
        let sz = cursor.read_be_u16(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_MAP
        v.map_keys = list.list_new()
        v.map_values = list.list_new()
        let i = 0
        while i < sz {
            let key, err_k = unpack_inner(c)
            if err_k != "" {
                free(v)
                return null, err_k
            }
            string.release(err_k) // success-path heap "" from the child; discard
            let val, err_v = unpack_inner(c)
            if err_v != "" {
                free(key)
                free(v)
                return null, err_v
            }
            string.release(err_v)
            list.list_add_raw(v.map_keys, key)
            list.list_add_raw(v.map_values, val)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 35. Map 32
    if m == 0xdf {
        if cursor.remaining(c) < 4 { return null, "EOF reading map 32 size" }
        let sz = cursor.read_be_u32(c)
        let v = heap.new(MsgValue)
        v.type_id = TYPE_MAP
        v.map_keys = list.list_new()
        v.map_values = list.list_new()
        let i = 0
        while i < sz {
            let key, err_k = unpack_inner(c)
            if err_k != "" {
                free(v)
                return null, err_k
            }
            string.release(err_k) // success-path heap "" from the child; discard
            let val, err_v = unpack_inner(c)
            if err_v != "" {
                free(key)
                free(v)
                return null, err_v
            }
            string.release(err_v)
            list.list_add_raw(v.map_keys, key)
            list.list_add_raw(v.map_values, val)
            i = i + 1
        }
        return v as ptr, ok
    }

    // 36. Negative FixInt
    if m >= 0xe0 && m <= 0xff {
        let i = m - 256
        let v = heap.new(MsgValue)
        v.type_id = TYPE_INT
        v.i_val = i
        return v as ptr, ok
    }

    return null, "unrecognized marker"
}