fix: x86_64 ABI mismatch — all extern "C" fn -> bool changed to i32/f64 (v0.4.49)

Bug #13 (SIGSEGV on Contract.call() returning tuple) was caused by the same
js_string_equals bool-return ABI mismatch fixed in Bug #12: Cranelift declared
I32 return but the Rust function returned bool (1 byte in al, not full eax).
Garbage upper bits made isDynamic() return true for tuple types, sending the
decoder down the dynamic-encoding path with astronomical offsets → BigInt('0x')
→ null pointer → SIGSEGV.

This commit fixes ALL remaining extern "C" fn -> bool across the codebase:

perry-runtime: js_nanbox_is_bigint/pointer/string (→ i32),
               js_json_is_valid (→ f64 NaN-boxed TAG_TRUE/TAG_FALSE)

perry-stdlib:  js_cron_validate, js_cron_job_is_running (→ f64)
               js_sqlite_exec/begin/commit/rollback/close/in_transaction (→ i32)
               js_moment_is_before/after/same/between/valid (→ f64)
               js_lodash_in_range (→ f64), js_lodash_is_empty/nil (→ i32)
               js_argon2_verify_sync/needs_rehash (→ i32)
               js_commander_get_option_bool (→ f64)
               js_http_respond_*/server_close (→ f64)

Author: proggeramlug

CLAUDE.md

@@ -8,7 +8,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 Perry is a native TypeScript compiler written in Rust that compiles TypeScript source code directly to native executables. It uses SWC for TypeScript parsing and Cranelift for code generation.
 
-**Current Version:** 0.4.48
+**Current Version:** 0.4.49
 
 ## Workflow Requirements
 
@@ -140,6 +140,9 @@ Projects can list npm packages to compile natively instead of routing to V8. Con
 
 ## Recent Changes
 
+### v0.4.49
+- fix: x86_64 SIGSEGV when `Contract.call()` returns a tuple — root cause was `js_string_equals` returning `bool` (1 byte in `al`) while Cranelift declared it as `I32` (reads full `eax`); garbage upper bits made `isDynamic("(uint256,uint256)")` return true, causing the decoder to take the dynamic-encoding path with an astronomical offset, leading to invalid BigInt construction and null pointer dereference. Fixed in v0.4.48 commit db84777; this version additionally fixes ALL remaining `extern "C" fn -> bool` ABI mismatches across perry-runtime and perry-stdlib (17 functions: `js_json_is_valid`, `js_nanbox_is_*`, `js_cron_*`, `js_sqlite_*`, `js_moment_*`, `js_lodash_*`, `js_commander_*`, `js_http_*`)
+
 ### v0.4.48
 - fix: x86_64 SIGSEGV in `Contract()` with 20-module ethkit — wrapper functions for FuncRef callbacks (e.g., `.map(resolveType)`) now use `Linkage::Export` instead of `Linkage::Local`; module-scoped names prevent collisions while Export linkage ensures correct `func_addr` resolution on x86_64 ELF; also added cross-platform GcHeader validation for `keys_array` in `js_object_get_field_by_name` to catch corrupted object pointers (Linux lacked the macOS-only ASCII heuristic guard)
 

Cargo.lock

@@ -85,7 +85,7 @@ opt-level = "s"       # Optimize for size in stdlib
 opt-level = 3
 
 [workspace.package]
-version = "0.4.48"
+version = "0.4.49"
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/PerryTS/perry"

Cargo.toml

@@ -698,14 +698,20 @@ pub unsafe extern "C" fn js_json_stringify_null() -> *mut StringHeader {
 
 /// Check if a string is valid JSON
 #[no_mangle]
-pub unsafe extern "C" fn js_json_is_valid(text_ptr: *const StringHeader) -> bool {
+pub unsafe extern "C" fn js_json_is_valid(text_ptr: *const StringHeader) -> f64 {
+    const TAG_TRUE: u64 = 0x7FFC_0000_0000_0004;
+    const TAG_FALSE: u64 = 0x7FFC_0000_0000_0003;
     if text_ptr.is_null() {
-        return false;
+        return f64::from_bits(TAG_FALSE);
     }
     let len = (*text_ptr).length as usize;
     let data_ptr = (text_ptr as *const u8).add(std::mem::size_of::<StringHeader>());
     let bytes = std::slice::from_raw_parts(data_ptr, len);
-    serde_json::from_slice::<serde_json::Value>(bytes).is_ok()
+    if serde_json::from_slice::<serde_json::Value>(bytes).is_ok() {
+        f64::from_bits(TAG_TRUE)
+    } else {
+        f64::from_bits(TAG_FALSE)
+    }
 }
 
 // ─── Utility functions ────────────────────────────────────────────────────────

crates/perry-runtime/src/json.rs

@@ -660,9 +660,9 @@ pub unsafe extern "C" fn js_dynamic_bitxor(a: f64, b: f64) -> f64 {
 
 /// Check if an f64 value (interpreted as NaN-boxed) represents a BigInt.
 #[no_mangle]
-pub extern "C" fn js_nanbox_is_bigint(value: f64) -> bool {
+pub extern "C" fn js_nanbox_is_bigint(value: f64) -> i32 {
     let jsval = JSValue::from_bits(value.to_bits());
-    jsval.is_bigint()
+    if jsval.is_bigint() { 1 } else { 0 }
 }
 
 /// Extract a BigInt pointer from a NaN-boxed f64 value.
@@ -682,9 +682,9 @@ pub extern "C" fn js_nanbox_get_bigint(value: f64) -> i64 {
 
 /// Check if an f64 value (interpreted as NaN-boxed) represents a pointer.
 #[no_mangle]
-pub extern "C" fn js_nanbox_is_pointer(value: f64) -> bool {
+pub extern "C" fn js_nanbox_is_pointer(value: f64) -> i32 {
     let jsval = JSValue::from_bits(value.to_bits());
-    jsval.is_pointer()
+    if jsval.is_pointer() { 1 } else { 0 }
 }
 
 /// Extract a pointer from a NaN-boxed f64 value.
@@ -780,9 +780,9 @@ pub extern "C" fn js_get_string_pointer_unified(value: f64) -> i64 {
 
 /// Check if a NaN-boxed f64 value represents a string.
 #[no_mangle]
-pub extern "C" fn js_nanbox_is_string(value: f64) -> bool {
+pub extern "C" fn js_nanbox_is_string(value: f64) -> i32 {
     let jsval = JSValue::from_bits(value.to_bits());
-    jsval.is_string()
+    if jsval.is_string() { 1 } else { 0 }
 }
 
 /// Convert a NaN-boxed f64 value to a string pointer.

crates/perry-runtime/src/value.rs

@@ -129,47 +129,47 @@ pub unsafe extern "C" fn js_argon2_verify(
 pub unsafe extern "C" fn js_argon2_verify_sync(
     hash_ptr: *const StringHeader,
     password_ptr: *const StringHeader,
-) -> bool {
+) -> i32 {
     let hash_str = match string_from_header(hash_ptr) {
         Some(h) => h,
-        None => return false,
+        None => return 0,
     };
 
     let password = match string_from_header(password_ptr) {
         Some(p) => p,
-        None => return false,
+        None => return 0,
     };
 
     let parsed_hash = match PasswordHash::new(&hash_str) {
         Ok(h) => h,
-        Err(_) => return false,
+        Err(_) => return 0,
     };
 
     let argon2 = Argon2::default();
-    argon2.verify_password(password.as_bytes(), &parsed_hash).is_ok()
+    if argon2.verify_password(password.as_bytes(), &parsed_hash).is_ok() { 1 } else { 0 }
 }
 
 /// argon2.needsRehash(hash) -> boolean
 ///
 /// Check if a hash needs to be rehashed (e.g., due to outdated parameters).
 #[no_mangle]
-pub unsafe extern "C" fn js_argon2_needs_rehash(hash_ptr: *const StringHeader) -> bool {
+pub unsafe extern "C" fn js_argon2_needs_rehash(hash_ptr: *const StringHeader) -> i32 {
     let hash_str = match string_from_header(hash_ptr) {
         Some(h) => h,
-        None => return true,
+        None => return 1,
     };
 
     // Parse the hash to check its parameters
     match PasswordHash::new(&hash_str) {
         Ok(parsed) => {
             // Check if algorithm is argon2id
             if parsed.algorithm.as_str() != "argon2id" {
-                return true;
+                return 1;
             }
             // In a real implementation, we'd check memory cost, time cost, etc.
             // For now, we assume current defaults are acceptable
-            false
+            0
         }
-        Err(_) => true, // Invalid hash needs rehashing
+        Err(_) => 1, // Invalid hash needs rehashing
     }
 }

crates/perry-stdlib/src/argon2.rs

@@ -281,19 +281,24 @@ pub unsafe extern "C" fn js_commander_get_option_number(handle: Handle, name_ptr
 
 /// Get a specific option value as boolean
 #[no_mangle]
-pub unsafe extern "C" fn js_commander_get_option_bool(handle: Handle, name_ptr: *const StringHeader) -> bool {
+pub unsafe extern "C" fn js_commander_get_option_bool(handle: Handle, name_ptr: *const StringHeader) -> f64 {
+    const TAG_TRUE: u64 = 0x7FFC_0000_0000_0004;
+    const TAG_FALSE: u64 = 0x7FFC_0000_0000_0003;
+
     let name = match string_from_header(name_ptr) {
         Some(n) => n,
-        None => return false,
+        None => return f64::from_bits(TAG_FALSE),
     };
 
     if let Some(cmd) = get_handle_mut::<CommanderHandle>(handle) {
         if let Some(value) = cmd.parsed_values.get(&name) {
-            return value == "true" || value == "1";
+            if value == "true" || value == "1" {
+                return f64::from_bits(TAG_TRUE);
+            }
         }
     }
 
-    false
+    f64::from_bits(TAG_FALSE)
 }
 
 /// Get positional arguments count