Method exec_mod

compiler/src/modules/vm/handlers/arith.rs:120–139

(&mut self, a: Val, b: Val, chunk: &SSAChunk, slots: &mut [Val])

    }

    fn exec_mod(&mut self, a: Val, b: Val, chunk: &SSAChunk, slots: &mut [Val]) -> Result<Val, VmErr> {
        // `str % args` is printf-style formatting, not modulo.
        if a.is_heap() && matches!(self.heap.get(a), HeapObj::Str(_)) {
            return self.str_percent_format(a, b, chunk, slots);
        }
        if a.is_float() || b.is_float() {
            let af = self.to_f64_coerce(a).map_err(|_| cold_type("% requires numeric operands"))?;
            let bf = self.to_f64_coerce(b).map_err(|_| cold_type("% requires numeric operands"))?;
            if bf == 0.0 { return Err(VmErr::ZeroDiv); }
            // Floor-division semantics: result takes the divisor's sign.
            let r = af - ffloor(af / bf) * bf;
            return Ok(Val::float(r));
        }
        let (Some(ai), Some(bi)) = (self.as_i128(a), self.as_i128(b)) else { return Err(cold_type("% requires numeric operands")); };
        if bi == 0 { return Err(VmErr::ZeroDiv); }
        // Floor-mod on i128: result takes the divisor's sign. `checked_rem` guards against i128::MIN % -1 (which would overflow).
        let r = ai.checked_rem(bi).ok_or(cold_overflow())?;
        let r = if (r != 0) && ((r < 0) != (bi < 0)) { r + bi } else { r };
        self.int_to_val(Some(r))
    }

    /* printf-style `str % args`: translates each `%[flags][width][.prec]conv` into the `{:spec}` mini-language and reuses `format_value`. A tuple spreads; else one value. */
    fn str_percent_format(&mut self, fmt_val: Val, arg: Val, chunk: &SSAChunk, slots: &mut [Val]) -> Result<Val, VmErr> {