@tishlang/tish-format 1.0.12 → 2.0.1

package/crates/tish_bytecode/src/encoding.rs

@@ -0,0 +1,102 @@
+//! Canonical u8 encoding for AST operators in bytecode.
+//! Single source of truth: compiler encodes with *\_to_u8, VM decodes with u8_to\_*.
+
+use tishlang_ast::{BinOp, CompoundOp, UnaryOp};
+
+/// Encode BinOp for bytecode operand. Used by compiler.
+pub fn binop_to_u8(op: BinOp) -> u8 {
+    use tishlang_ast::BinOp::*;
+    match op {
+        Add => 0,
+        Sub => 1,
+        Mul => 2,
+        Div => 3,
+        Mod => 4,
+        Pow => 5,
+        Eq => 6,
+        Ne => 7,
+        StrictEq => 8,
+        StrictNe => 9,
+        Lt => 10,
+        Le => 11,
+        Gt => 12,
+        Ge => 13,
+        And => 14,
+        Or => 15,
+        BitAnd => 16,
+        BitOr => 17,
+        BitXor => 18,
+        Shl => 19,
+        Shr => 20,
+        In => 21,
+        UShr => 22,
+    }
+}
+
+/// Decode bytecode operand to BinOp. Used by VM.
+pub fn u8_to_binop(b: u8) -> Option<BinOp> {
+    use tishlang_ast::BinOp::*;
+    Some(match b {
+        0 => Add,
+        1 => Sub,
+        2 => Mul,
+        3 => Div,
+        4 => Mod,
+        5 => Pow,
+        6 => Eq,
+        7 => Ne,
+        8 => StrictEq,
+        9 => StrictNe,
+        10 => Lt,
+        11 => Le,
+        12 => Gt,
+        13 => Ge,
+        14 => And,
+        15 => Or,
+        16 => BitAnd,
+        17 => BitOr,
+        18 => BitXor,
+        19 => Shl,
+        20 => Shr,
+        21 => In,
+        22 => UShr,
+        _ => return None,
+    })
+}
+
+/// Encode CompoundOp for bytecode (same numeric subset as BinOp: Add,Sub,Mul,Div,Mod).
+pub fn compound_op_to_u8(op: CompoundOp) -> u8 {
+    use tishlang_ast::CompoundOp::*;
+    match op {
+        Add => 0,
+        Sub => 1,
+        Mul => 2,
+        Div => 3,
+        Mod => 4,
+    }
+}
+
+/// Encode UnaryOp for bytecode operand. Used by compiler.
+pub fn unaryop_to_u8(op: UnaryOp) -> u8 {
+    use tishlang_ast::UnaryOp::*;
+    match op {
+        Not => 0,
+        Neg => 1,
+        Pos => 2,
+        BitNot => 3,
+        Void => 4,
+    }
+}
+
+/// Decode bytecode operand to UnaryOp. Used by VM.
+pub fn u8_to_unaryop(b: u8) -> Option<UnaryOp> {
+    use tishlang_ast::UnaryOp::*;
+    Some(match b {
+        0 => Not,
+        1 => Neg,
+        2 => Pos,
+        3 => BitNot,
+        4 => Void,
+        _ => return None,
+    })
+}

package/crates/tish_bytecode/src/lib.rs

@@ -0,0 +1,20 @@
+//! Bytecode compiler for Tish.
+//! Compiles AST to stack-based bytecode for VM execution.
+
+mod chunk;
+mod compiler;
+mod encoding;
+mod opcode;
+mod peephole;
+mod serialize;
+
+pub const NO_REST_PARAM: u16 = 0xFFFF;
+
+pub use chunk::{Chunk, Constant};
+pub use compiler::{
+    compile, compile_for_repl, compile_for_repl_unoptimized, compile_unoptimized,
+    compile_with_source, CompileError,
+};
+pub use encoding::{binop_to_u8, compound_op_to_u8, u8_to_binop, u8_to_unaryop, unaryop_to_u8};
+pub use opcode::Opcode;
+pub use serialize::{deserialize, serialize};

package/crates/tish_bytecode/src/opcode.rs

@@ -0,0 +1,185 @@
+//! Bytecode opcodes for the Tish VM.
+
+/// Stack-based bytecode opcodes.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Opcode {
+    /// No operation
+    Nop = 0,
+    /// Push constant from constants table (operand: u16 index)
+    LoadConst = 1,
+    /// Load variable from scope (operand: u16 name index)
+    LoadVar = 2,
+    /// Store top of stack to variable (operand: u16 name index)
+    StoreVar = 3,
+    /// Discard top of stack
+    Pop = 4,
+    /// Duplicate top of stack
+    Dup = 5,
+    /// Call function with n args (operand: u16 arg count). Callee and args on stack.
+    Call = 6,
+    /// Return from function. Top of stack is return value.
+    Return = 7,
+    /// Unconditional jump forward (operand: u16 byte offset)
+    Jump = 8,
+    /// Pop top; if falsy, jump forward (operand: u16 byte offset)
+    JumpIfFalse = 9,
+    /// Unconditional jump backward (operand: u16 byte offset)
+    JumpBack = 10,
+    /// Binary operation (operand: u8 BinOp variant). Pops left, right; pushes result.
+    BinOp = 11,
+    /// Unary operation (operand: u8 UnaryOp variant). Pops operand; pushes result.
+    UnaryOp = 12,
+    /// Get property: obj.prop (operand: u16 prop name index). Pops obj; pushes value.
+    GetMember = 13,
+    /// Set property: obj.prop = val (operand: u16 prop name index). Pops obj, val.
+    SetMember = 14,
+    /// Get index: obj[idx]. Pops obj, idx; pushes value.
+    GetIndex = 15,
+    /// Set index: obj[idx] = val. Pops obj, idx, val.
+    SetIndex = 16,
+    /// Create array with n elements (operand: u16 count). Elements on stack.
+    NewArray = 17,
+    /// Create object with n key-value pairs (operand: u16 count). Keys and vals interleaved.
+    NewObject = 18,
+    /// Load from global scope (operand: u16 name index)
+    LoadGlobal = 19,
+    /// Store to global scope (operand: u16 name index)
+    StoreGlobal = 20,
+    /// Create closure: push function (operand: u16 chunk index for nested function)
+    Closure = 21,
+    /// Pop and discard n values (operand: u16 count)
+    PopN = 22,
+    /// Load `this` or receiver (for method calls)
+    LoadThis = 23,
+    /// Throw: pop value, unwind to catch handler, push value, jump
+    Throw = 24,
+    /// EnterTry: push handler (catch offset u16). Catch offset = bytes from end of this insn.
+    EnterTry = 25,
+    /// ExitTry: pop try handler
+    ExitTry = 26,
+    /// Concat arrays: pop right, pop left, push left.concat(right). For spread.
+    ConcatArray = 27,
+    /// Merge objects: pop right, pop left, push Object.assign({}, left, right). For object spread.
+    MergeObject = 28,
+    /// Call with spread: pop args array, pop callee, call callee(...args).
+    CallSpread = 29,
+    /// Get property optional: like GetMember but returns Null if obj is null or prop missing.
+    GetMemberOptional = 30,
+    /// Pop array, sort numerically in place (operand: u8 0=asc, 1=desc), push array.
+    /// Fast path for arr.sort((a,b)=>a-b) / arr.sort((a,b)=>b-a).
+    ArraySortNumeric = 31,
+    /// Pop array, sort by numeric property (operands: u16 prop_name_const_idx, u16 0=asc/1=desc).
+    /// Fast path for arr.sort((a,b)=>a.prop-b.prop).
+    ArraySortByProperty = 32,
+    /// arr.map(x => x) - identity, returns array clone.
+    ArrayMapIdentity = 33,
+    /// arr.map(x => x op const) or arr.map(x => const op x). Operands: u8 binop, u16 const_idx, u8 param_left (0=param on left e.g. x*2, 1=param on right e.g. 2*x).
+    ArrayMapBinOp = 34,
+    /// arr.filter(x => x op const) or arr.filter(x => const op x). Operands: u8 binop, u16 const_idx, u8 param_left. Keeps elements where result is truthy.
+    ArrayFilterBinOp = 35,
+    /// Load built-in module export. Operands: u16 spec_const_idx, u16 export_name_const_idx. Pushes Value.
+    LoadNativeExport = 36,
+    /// `new callee(...args)` (operand: u16 arg count). Stack: callee, then args — same as Call.
+    Construct = 37,
+    /// `new callee(...spread)` — stack: args array, then callee (same order as CallSpread).
+    ConstructSpread = 38,
+    /// Declare `let`/`const` in the current lexical frame (operand: u16 name index). Pops value.
+    /// Does not walk enclosing scopes or globals (unlike [`StoreVar`]).
+    DeclareVar = 39,
+    /// Enter a block scope; pairs with [`ExitBlock`].
+    EnterBlock = 40,
+    /// Exit innermost block scope and restore shadowed bindings.
+    ExitBlock = 41,
+    /// Like [`DeclareVar`] but does not record block-scope undo (for `for`/`for-of` header bindings).
+    DeclareVarPlain = 42,
+    /// Pop the `await` operand value; if it is a `Promise`, block until settled, push the result,
+    /// or unwind to `catch` like `Throw` on rejection.
+    AwaitPromise = 43,
+    /// Load a local variable by frame slot (operand: u16 slot). Fast path: direct
+    /// index into the current call frame's locals, no name lookup.
+    LoadLocal = 44,
+    /// Store top of stack into a local frame slot (operand: u16 slot). Leaves nothing.
+    StoreLocal = 45,
+    /// Load a captured variable from an enclosing frame (operands: u16 hops, u16 slot).
+    /// Walks `hops` parent frames, then indexes `slot`.
+    LoadUpvalue = 46,
+    /// Store top of stack into an enclosing frame slot (operands: u16 hops, u16 slot).
+    StoreUpvalue = 47,
+    /// Begin a per-iteration binding region for a loop variable (operand: u16 name index).
+    /// Registers the name so closures created in the loop body snapshot it into a fresh overlay
+    /// (ES `let` per-iteration semantics); the rest of the frame stays shared. Emitted only when
+    /// the loop body creates a closure, so closure-free (hot) loops are untouched.
+    LoopVarsBegin = 48,
+    /// End the innermost per-iteration binding region (no operand).
+    LoopVarsEnd = 49,
+    /// Push `Bool(param_index >= argc)` — true when the positional argument at `param_index`
+    /// was not supplied by the caller (operand: u16 param index). Emitted by the function
+    /// prologue so default parameter values apply only for *missing* args, matching the
+    /// interpreter: an explicit `null` argument does NOT trigger the default.
+    ArgMissing = 50,
+    /// Direct self-recursive call (operand: u16 arg count). Emitted by the compiler ONLY when a
+    /// `fn NAME` body calls `NAME(args)` and `NAME` is provably the function itself (not shadowed
+    /// by a param/local, not reassigned anywhere in the body). Args are on the stack as for `Call`,
+    /// but the callee is implicitly the currently-executing chunk — no name lookup, no closure
+    /// dispatch. The numeric JIT lowers this to a native recursive call (the big recursion win);
+    /// the VM runs the current chunk directly. Behaviour is identical to `LoadVar NAME; Call argc`.
+    SelfCall = 51,
+    /// Normalize the top-of-stack iterable for `for…of`: a JS iterator object (one with a
+    /// callable `next()` returning `{ value, done }`, e.g. a `Map`/`Set` `.values()` result)
+    /// is drained into an array; arrays/strings/anything else pass through unchanged. Emitted
+    /// right after the iterable expression so the existing index-based loop can iterate it.
+    IterNormalize = 52,
+    /// `delete obj[key]` / `delete obj.prop`. Pops `[obj, key]`, removes the property
+    /// (objects: drop the key; arrays: set the index to a null hole), pushes `true`.
+    DeleteIndex = 53,
+}
+
+impl Opcode {
+    /// Decode byte to opcode. Safe for b in 0..=53 (matches #[repr(u8)] discriminants).
+    #[inline]
+    pub fn from_u8(b: u8) -> Option<Opcode> {
+        if b <= 53 {
+            Some(unsafe { std::mem::transmute::<u8, Opcode>(b) })
+        } else {
+            None
+        }
+    }
+
+    /// Size in bytes of this instruction at `ip` (including operands). Returns None if truncated.
+    pub fn instruction_size(self, code: &[u8], ip: usize) -> Option<usize> {
+        let size = match self {
+            Opcode::Nop
+            | Opcode::Pop
+            | Opcode::Dup
+            | Opcode::Return
+            | Opcode::ExitTry
+            | Opcode::ConcatArray
+            | Opcode::MergeObject
+            | Opcode::GetIndex
+            | Opcode::SetIndex
+            | Opcode::Throw
+            | Opcode::ArrayMapIdentity
+            | Opcode::CallSpread
+            | Opcode::ConstructSpread
+            | Opcode::EnterBlock
+            | Opcode::ExitBlock
+            | Opcode::LoopVarsEnd
+            | Opcode::IterNormalize
+            | Opcode::DeleteIndex
+            | Opcode::AwaitPromise => 1,
+            Opcode::ArraySortByProperty
+            | Opcode::ArrayMapBinOp
+            | Opcode::ArrayFilterBinOp
+            | Opcode::LoadNativeExport
+            | Opcode::LoadUpvalue
+            | Opcode::StoreUpvalue => 5,
+            // LoadLocal / StoreLocal take a single u16 operand → 3 bytes (default).
+            _ => 3,
+        };
+        if ip + size > code.len() {
+            return None;
+        }
+        Some(size)
+    }
+}

package/crates/tish_bytecode/src/peephole.rs

@@ -0,0 +1,189 @@
+//! Peephole optimizations on bytecode (post-emission).
+//! B2 from optimization plan: jump chaining, etc.
+
+use std::collections::BTreeSet;
+
+use crate::opcode::Opcode;
+use crate::Chunk;
+
+fn read_u16(code: &[u8], pos: usize) -> u16 {
+    if pos + 1 >= code.len() {
+        return 0;
+    }
+    let a = code[pos] as u16;
+    let b = code[pos + 1] as u16;
+    (a << 8) | b
+}
+
+fn read_i16(code: &[u8], pos: usize) -> i16 {
+    read_u16(code, pos) as i16
+}
+
+fn write_u16(code: &mut [u8], pos: usize, v: u16) {
+    if pos + 1 < code.len() {
+        let bytes = v.to_be_bytes();
+        code[pos] = bytes[0];
+        code[pos + 1] = bytes[1];
+    }
+}
+
+/// Size of instruction at `ip` in bytes. Returns None if invalid/truncated.
+fn instruction_size(code: &[u8], ip: usize) -> Option<usize> {
+    if ip >= code.len() {
+        return None;
+    }
+    let opcode = Opcode::from_u8(code[ip])?;
+    opcode.instruction_size(code, ip)
+}
+
+/// Advance past `Nop` bytes left by other peepholes (`Dup`+`Pop` → `Nop`+`Nop`, etc.).
+/// Jump resolution must not treat a `Nop` run as the end of a chain, or we leave a jump
+/// targeting the middle of padding while `chain_jumps` redirects another jump past it —
+/// that misaligns `||` short-circuit when nested in an outer `if`.
+fn skip_leading_nops(code: &[u8], mut ip: usize) -> usize {
+    while ip < code.len() && Opcode::from_u8(code[ip]) == Some(Opcode::Nop) {
+        ip += 1;
+    }
+    ip
+}
+
+/// After a branch lands at `ip`, follow only **unconditional** `Jump` instructions.
+/// Must not follow `JumpIfFalse`: that opcode is conditional; treating it like `Jump`
+/// breaks short-circuit codegen (e.g. `a === 1 || b === 2` inside `if (...)`).
+fn skip_unconditional_jump_chain(code: &[u8], mut ip: usize) -> Option<usize> {
+    ip = skip_leading_nops(code, ip);
+    let mut visited = 0u32;
+    const MAX_CHAIN: u32 = 1000;
+    loop {
+        if visited > MAX_CHAIN {
+            return None;
+        }
+        visited += 1;
+        if ip > code.len() {
+            return None;
+        }
+        if ip == code.len() {
+            return Some(ip);
+        }
+        let _ = instruction_size(code, ip)?;
+        let op = Opcode::from_u8(code[ip])?;
+        if op != Opcode::Jump {
+            return Some(ip);
+        }
+        let offset = read_i16(code, ip + 1) as isize;
+        ip = (ip as isize + 3 + offset).max(0) as usize;
+        ip = skip_leading_nops(code, ip);
+    }
+}
+
+/// For a `Jump` or `JumpIfFalse` at `jump_ip`, return the final IP after resolving the
+/// taken branch and then skipping through any **unconditional** `Jump` chain only.
+fn final_jump_target(code: &[u8], jump_ip: usize) -> Option<usize> {
+    let _ = instruction_size(code, jump_ip)?;
+    let op = Opcode::from_u8(code[jump_ip])?;
+    let first_target = match op {
+        Opcode::Jump | Opcode::JumpIfFalse => {
+            let offset = read_i16(code, jump_ip + 1) as isize;
+            (jump_ip as isize + 3 + offset).max(0) as usize
+        }
+        _ => return Some(jump_ip),
+    };
+    let first_target = skip_leading_nops(code, first_target);
+    skip_unconditional_jump_chain(code, first_target)
+}
+
+/// Instruction boundaries from a linear scan (aligned bytecode from the compiler).
+fn collect_insn_starts(code: &[u8]) -> BTreeSet<usize> {
+    let mut out = BTreeSet::new();
+    let mut ip = 0usize;
+    while ip < code.len() {
+        out.insert(ip);
+        let sz = instruction_size(code, ip).unwrap_or(1);
+        ip += sz;
+    }
+    out
+}
+
+/// Replace instruction at [ip..ip+len) with Nops (preserves length, no offset updates).
+fn nop_out(code: &mut [u8], ip: usize, len: usize) {
+    for i in 0..len {
+        if ip + i < code.len() {
+            code[ip + i] = Opcode::Nop as u8;
+        }
+    }
+}
+
+/// Remove redundant Dup + Pop (dup top then discard = no-op).
+fn remove_dup_pop(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip + 2 <= code.len() {
+        if Opcode::from_u8(code[ip]) == Some(Opcode::Dup)
+            && Opcode::from_u8(code[ip + 1]) == Some(Opcode::Pop)
+        {
+            nop_out(code, ip, 2);
+        }
+        ip += instruction_size(code, ip).unwrap_or(1);
+    }
+}
+
+/// Replace no-op jumps (Jump with offset 0) with Nops.
+fn remove_noop_jumps(code: &mut [u8]) {
+    let mut ip = 0;
+    while ip < code.len() {
+        if Opcode::from_u8(code[ip]) == Some(Opcode::Jump) {
+            let offset = read_u16(code, ip + 1);
+            if offset == 0 {
+                nop_out(code, ip, 3);
+            }
+        }
+        ip += instruction_size(code, ip).unwrap_or(1);
+    }
+}
+
+/// Apply jump chaining: if Jump/JumpIfFalse targets another jump, update to
+/// jump directly to the final target.
+fn chain_jumps(code: &mut [u8]) {
+    let insn_starts = collect_insn_starts(code);
+    let mut ip = 0;
+    while ip < code.len() {
+        let op = match Opcode::from_u8(code[ip]) {
+            Some(o) => o,
+            None => {
+                ip += 1;
+                continue;
+            }
+        };
+        let size = match instruction_size(code, ip) {
+            Some(s) => s,
+            None => break,
+        };
+        match op {
+            Opcode::Jump | Opcode::JumpIfFalse => {
+                let current_offset = read_i16(code, ip + 1) as isize;
+                let current_target = (ip as isize + 3 + current_offset).max(0) as usize;
+                if let Some(final_target) = final_jump_target(code, ip) {
+                    let target_ok =
+                        final_target == code.len() || insn_starts.contains(&final_target);
+                    if final_target != current_target && target_ok {
+                        let new_offset = final_target as i32 - (ip + 3) as i32;
+                        if (i16::MIN as i32..=i16::MAX as i32).contains(&new_offset) {
+                            write_u16(code, ip + 1, (new_offset as i16) as u16);
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+        ip += size;
+    }
+}
+
+/// Run peephole optimizations on a chunk (and nested chunks).
+pub fn optimize(chunk: &mut Chunk) {
+    remove_dup_pop(&mut chunk.code);
+    remove_noop_jumps(&mut chunk.code);
+    chain_jumps(&mut chunk.code);
+    for nested in &mut chunk.nested {
+        optimize(nested);
+    }
+}

package/crates/tish_bytecode/src/serialize.rs

@@ -0,0 +1,193 @@
+//! Chunk serialization for embedding in native/WASM outputs.
+//! Format: code, constants, names, nested (recursive).
+
+use std::sync::Arc;
+
+use super::{Chunk, Constant};
+
+/// Serialize a chunk to bytes (includes nested chunks for functions).
+pub fn serialize(chunk: &Chunk) -> Vec<u8> {
+    let mut out = Vec::new();
+    out.extend_from_slice(&(chunk.code.len() as u64).to_le_bytes());
+    out.extend_from_slice(&chunk.code);
+    out.extend_from_slice(&(chunk.constants.len() as u64).to_le_bytes());
+    for c in &chunk.constants {
+        match c {
+            Constant::Number(n) => {
+                out.push(0);
+                out.extend_from_slice(&n.to_le_bytes());
+            }
+            Constant::String(s) => {
+                out.push(1);
+                let b = s.as_bytes();
+                out.extend_from_slice(&(b.len() as u64).to_le_bytes());
+                out.extend_from_slice(b);
+            }
+            Constant::Bool(b) => {
+                out.push(2);
+                out.push(if *b { 1 } else { 0 });
+            }
+            Constant::Null => out.push(3),
+            Constant::Closure(idx) => {
+                out.push(4);
+                out.extend_from_slice(&(*idx as u64).to_le_bytes());
+            }
+        }
+    }
+    out.extend_from_slice(&(chunk.names.len() as u64).to_le_bytes());
+    for n in &chunk.names {
+        let b = n.as_bytes();
+        out.extend_from_slice(&(b.len() as u64).to_le_bytes());
+        out.extend_from_slice(b);
+    }
+    out.extend_from_slice(&(chunk.nested.len() as u64).to_le_bytes());
+    for nested in &chunk.nested {
+        let nested_bytes = serialize(nested);
+        out.extend_from_slice(&(nested_bytes.len() as u64).to_le_bytes());
+        out.extend_from_slice(&nested_bytes);
+    }
+    out.extend_from_slice(&chunk.rest_param_index.to_le_bytes());
+    out.extend_from_slice(&chunk.param_count.to_le_bytes());
+    out.extend_from_slice(&chunk.num_slots.to_le_bytes());
+    out.push(if chunk.slot_based { 1 } else { 0 });
+    out
+}
+
+/// Deserialize a chunk from bytes.
+pub fn deserialize(mut data: &[u8]) -> Result<Chunk, String> {
+    let read_u64 = |d: &mut &[u8]| {
+        if d.len() < 8 {
+            return Err("Unexpected EOF".to_string());
+        }
+        let (head, tail) = d.split_at(8);
+        *d = tail;
+        Ok(u64::from_le_bytes(head.try_into().unwrap()))
+    };
+
+    let code_len = read_u64(&mut data)? as usize;
+    if data.len() < code_len {
+        return Err("Truncated code".to_string());
+    }
+    let (code_bytes, rest) = data.split_at(code_len);
+    data = rest;
+    let code = code_bytes.to_vec();
+
+    let const_count = read_u64(&mut data)? as usize;
+    let mut constants = Vec::with_capacity(const_count);
+    for _ in 0..const_count {
+        if data.is_empty() {
+            return Err("Truncated constant".to_string());
+        }
+        let tag = data[0];
+        data = &data[1..];
+        let c = match tag {
+            0 => {
+                if data.len() < 8 {
+                    return Err("Truncated number".to_string());
+                }
+                let (n_bytes, rest) = data.split_at(8);
+                data = rest;
+                Constant::Number(f64::from_le_bytes(n_bytes.try_into().unwrap()))
+            }
+            1 => {
+                let str_len = read_u64(&mut data)? as usize;
+                if data.len() < str_len {
+                    return Err("Truncated string".to_string());
+                }
+                let (s_bytes, rest) = data.split_at(str_len);
+                data = rest;
+                Constant::String(Arc::from(String::from_utf8_lossy(s_bytes).into_owned()))
+            }
+            2 => {
+                if data.is_empty() {
+                    return Err("Truncated bool".to_string());
+                }
+                let b = data[0] != 0;
+                data = &data[1..];
+                Constant::Bool(b)
+            }
+            3 => Constant::Null,
+            4 => {
+                let idx = read_u64(&mut data)? as usize;
+                Constant::Closure(idx)
+            }
+            _ => return Err(format!("Unknown constant tag: {}", tag)),
+        };
+        constants.push(c);
+    }
+
+    let names_count = read_u64(&mut data)? as usize;
+    let mut names = Vec::with_capacity(names_count);
+    for _ in 0..names_count {
+        let n_len = read_u64(&mut data)? as usize;
+        if data.len() < n_len {
+            return Err("Truncated name".to_string());
+        }
+        let (n_bytes, rest) = data.split_at(n_len);
+        data = rest;
+        names.push(Arc::from(String::from_utf8_lossy(n_bytes).into_owned()));
+    }
+
+    let nested_count = read_u64(&mut data)? as usize;
+    let mut nested = Vec::with_capacity(nested_count);
+    for _ in 0..nested_count {
+        let nested_len = read_u64(&mut data)? as usize;
+        if data.len() < nested_len {
+            return Err("Truncated nested chunk".to_string());
+        }
+        let (nested_data, rest) = data.split_at(nested_len);
+        data = rest;
+        nested.push(deserialize(nested_data)?);
+    }
+
+    let rest_param_index = if data.len() >= 2 {
+        let (r_bytes, rest) = data.split_at(2);
+        data = rest;
+        u16::from_le_bytes(r_bytes.try_into().unwrap())
+    } else {
+        super::NO_REST_PARAM
+    };
+    let param_count = if data.len() >= 2 {
+        let (p_bytes, rest) = data.split_at(2);
+        data = rest;
+        u16::from_le_bytes(p_bytes.try_into().unwrap())
+    } else {
+        0
+    };
+    let num_slots = if data.len() >= 2 {
+        let (s_bytes, rest) = data.split_at(2);
+        data = rest;
+        u16::from_le_bytes(s_bytes.try_into().unwrap())
+    } else {
+        0
+    };
+    let slot_based = if !data.is_empty() {
+        let b = data[0] != 0;
+        data = &data[1..];
+        b
+    } else {
+        false
+    };
+    let _ = data;
+
+    // Inline caches are a runtime-only cache, not serialized — start empty, sized to `names`.
+    let inline_caches = crate::chunk::InlineCaches(
+        (0..names.len())
+            .map(|_| std::sync::atomic::AtomicU64::new(0))
+            .collect(),
+    );
+    Ok(Chunk {
+        code,
+        constants,
+        names,
+        nested,
+        rest_param_index,
+        param_count,
+        num_slots,
+        slot_based,
+        inline_caches,
+        // Debug-only; not part of the serialized format (issue #74).
+        lines: Vec::new(),
+        source: None,
+    })
+}