perf(wasm): format numbers without libc printf

- add utils/number_text with snprintf-compatible %f/%e/%g and integer/hex formatting
- take float digits from double-conversion, rounding exact binary ties to even as printf does (double-conversion alone rounds them up)
- move every engine snprintf and std::to_string(double) onto it
- route pugixml XPath number formatting through a WASM-only --wrap=snprintf in FormulonWasm.cmake, next to the existing strtod wrap
- musl's printf machinery leaves the module
- output is byte-identical: number_text_test.cpp checks parity against host snprintf over hand-picked values, random magnitudes, exact ties and random bit patterns
- oracle diff: fast tier passes unchanged
- WASM: 3,293,540 -> 3,292,036 raw, Brotli -2.1 KB (901,702)

Author: libraz

CMakeLists.txt

@@ -112,6 +112,7 @@ set(FORMULON_CORE_SOURCES
   src/utils/double_parse.cpp
   src/utils/index_sort.cpp
   src/utils/japanese_era.cpp
+  src/utils/number_text.cpp
   src/utils/structured_log.cpp
   src/utils/text_ops.cpp
   src/utils/thread_launch.cpp

cmake/FormulonWasm.cmake

@@ -402,15 +402,18 @@ set_target_properties(formulon_wasm_stack_probe PROPERTIES
 # always-active SAX). Native builds keep the threshold at 256 KiB.
 target_compile_definitions(formulon_core PRIVATE FORMULON_WASM=1)
 
-# pugixml parses numbers with strtod. Wrapping the symbol routes those calls
-# to the engine's decimal parser (`__wrap_strtod` in src/utils/double_parse.cpp),
-# which keeps libc's scanner and the 128-bit float routines it needs out of
-# the module: ~10 KB uncompressed, ~5 KB Brotli.
+# pugixml parses numbers with strtod and prints them with snprintf. Wrapping
+# the symbols routes those calls to the engine's decimal parser
+# (`__wrap_strtod` in src/utils/double_parse.cpp) and formatter
+# (`__wrap_snprintf` in src/utils/number_text.cpp), which keeps libc's scanner,
+# its printf machinery and the 128-bit float routines they need out of the
+# module.
 target_link_options(formulon_wasm PRIVATE
   ${_FM_WASM_OPT_FLAGS}
   ${_FM_WASM_LINK_OPT_FLAGS}
   ${_FM_WASM_COMMON_LINK_FLAGS}
   "-Wl,--wrap=strtod"
+  "-Wl,--wrap=snprintf"
 )
 
 # Land the artifact at <build>/<base>.{js,wasm}. Emscripten infers the

src/c_api/parts/cf_mutate.cpp

@@ -19,7 +19,6 @@
 #include <algorithm>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
 #include <string>
 #include <utility>
 #include <vector>
@@ -30,6 +29,7 @@
 #include "color_resolve.h"
 #include "io/cf_overlay.h"
 #include "utils/error.h"
+#include "utils/number_text.h"
 #include "workbook.h"
 
 using formulon::c_api::BorrowedArrayArena;
@@ -422,9 +422,9 @@ extern "C" fm_status_t fm_sheet_cf_add_rule(fm_workbook_t* wb, std::size_t sheet
     // nibble is `0`, which no random (version 4) GUID Excel generates
     // can carry, so a synthesized id can never collide with a loaded
     // one.
-    char buf[40];
-    std::snprintf(buf, sizeof(buf), "{FC000000-0000-0000-0000-%012X}", static_cast<unsigned>(out_rule.priority));
-    out_rule.id = buf;
+    char buf[16];
+    formulon::format_hex(buf, sizeof(buf), static_cast<unsigned>(out_rule.priority), 12, true);
+    out_rule.id = std::string("{FC000000-0000-0000-0000-") + buf + "}";
   }
   if (rule.formula1 != nullptr) {
     out_rule.formula1 = std::string(rule.formula1);

src/c_api/parts/common.cpp

@@ -15,6 +15,7 @@
 #include "sheet.h"
 #include "styles.h"
 #include "utils/error.h"
+#include "utils/number_text.h"
 #include "value.h"
 
 namespace formulon {
@@ -126,15 +127,15 @@ fm_status_t check_finite_non_negative(double value, const char* api, const char*
     return 0;
   }
   return set_binding_error(formulon::FormulonErrorCode::kInvalidArgument, "value must be finite and non-negative",
-                           std::string(api) + ": " + field + "=" + std::to_string(value));
+                           std::string(api) + ": " + field + "=" + formulon::fixed_string(value, 6));
 }
 
 fm_status_t check_finite(double value, const char* api, const char* field) {
   if (std::isfinite(value)) {
     return 0;
   }
   return set_binding_error(formulon::FormulonErrorCode::kInvalidArgument, "value must be finite",
-                           std::string(api) + ": " + field + "=" + std::to_string(value));
+                           std::string(api) + ": " + field + "=" + formulon::fixed_string(value, 6));
 }
 
 fm_status_t value_from_fm(const fm_value_t& in, formulon::Value* out, const char* api) {

src/c_api/parts/pivot_table.cpp

@@ -21,6 +21,7 @@
 #include "pivot/field_lookup.h"
 #include "sheet.h"
 #include "utils/error.h"
+#include "utils/number_text.h"
 #include "workbook.h"
 
 using formulon::c_api::parts::check_enum_domain;
@@ -543,10 +544,10 @@ extern "C" fm_status_t fm_workbook_pivot_field_set_date_group(
                                "fm_workbook_pivot_field_set_date_group: interval_days=0");
     }
     if (has_start && has_end && start_serial_or_neg1 > end_serial_or_neg1) {
-      return set_binding_error(formulon::FormulonErrorCode::kInvalidArgument,
-                               "start_serial_or_neg1 must not exceed end_serial_or_neg1",
-                               "fm_workbook_pivot_field_set_date_group: start=" + std::to_string(start_serial_or_neg1) +
-                                   " end=" + std::to_string(end_serial_or_neg1));
+      return set_binding_error(
+          formulon::FormulonErrorCode::kInvalidArgument, "start_serial_or_neg1 must not exceed end_serial_or_neg1",
+          "fm_workbook_pivot_field_set_date_group: start=" + formulon::fixed_string(start_serial_or_neg1, 6) +
+              " end=" + formulon::fixed_string(end_serial_or_neg1, 6));
     }
     if ((has_start && !is_valid_date_serial(start_serial_or_neg1, wb->workbook().date1904())) ||
         (has_end && !is_valid_date_serial(end_serial_or_neg1, wb->workbook().date1904()))) {

src/cf/validation_eval.cpp

@@ -2,7 +2,6 @@
 
 #include <algorithm>
 #include <cmath>
-#include <cstdio>
 #include <cstdlib>
 #include <optional>
 #include <string>
@@ -17,6 +16,7 @@
 #include "eval/function_registry.h"
 #include "sheet.h"
 #include "utils/arena.h"
+#include "utils/number_text.h"
 #include "utils/resource_budget.h"
 #include "utils/utf8_length.h"
 #include "workbook.h"
@@ -227,7 +227,7 @@ bool inline_list_matches(const std::vector<std::string>& items, const Value& pro
 std::optional<std::string> literal_of(const Value& proposed) {
   if (proposed.is_number()) {
     char buf[40];
-    std::snprintf(buf, sizeof(buf), "%.17g", proposed.as_number());
+    format_general(buf, sizeof(buf), proposed.as_number(), 17);
     return std::string(buf);
   }
   if (proposed.is_boolean()) {

src/eval/builtins/engineering.cpp

@@ -22,7 +22,6 @@
 
 #include <cmath>
 #include <cstdint>
-#include <cstdio>
 #include <cstdlib>
 #include <string>
 #include <string_view>
@@ -32,6 +31,7 @@
 #include "eval/function_registry.h"
 #include "utils/arena.h"
 #include "utils/expected.h"
+#include "utils/number_text.h"
 #include "value.h"
 
 namespace formulon {
@@ -192,7 +192,7 @@ Expected<std::string, ErrorCode> input_digit_string(const Value& v) {
       // Use a fixed-width scratch buffer: the magnitude fits in a 64-bit
       // integer (signed range is well below 2^63 for our bases).
       char buf[32];
-      std::snprintf(buf, sizeof(buf), "%lld", static_cast<long long>(t));
+      format_signed(buf, sizeof(buf), static_cast<long long>(t));
       return std::string(buf);
     }
     case ValueKind::Bool:

src/eval/text_format/render_date.cpp

@@ -9,14 +9,14 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
 #include <string>
 #include <string_view>
 
 #include "eval/text_format/number_format_types.h"
 #include "eval/text_format/render_common.h"
 #include "utils/date_time.h"
 #include "utils/japanese_era.h"
+#include "utils/number_text.h"
 
 namespace formulon {
 namespace text_format {
@@ -206,7 +206,7 @@ FormatStatus render_date(const Section& section, std::string_view fmt, double se
       }
       case Tok::DateY4: {
         char buf[16];
-        const int n = std::snprintf(buf, sizeof(buf), "%04d", ymd.y);
+        const int n = format_signed(buf, sizeof(buf), ymd.y, 4);
         if (n > 0) {
           if (dbnum == DbNumMode::kNone) {
             out.append(buf, static_cast<std::size_t>(n));

src/eval/text_format/render_fraction.cpp

@@ -9,14 +9,14 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
 #include <limits>
 #include <string>
 #include <string_view>
 
 #include "eval/text_format/number_format_scanner.h"
 #include "eval/text_format/number_format_types.h"
 #include "eval/text_format/render_common.h"
+#include "utils/number_text.h"
 
 namespace formulon {
 namespace text_format {
@@ -296,7 +296,7 @@ FormatStatus render_fraction(const Section& section, std::string_view fmt, doubl
   // `# ?/?`), and a zero integer is shown even under `#`.
   const bool suppress_fraction = has_int_group && fraction_num == 0;
   char int_buf[400];
-  const int int_len = std::snprintf(int_buf, sizeof(int_buf), "%.0f", integer_part);
+  const int int_len = format_fixed(int_buf, sizeof(int_buf), integer_part, 0);
   if (int_len < 0 || static_cast<std::size_t>(int_len) >= sizeof(int_buf)) {
     return FormatStatus::kOverflow;
   }

src/eval/text_format/render_numeric.cpp

@@ -10,7 +10,6 @@
 #include <cmath>
 #include <cstddef>
 #include <cstdint>
-#include <cstdio>
 #include <string>
 #include <string_view>
 #include <vector>
@@ -19,6 +18,7 @@
 #include "eval/text_format/render_common.h"
 #include "eval/text_format/render_fraction.h"
 #include "eval/text_format/rounding.h"
+#include "utils/number_text.h"
 
 namespace formulon {
 namespace text_format {
@@ -44,7 +44,7 @@ void format_fixed_digits(double v, int decimals, bool* negative, std::string* in
   const double rounded = std::isfinite(decimal_rounded) ? decimal_rounded : v;
   *negative = rounded < 0.0;
   const double abs_v = std::fabs(rounded);
-  // `snprintf` only converts an already Excel-rounded decimal value to its
+  // `format_fixed` only converts an already Excel-rounded decimal value to its
   // digit string. It must not decide the tie direction: Apple libc rounds
   // `%.0f` ties to even, while Excel rounds them away from zero.
   const int requested_decimals = decimals < 0 ? 0 : decimals;
@@ -57,12 +57,12 @@ void format_fixed_digits(double v, int decimals, bool* negative, std::string* in
     rendered_decimals = std::min(requested_decimals, std::max(0, 14 - exponent));
   }
   char buf[64];
-  const int n = std::snprintf(buf, sizeof(buf), "%.*f", rendered_decimals, abs_v);
+  const int n = format_fixed(buf, sizeof(buf), abs_v, rendered_decimals);
   if (n < 0 || static_cast<std::size_t>(n) >= sizeof(buf)) {
-    // Fallback: fall back to sprintf with a heap buffer (extremely rare).
+    // Fallback: a heap buffer for the oversized text (extremely rare).
     std::string out;
     out.resize(static_cast<std::size_t>(rendered_decimals) + 32u);
-    const int m = std::snprintf(&out[0], out.size(), "%.*f", rendered_decimals, abs_v);
+    const int m = format_fixed(&out[0], out.size(), abs_v, rendered_decimals);
     if (m > 0) {
       out.resize(static_cast<std::size_t>(m));
     } else {
@@ -165,9 +165,10 @@ void format_general(std::string& out, double v) {
       frac = 0;
     }
     char buf[64];
-    const int n = std::snprintf(buf, sizeof(buf), "%.*e", frac, v);
+    const int n = format_exponential(buf, sizeof(buf), v, frac);
     if (n <= 0) {
-      out.append(std::to_string(v));
+      format_fixed(buf, sizeof(buf), v, 6);
+      out.append(buf);
       return;
     }
     std::string_view s(buf, static_cast<std::size_t>(n));
@@ -210,9 +211,10 @@ void format_general(std::string& out, double v) {
     frac = 0;
   }
   char buf[64];
-  const int n = std::snprintf(buf, sizeof(buf), "%.*f", frac, v);
+  const int n = format_fixed(buf, sizeof(buf), v, frac);
   if (n <= 0) {
-    out.append(std::to_string(v));
+    format_fixed(buf, sizeof(buf), v, 6);
+    out.append(buf);
     return;
   }
   out.append(buf, trimmed_fraction_length(std::string_view(buf, static_cast<std::size_t>(n))));
@@ -403,7 +405,7 @@ FormatStatus render_numeric(const Section& section, std::string_view fmt, double
     int_digits.clear();
   }
 
-  // Fraction adjustment: the snprintf produced exactly `frac_digits` chars.
+  // Fraction adjustment: the formatter produced exactly `frac_digits` chars.
   // Trim trailing zeros matching the `#` tokens (scan right-to-left).
   int trim = section.fraction_opt_digits;
   while (trim > 0 && !frac_digits_str.empty() && frac_digits_str.back() == '0') {