Fix: Prevent float precision loss for large integers in MessagePack encoding

[mstdokumaci]

Problem

Large floating-point numbers (e.g., 1774904202196) were being truncated when encoded as MessagePack floats. This happened because the encoder would downgrade to 32-bit float (f32) encoding, which only supports 24 bits of mantissa precision. Values requiring more than 24 bits would lose precision.

Solution

Refactored the writeFloat() function to intelligently choose the encoding format:

• Convert the f64 value to f32 and back to f64
• Compare the result with the original value
• If they match exactly: use space-efficient f32 encoding
• If precision is lost: use full f64 encoding

This ensures large integers preserve their exact value while still optimizing for smaller numbers.

Changes

• src/msgpack.zig: Refactored writeFloat() to detect precision loss
• src/test.zig: Added large integer float precision (issue fix) test

Testing

The new test demonstrates:

• The specific value 1774904202196 is preserved exactly
• Wire format correctly uses f64 marker (0xcb) instead of f32 (0xca)
• Round-trip serialization maintains full precision

Example

// Before: would truncate to 1774904202688
const large_int: f64 = 1774904202196.0;

// After: preserves exact value with f64 encoding
try packer.write(.{ .float = large_int });
const result = try packer.read(allocator); // == 1774904202196.0 ✓

[gemini-code-assist]

Code Review

This pull request updates the writeFloat function in src/msgpack.zig to ensure f64 values are only encoded as f32 when there is no loss of precision. It also adds a test case in src/test.zig to verify that large integers are correctly encoded as f64. I have no feedback to provide.

[jinzhongjia]

oh, nice pr, thx