fix: event loop GC via threshold-based gc_check_trigger_export

After removing gc_check_trigger from timer ticks (caused SIGSEGV from
register-held values being missed by conservative stack scanner), GC had
no trigger point for long-running services. Memory grew unbounded.

This adds gc_check_trigger_export() — an extern "C" wrapper around the
existing threshold-based gc_check_trigger — and calls it from the main
event loop AFTER both timer ticks have returned. At this point, all live
JS values are safely stored in module globals, closure boxes, or timer
root lists (not in registers), so the conservative scanner finds them.

The threshold check (arena >= 64MB or malloc objects >= 10k) ensures GC
only fires when needed, not on every 10ms loop tick.

Verified: RSS stable at ~90MB (vs 40MB/min growth without, and SIGSEGV
with the timer-tick approach).

Author: proggeramlug

crates/perry-codegen/src/module_init.rs

@@ -798,11 +798,21 @@ impl crate::codegen::Compiler {
                         let has_work = builder.ins().icmp(IntCC::NotEqual, any_pending, zero_i32);
                         builder.ins().brif(has_work, loop_body, &[], loop_exit, &[]);
 
-                        // loop_body: tick both timer queues, sleep 10ms, jump back
+                        // loop_body: tick both timer queues, then GC, sleep 10ms, jump back
                         builder.switch_to_block(loop_body);
                         builder.seal_block(loop_body);
                         builder.ins().call(int_tick_ref, &[]);
                         builder.ins().call(cb_tick_ref, &[]);
+
+                        // GC safe point: timer callbacks have returned, so all live JS values
+                        // are stored in module globals, closure boxes, or timer root lists —
+                        // NOT in registers. Uses threshold-based check (not unconditional
+                        // collection) to avoid the overhead of running GC on every loop tick.
+                        if let Some(&gc_trigger_func) = self.extern_funcs.get("gc_check_trigger_export") {
+                            let gc_ref = self.module.declare_func_in_func(gc_trigger_func, builder.func);
+                            builder.ins().call(gc_ref, &[]);
+                        }
+
                         let ten_ms = builder.ins().f64const(10.0);
                         builder.ins().call(sleep_ref, &[ten_ms]);
                         builder.ins().jump(loop_header, &[]);

crates/perry-codegen/src/runtime_decls.rs

@@ -10710,6 +10710,14 @@ impl Compiler {
             self.extern_funcs.insert(Cow::Borrowed("gc"), func_id);
         }
 
+        // gc_check_trigger_export() -> void
+        // Threshold-based GC trigger for the event loop (only collects if needed)
+        {
+            let sig = self.module.make_signature();
+            let func_id = self.module.declare_function("gc_check_trigger_export", Linkage::Import, &sig)?;
+            self.extern_funcs.insert(Cow::Borrowed("gc_check_trigger_export"), func_id);
+        }
+
         // js_gc_register_global_root(ptr: i64) -> void
         {
             let mut sig = self.module.make_signature();

crates/perry-runtime/src/gc.rs

@@ -259,6 +259,13 @@ pub extern "C" fn js_gc_collect() {
     gc_collect_inner();
 }
 
+/// Threshold-based GC trigger (safe for use from the event loop).
+/// Only runs collection if arena or malloc thresholds are exceeded.
+#[no_mangle]
+pub extern "C" fn gc_check_trigger_export() {
+    gc_check_trigger();
+}
+
 /// Main GC collection
 fn gc_collect_inner() {
     let start = std::time::Instant::now();