@mikrojs/native 0.12.0-next.9.g2e06437 → 0.13.0

package/CMakeLists.txt

@@ -81,7 +81,7 @@ endif()
 include(cmake/mikrojs_bytecode.cmake)
 mikrojs_generate_bytecode(
     RUNTIME_DIR "${CMAKE_CURRENT_SOURCE_DIR}/runtime"
-    MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared module neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi
+    MODULES abort cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared module neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi
     MODULE_PREFIX "mikro"
     SYMBOL_PREFIX "mikro"
     TARGET gen_bytecode
@@ -152,6 +152,7 @@ if(BUILD_TESTING)
         test/main.cpp
         test/runtime_test.cpp
         test/modules_test.cpp
+        test/virtual_modules_test.cpp
         test/text_encoding_test.cpp
         test/cbor_test.cpp
         test/abort_test.cpp
@@ -163,6 +164,7 @@ if(BUILD_TESTING)
         test/runtime_recycle_test.cpp
         test/udp_test.cpp
         test/observable_test.cpp
+        test/unhandled_rejection_test.cpp
     )
 
     target_link_libraries(mikrojs_tests PRIVATE mikrojs)

package/include/mikrojs/mikrojs.h

@@ -86,6 +86,13 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt);
  * Emits no diagnostic output — callers decide whether and how to log. */
 int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry);
 
+/* MIK_RunEntry variant that, on -EFAULT, copies the thrown exception's
+ * string form (or the sync-rejected promise's rejection value) into
+ * err_buf so callers can surface the real failure instead of a generic
+ * "evaluation threw". err_buf may be NULL; when given it is always
+ * NUL-terminated (empty when no message could be captured). */
+int MIK_RunEntryErr(MIKRuntime* mik_rt, const char* entry, char* err_buf, size_t err_buf_size);
+
 JSContext* MIK_GetJSContext(MIKRuntime* mik_rt);
 MIKRuntime* MIK_GetRuntime(JSContext* ctx);
 void MIK_SetFSBasePath(MIKRuntime* mik_rt, const char* base_path);

package/include/mikrojs/platform.h

@@ -64,6 +64,15 @@ typedef struct MIKPlatform {
      *  original 6 MAC bytes. The returned pointer must remain valid for the
      *  lifetime of the platform. */
     const char* (*get_device_id)(void);
+    /** Reason the chip last reset, as a stable lowercase string. On ESP32
+     *  this maps esp_reset_reason(): "power-on", "software", "panic",
+     *  "watchdog", "interrupt-watchdog", "task-watchdog", "brownout",
+     *  "deep-sleep", "external", "sdio", "usb", "jtag", "efuse",
+     *  "power-glitch", "cpu-lockup", or "unknown". A clean restart()
+     *  reports "software". Host platforms have no reset concept and return
+     *  "unknown". The returned pointer must remain valid for the lifetime
+     *  of the platform. */
+    const char* (*get_reset_reason)(void);
 } MIKPlatform;
 
 /* Log levels (matching ESP-IDF ESP_LOG_xxx values) */

package/include/mikrojs/private.h

@@ -48,6 +48,15 @@ struct MIKLoopConsumerEntry {
     MIKLoopDestroyFn destroy_fn;
 };
 
+/* A promise that rejected without a handler, awaiting the end-of-turn
+ * unhandled-rejection check. Mirrors quickjs-libc's JSRejectedPromiseEntry:
+ * we hold a reference to both the promise (matched by identity on `handle`)
+ * and its reason (reported at flush time). */
+struct MIKRejectedPromise {
+    JSValue promise;
+    JSValue reason;
+};
+
 struct MIKRuntime {
     MIKRunOptions options;
     MIKConfig config;
@@ -83,10 +92,16 @@ struct MIKRuntime {
     MIKTimerRegistry* timers;
     std::vector<MIKNativeModuleEntry> native_modules;
     std::vector<MIKLoopConsumerEntry> loop_consumers;
-    struct {
-        JSValue promise_event_ctor;
-        JSValue dispatch_event_func;
-    } builtins;
+    /* Promises that rejected without a handler, awaiting the end-of-turn
+     * unhandled-rejection check. The host rejection tracker adds a promise
+     * here on `reject` and removes it on `handle`; whatever remains after a
+     * microtask drain (mik__execute_jobs) is a genuine unhandled rejection
+     * and gets reported. This deferral mirrors the HTML/WinterCG algorithm
+     * and is what prevents a transiently-unhandled promise (e.g. a module's
+     * evaluation promise, rejected before the import loader attaches its
+     * .then) from being reported. Entries hold dup'd references owned by this
+     * vector and freed when removed or flushed. */
+    std::vector<MIKRejectedPromise> pending_rejections;
     /* Shared prototype for Result objects ({ok, value} / {ok, error}) created
      * by mik__result_ok/mik__result_err and the native:result ok()/err()
      * functions.  Holds .map/.mapErr/.andThen/.match/.orDefault/.orPanic +
@@ -167,6 +182,10 @@ JSValue mik_new_error(JSContext* ctx, int err);
 JSValue mik_throw_errno(JSContext* ctx, int err);
 
 void mik__execute_jobs(JSContext* ctx);
+/* End-of-turn unhandled-rejection check; called after each microtask drain. */
+void mik__flush_unhandled_rejections(JSContext* ctx);
+/* Drop a promise from the pending-rejection queue without reporting it. */
+void mik__forget_rejection(JSContext* ctx, JSValue promise);
 JSModuleDef* mik__load_builtin(JSContext* ctx, const char* name);
 int mik__load_file(JSContext* ctx, DynBuf* dbuf, const char* filename);
 void mik__resolve_fs_path(JSContext* ctx, const char* module_name, char* out, size_t out_size);
@@ -221,7 +240,10 @@ void mik__stdin_consume(JSContext* ctx);
 
 /* Console global (mik_console.cpp) */
 void mik__console_init(JSContext* ctx, JSValue global_obj);
-void mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise = false);
+/* Reports an uncaught error/rejection. Dedups by error-object identity:
+ * returns true if it reported, false if this same object was already
+ * reported. */
+bool mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise = false);
 
 /* Inspect (mik_inspect.cpp) */
 std::string mik_inspect(JSContext* ctx, JSValue value, int depth = 2, bool colors = false,
@@ -313,6 +335,11 @@ void mik__repl_set_paused(bool paused);
  * Device replies with zero-or-more MIK_MSG_FS_CHUNK frames followed by
  * MIK_MSG_OK on EOF, or MIK_MSG_ERR if the path can't be opened. */
 #define MIK_CMD_FS_GET 0x2B
+/* Clear the on-device log files (log.txt + log.txt.1). No payload.
+ * Device suspends the logger, deletes both files, reopens a fresh
+ * log.txt, and replies MIK_MSG_OK. No-op (still OK) when file logging
+ * is disabled. */
+#define MIK_CMD_LOG_RESET 0x2C
 
 #define MIK_CMD_CONFIG_LIST 0x40
 #define MIK_CMD_CONFIG_SET 0x41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/native",
-  "version": "0.12.0-next.9.g2e06437",
+  "version": "0.13.0",
   "description": "Mikro.js C++ runtime library and Node.js native addon",
   "keywords": [
     "esp32",
@@ -80,7 +80,7 @@
     "cmake-js": "^8.0.0",
     "node-addon-api": "^8.7.0",
     "node-gyp-build": "^4.8.4",
-    "@mikrojs/quickjs": "0.12.0-next.9.g2e06437"
+    "@mikrojs/quickjs": "0.13.0"
   },
   "devDependencies": {
     "@swc/core": "^1.15.30",

package/runtime/abort/abort.ts

@@ -0,0 +1,120 @@
+/* Minimal AbortController / AbortSignal implementation.
+ *
+ * This is a lightweight subset of the WHATWG DOM spec: just enough
+ * for fetch timeouts and cooperative cancellation. No EventTarget
+ * dependency: listeners are stored in a simple array.
+ *
+ * Evaluating this module installs AbortController, AbortSignal,
+ * AbortError, and TimeoutError on globalThis. It is loaded lazily by
+ * the native lazy getters in mik_abort.cpp on first access to any of
+ * the four globals; shipping it as precompiled bytecode keeps the
+ * QuickJS parser out of the install path (parsing at runtime caused
+ * OOM on low-memory chips).
+ */
+
+class AbortError extends Error {
+  constructor(message?: string) {
+    super(message || 'The operation was aborted')
+  }
+  get name() {
+    return 'AbortError'
+  }
+}
+
+class TimeoutError extends Error {
+  constructor(message?: string) {
+    super(message || 'The operation timed out')
+  }
+  get name() {
+    return 'TimeoutError'
+  }
+}
+
+const _a: unique symbol = Symbol()
+const _r: unique symbol = Symbol()
+const _l: unique symbol = Symbol()
+const _s: unique symbol = Symbol()
+
+function doAbort(signal: AbortSignal, reason: unknown): void {
+  if (signal[_a]) return
+  signal[_a] = true
+  signal[_r] = reason
+  if (typeof signal.onabort === 'function') signal.onabort()
+  for (const fn of signal[_l]) fn()
+}
+
+class AbortSignal {
+  [_a] = false;
+  [_r]: unknown = undefined;
+  [_l]: (() => void)[] = []
+  onabort: (() => void) | null = null
+
+  get aborted(): boolean {
+    return this[_a]
+  }
+  get reason(): unknown {
+    return this[_r]
+  }
+  throwIfAborted(): void {
+    if (this[_a]) throw this[_r]
+  }
+  addEventListener(type: 'abort', fn: () => void): void {
+    if (type === 'abort' && typeof fn === 'function') this[_l].push(fn)
+  }
+  removeEventListener(type: 'abort', fn: () => void): void {
+    if (type === 'abort') this[_l] = this[_l].filter((f) => f !== fn)
+  }
+  static abort(reason?: unknown): AbortSignal {
+    const s = new AbortSignal()
+    doAbort(s, reason !== undefined ? reason : new AbortError())
+    return s
+  }
+  static timeout(ms: number): AbortSignal {
+    const s = new AbortSignal()
+    setTimeout(() => doAbort(s, new TimeoutError()), ms)
+    return s
+  }
+  static any(signals: AbortSignal[]): AbortSignal {
+    const s = new AbortSignal()
+    for (const i of signals) {
+      if (i.aborted) {
+        doAbort(s, i.reason)
+        return s
+      }
+    }
+    for (const i of signals) {
+      i.addEventListener('abort', () => doAbort(s, i.reason))
+    }
+    return s
+  }
+}
+
+class AbortController {
+  [_s] = new AbortSignal()
+
+  get signal(): AbortSignal {
+    return this[_s]
+  }
+  abort(reason?: unknown): void {
+    doAbort(this[_s], reason !== undefined ? reason : new AbortError())
+  }
+}
+
+/* Object.defineProperties, NOT Object.assign: when this module is
+ * evaluated via a direct `import 'mikro/abort'` (it is in the builtins
+ * table), the four lazy getters installed by mik_abort.cpp are still
+ * present as setter-less accessors, and Object.assign's [[Set]] would
+ * throw "no setter for property". Defining replaces the accessors with
+ * plain data properties, matching what the lazy-getter path produces. */
+const descriptor = (value: unknown) => ({
+  value,
+  writable: true,
+  enumerable: true,
+  configurable: true,
+})
+Object.defineProperties(globalThis, {
+  AbortError: descriptor(AbortError),
+  TimeoutError: descriptor(TimeoutError),
+  AbortSignal: descriptor(AbortSignal),
+  AbortController: descriptor(AbortController),
+})

package/runtime/internal.d.ts

@@ -34,7 +34,7 @@ declare module 'native:observable' {
 }
 
 declare module 'native:sys' {
-  import type {JsMemoryUsage} from './sys/types.js'
+  import type {JsMemoryUsage, ResetReason} from './sys/types.js'
   export function evalScript(code: string): Promise<{value: unknown}>
   export function memoryUsage(): {
     heapUsed: number
@@ -67,6 +67,7 @@ declare module 'native:sys' {
   }
   export const firmware: {hash: string; date: string; idfVersion: string | undefined}
   export const deviceId: string
+  export const resetReason: ResetReason
 }
 
 declare module 'native:fs' {

package/runtime/sys/sys.ts

@@ -37,6 +37,8 @@ export const firmware = native.firmware
 
 export const deviceId: string = native.deviceId
 
+export const resetReason = native.resetReason
+
 export function restart(): never {
   return native.restart() as never
 }

package/runtime/sys/types.ts

@@ -73,7 +73,10 @@ export interface JsMemoryUsage {
   arrayCount: number
   /** Total element slots across all fast arrays */
   fastArrayElements: number
-  /** Bytes of backing storage for ArrayBuffer / TypedArray data */
+  /** Cumulative bytes deserialized via JS_ReadObject over this
+   *  runtime's lifetime (bytecode of imported modules, builtins, and
+   *  bjson). A monotonic counter, NOT live memory — it never goes
+   *  down, so don't read it as retained ArrayBuffer storage. */
   binaryObjectSize: number
 }
 
@@ -122,6 +125,29 @@ export declare const firmware: {
   readonly idfVersion: string | undefined
 }
 
+/** Why the device last reset. A clean `restart()` reports `'software'`;
+ *  a crash reports `'panic'`. Host/Node builds always report `'unknown'`. */
+export type ResetReason =
+  | 'power-on'
+  | 'software'
+  | 'panic'
+  | 'watchdog'
+  | 'interrupt-watchdog'
+  | 'task-watchdog'
+  | 'brownout'
+  | 'deep-sleep'
+  | 'external'
+  | 'sdio'
+  | 'usb'
+  | 'jtag'
+  | 'efuse'
+  | 'power-glitch'
+  | 'cpu-lockup'
+  | 'unknown'
+
+/** Reason the device last reset, determined once at boot. */
+export declare const resetReason: ResetReason
+
 export declare function restart(): never
 
 /** Reason the device woke up this boot. Set after deep sleep (or first

package/runtime/test/test.ts

@@ -30,6 +30,17 @@ interface Suite {
 const suites: Suite[] = []
 let currentSuite: Suite | null = null
 let heapBaseline = 0
+/** Free system heap (bytes) at the baseline point, or 0 on the host (no
+ *  system heap). Reference point for the "peak" figure: baseline free minus
+ *  the run's low-water is the most the suite needed at once. Recaptured after
+ *  each suite's beforeAll, in step with heapBaseline, so warmup is excluded
+ *  from the figure. */
+let sysFreeStart = 0
+/** Lowest free system heap (bytes) sampled (post-gc) this run, or 0 on the
+ *  host. The suite's closest sampled approach to OOM. The module re-inits
+ *  for each test file (fresh runtime per file), so this is a true per-file
+ *  figure, not a process-lifetime watermark shared across files. */
+let sysFreeFloor = 0
 
 /**
  * Recapture the heap baseline. Called by the harness after each suite's
@@ -43,7 +54,15 @@ let heapBaseline = 0
 async function captureHeapBaseline(): Promise<void> {
   await Promise.resolve()
   gc()
-  heapBaseline = memoryUsage().heapUsed
+  const {heapUsed, systemFree} = memoryUsage()
+  heapBaseline = heapUsed
+  // Recapture the system-heap baseline and reset the per-file low-water in
+  // step with heapBaseline, so warmup (module loads, TLS, wifi) is excluded
+  // from sysUsed the same way it is from heapDelta.
+  if (systemFree > 0) {
+    sysFreeStart = systemFree
+    sysFreeFloor = systemFree
+  }
 }
 
 function newSuite(name: string, flags: {skip?: boolean; only?: boolean; todo?: boolean}): Suite {
@@ -363,6 +382,8 @@ type TestEvent =
       d: number
       hb?: number
       ha?: number
+      su?: number
+      sf?: number
       tb?: number
       ta?: number
       pb?: number
@@ -401,7 +422,10 @@ function emitHeap(): void {
   gc()
   const mem = memoryUsage()
   const evt: TestEvent = {e: 8, u: mem.heapUsed, t: mem.heapTotal}
-  if (mem.systemFree > 0) evt.f = mem.systemFree
+  if (mem.systemFree > 0) {
+    evt.f = mem.systemFree
+    if (sysFreeFloor === 0 || mem.systemFree < sysFreeFloor) sysFreeFloor = mem.systemFree
+  }
   if (mem.systemMinFree > 0) evt.mf = mem.systemMinFree
   emit(evt)
 }
@@ -420,7 +444,14 @@ async function run(): Promise<void> {
   // warmup costs (module loads, TLS lazy-init, wifi connection) get
   // folded into the baseline automatically.
   gc()
-  heapBaseline = memoryUsage().heapUsed
+  // Destructure to primitives so the live memoryUsage() object isn't held
+  // while heapBaseline is captured (it would otherwise be counted in it).
+  const {heapUsed: startHeap, systemFree: startFree} = memoryUsage()
+  heapBaseline = startHeap
+  if (startFree > 0) {
+    sysFreeStart = startFree
+    sysFreeFloor = startFree
+  }
   const timersBefore = activeTimers()
   const pendingBefore = pendingHttpCount()
 
@@ -569,11 +600,23 @@ async function run(): Promise<void> {
   }
 
   gc()
-  const heapAfter = memoryUsage().heapUsed
+  // Destructure to primitives (see baseline capture above) so the live
+  // memoryUsage() object isn't held while we build the run_done event.
+  const {heapUsed: heapAfter, systemFree: endFree} = memoryUsage()
+  if (endFree > 0 && (sysFreeFloor === 0 || endFree < sysFreeFloor)) {
+    sysFreeFloor = endFree
+  }
   const timersAfter = activeTimers()
   const pendingAfter = pendingHttpCount()
 
-  emit({
+  // Per-file system-heap figures. sysFreeFloor is the lowest free heap we
+  // sampled (post-gc) this run; sysUsed is how far free heap fell from the
+  // baseline to that low. They sum back to the baseline free, so "peak" and
+  // "min free" read as one story. Samples are taken between tests, so a
+  // transient peak inside a single test can dip below what sysFreeFloor saw.
+  const sysUsed = sysFreeStart > sysFreeFloor ? sysFreeStart - sysFreeFloor : 0
+
+  const doneEvt: TestEvent = {
     e: 6,
     p: passed,
     f: failed,
@@ -586,7 +629,12 @@ async function run(): Promise<void> {
     ta: timersAfter,
     pb: pendingBefore,
     pa: pendingAfter,
-  })
+  }
+  if (sysFreeStart > 0) {
+    doneEvt.su = sysUsed
+    doneEvt.sf = sysFreeFloor
+  }
+  emit(doneEvt)
 
   // Signal the supervisor (if any) that this file is complete so it can
   // swap in the next runtime. No-op in non-test-harness contexts.

package/src/builtins.cpp

@@ -32,11 +32,16 @@ static JSModuleDef* mik__deserialize_builtin(JSContext* ctx, const char* name,
     JSValue obj = JS_ReadObject(ctx, data, data_size, JS_READ_OBJ_BYTECODE);
 
     if (JS_IsException(obj)) {
-        platform->log(MIK_LOG_ERROR, "mikrojs", "Failed to deserialize bytecode for builtin '%s' (%u bytes)", name,
-                 data_size);
-        /* Leave the JS exception on ctx so the caller can propagate the
-         * real error (e.g. "Maximum call stack size exceeded") instead of
-         * replacing it with a generic "not available" message. */
+        /* Peek the exception for the log, then re-throw it so the caller
+         * can still propagate the real error (e.g. "Maximum call stack
+         * size exceeded") instead of a generic "not available" message. */
+        JSValue exc = JS_GetException(ctx);
+        const char* msg = JS_ToCString(ctx, exc);
+        platform->log(MIK_LOG_ERROR, "mikrojs",
+                 "Failed to deserialize bytecode for builtin '%s' (%u bytes): %s", name,
+                 data_size, msg ? msg : "unknown error");
+        if (msg) JS_FreeCString(ctx, msg);
+        JS_Throw(ctx, exc);
         return NULL;
     }
 

package/src/mik_abort.cpp

@@ -1,110 +1,32 @@
 #include <quickjs.h>
 
+#include "mikrojs/private.h"
 #include "mikrojs/utils.h"
 
-/* Minimal AbortController / AbortSignal implementation.
+/* AbortController / AbortSignal globals.
  *
- * This is a lightweight subset of the WHATWG DOM spec — just enough
- * for fetch timeouts and cooperative cancellation.  No EventTarget
- * dependency: listeners are stored in a simple array.
+ * The implementation lives in runtime/abort/abort.ts and ships as
+ * precompiled bytecode in the builtins table ("mikro/abort").
+ * Evaluating that module installs AbortController, AbortSignal,
+ * AbortError, and TimeoutError on globalThis.
  *
- * Implements:
- *   AbortSignal: aborted, reason, throwIfAborted(), onabort,
- *                addEventListener("abort", fn), removeEventListener("abort", fn)
- *   AbortSignal.abort(reason)   — pre-aborted signal
- *   AbortSignal.timeout(ms)     — auto-aborts after delay
- *   AbortSignal.any(signals)    — aborts when any input signal aborts
- *   AbortController: signal, abort(reason)
- *
- * Lazy-initialized: the JS class hierarchy is compiled and installed
- * on first access to any of the four globals (AbortController,
- * AbortSignal, AbortError, TimeoutError).
+ * Lazy-initialized: this file installs lazy getters for the four
+ * globals; the first access evaluates the bytecode module. Bytecode
+ * (rather than JS source evaluated at runtime) keeps the QuickJS
+ * parser out of the install path — the parse peak pushed low-memory
+ * chips into OOM when the heap was already near full.
  */
 
-static const char abort_js[] = R"JS(
-(function(g) {
-  "use strict";
-
-  class AbortError extends Error {
-    constructor(message) { super(message || "The operation was aborted"); }
-    get name() { return "AbortError"; }
-  }
-  class TimeoutError extends Error {
-    constructor(message) { super(message || "The operation timed out"); }
-    get name() { return "TimeoutError"; }
-  }
-
-  const _a = Symbol(), _r = Symbol(), _l = Symbol(), _s = Symbol();
-  const ABORT_REASON = () => new AbortError();
-
-  function doAbort(signal, reason) {
-    if (signal[_a]) return;
-    signal[_a] = true;
-    signal[_r] = reason;
-    if (typeof signal.onabort === "function") signal.onabort();
-    for (const fn of signal[_l]) fn();
-  }
-
-  class AbortSignal {
-    constructor() {
-      this[_a] = false;
-      this[_r] = undefined;
-      this[_l] = [];
-      this.onabort = null;
-    }
-    get aborted() { return this[_a]; }
-    get reason() { return this[_r]; }
-    throwIfAborted() { if (this[_a]) throw this[_r]; }
-    addEventListener(type, fn) {
-      if (type === "abort" && typeof fn === "function") this[_l].push(fn);
-    }
-    removeEventListener(type, fn) {
-      if (type === "abort") this[_l] = this[_l].filter(f => f !== fn);
-    }
-    static abort(reason) {
-      const s = new AbortSignal();
-      doAbort(s, reason !== undefined ? reason : ABORT_REASON());
-      return s;
-    }
-    static timeout(ms) {
-      const s = new AbortSignal();
-      setTimeout(() => doAbort(s, new TimeoutError()), ms);
-      return s;
-    }
-    static any(signals) {
-      const s = new AbortSignal();
-      for (const i of signals) {
-        if (i.aborted) { doAbort(s, i.reason); return s; }
-      }
-      for (const i of signals) {
-        i.addEventListener("abort", () => doAbort(s, i.reason));
-      }
-      return s;
-    }
-  }
-
-  class AbortController {
-    constructor() { this[_s] = new AbortSignal(); }
-    get signal() { return this[_s]; }
-    abort(reason) { doAbort(this[_s], reason !== undefined ? reason : ABORT_REASON()); }
-  }
-
-  g.AbortError = AbortError;
-  g.TimeoutError = TimeoutError;
-  g.AbortSignal = AbortSignal;
-  g.AbortController = AbortController;
-})
-)JS";
-
-/* Names of the globals this module installs */
+/* Names of the globals the abort module installs */
 static const char* const abort_global_names[] = {"AbortController", "AbortSignal", "AbortError",
                                                   "TimeoutError"};
 static constexpr int ABORT_GLOBAL_COUNT = 4;
 
 /**
  * Lazy getter: on first access to any of the four globals, delete all
- * lazy getters, evaluate the JS to install real values, then return
- * the requested one.  The magic parameter identifies which global.
+ * lazy getters, evaluate the bytecode module to install real values,
+ * then return the requested one. The magic parameter identifies which
+ * global.
  *
  * Signature must match JS_CFUNC_getter_magic: (ctx, this_val, magic).
  */
@@ -112,29 +34,40 @@ static JSValue mik__abort_lazy_get(JSContext* ctx, JSValue this_val, int magic)
 
     JSValue global_obj = JS_GetGlobalObject(ctx);
 
-    /* Remove all four lazy getters so the JS assignment (g.X = Y) works */
+    /* Remove all four lazy getters so the module's globalThis
+     * assignments define plain properties */
     for (int i = 0; i < ABORT_GLOBAL_COUNT; i++) {
         JSAtom prop = JS_NewAtom(ctx, abort_global_names[i]);
         JS_DeleteProperty(ctx, global_obj, prop, 0);
         JS_FreeAtom(ctx, prop);
     }
 
-    /* Evaluate and install the real globals */
-    JSValue wrapper =
-        JS_Eval(ctx, abort_js, sizeof(abort_js) - 1, "<abort>", JS_EVAL_TYPE_GLOBAL);
-    if (JS_IsException(wrapper)) {
-        JSValue exc = JS_GetException(ctx);
-        JS_FreeValue(ctx, exc);
+    /* Evaluate the precompiled module; its side effect installs the
+     * globals. The module is synchronous, so the returned promise is
+     * already settled. */
+    JSModuleDef* m = mik__load_builtin(ctx, "mikro/abort");
+    if (m == NULL) {
+        /* A table miss returns NULL with no pending exception (only
+         * deserialize failures throw); without this guard the getter
+         * would surface a bare 'null'. Mirrors the module loader's
+         * missing-builtin fallback. */
+        if (!JS_HasException(ctx)) {
+            JS_ThrowReferenceError(ctx,
+                                   "Builtin module 'mikro/abort' is not available in this build");
+        }
         JS_FreeValue(ctx, global_obj);
-        return JS_UNDEFINED;
+        return JS_EXCEPTION;
     }
-    JSValue ret = JS_Call(ctx, wrapper, JS_UNDEFINED, 1, &global_obj);
-    JS_FreeValue(ctx, wrapper);
+    JSValue ret = JS_EvalFunction(ctx, JS_DupValue(ctx, JS_MKPTR(JS_TAG_MODULE, m)));
     if (JS_IsException(ret)) {
-        JSValue exc = JS_GetException(ctx);
-        JS_FreeValue(ctx, exc);
         JS_FreeValue(ctx, global_obj);
-        return JS_UNDEFINED;
+        return JS_EXCEPTION;
+    }
+    if (JS_PromiseState(ctx, ret) == JS_PROMISE_REJECTED) {
+        JSValue err = JS_PromiseResult(ctx, ret);
+        JS_FreeValue(ctx, ret);
+        JS_FreeValue(ctx, global_obj);
+        return JS_Throw(ctx, err);
     }
     JS_FreeValue(ctx, ret);
 
@@ -145,7 +78,7 @@ static JSValue mik__abort_lazy_get(JSContext* ctx, JSValue this_val, int magic)
 }
 
 void mik__abort_init(JSContext* ctx, JSValue global_obj) {
-    /* Install lazy getters instead of eagerly evaluating the JS.
+    /* Install lazy getters instead of eagerly evaluating the module.
      * Each getter shares the same C function, distinguished by magic. */
     for (int i = 0; i < ABORT_GLOBAL_COUNT; i++) {
         JSAtom prop = JS_NewAtom(ctx, abort_global_names[i]);

package/src/mik_console.cpp

@@ -236,31 +236,32 @@ static JSValue mik__console_error_warn(JSContext* ctx, JSValue this_val, int arg
 
 /* ── Uncaught error reporting ─────────────────────────────────────── */
 
-/* Dedup: the rejection tracker can fire multiple times for the same
- * error (e.g. inner Promise.reject + async wrapper rejection). Skip
- * if the same object pointer was just reported. */
-static void* last_reported_ptr = nullptr;
-static int64_t last_reported_time = 0;
-
-void mik__report_uncaught_reset(void) {
-    last_reported_ptr = nullptr;
-}
-
-void mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise) {
+/* Dedup across report paths: one error can reach this function more than
+ * once for a single failure. A failed dynamic import leaves two never-handled
+ * promises with the SAME reason (QuickJS runs a module body as an async
+ * function and reads its rejected result by value, plus the rejection
+ * propagated up the await chain), and at the REPL the throw path reports an
+ * error the deferred flush then sees again. Mark the error object the first
+ * time it is reported and skip it afterwards. Keying on object identity is
+ * exact and time-independent; a recycled address belongs to a fresh object
+ * with no marker, so distinct errors are never suppressed. Primitive
+ * rejections (e.g. a null OOM rejection) can't hold a marker and are always
+ * reported. Returns true if it reported, false if it was a duplicate. */
+bool mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise) {
     if (JS_IsObject(exc)) {
-        void* ptr = JS_VALUE_GET_PTR(exc);
-        int64_t now = MIK_GetPlatform()->get_boot_us();
-        /* Deduplicate only within 1ms — the rejection tracker can fire
-         * twice for the same error (inner + async wrapper) essentially
-         * instantly, but a new error 1s later at a recycled address
-         * must not be suppressed. */
-        if (ptr == last_reported_ptr && (now - last_reported_time) < 1000) {
-            return;
+        JSAtom marker = JS_NewAtom(ctx, "\xff" "mik_reported");
+        if (marker != JS_ATOM_NULL) {
+            if (JS_HasProperty(ctx, exc, marker) > 0) {
+                JS_FreeAtom(ctx, marker);
+                return false;
+            }
+            /* Non-enumerable, non-writable, non-configurable so it stays
+             * invisible to user code. Best-effort: JS_* calls return error
+             * codes (no C++ throw), so under OOM we just report without
+             * dedup rather than abort. */
+            JS_DefinePropertyValue(ctx, exc, marker, JS_TRUE, 0);
+            JS_FreeAtom(ctx, marker);
         }
-        last_reported_ptr = ptr;
-        last_reported_time = now;
-    } else {
-        last_reported_ptr = nullptr;
     }
 
     /* Fixed-size stack buffer so this function never allocates from the
@@ -360,11 +361,12 @@ void mik__report_uncaught(JSContext* ctx, JSValue exc, bool in_promise) {
 
     if (mik__repl_is_protocol_mode()) {
         mik__repl_proto_send_output(MIK_MSG_ERROR, buf, pos);
-        return;
+        return true;
     }
 
     append_cstr("\r\n");
     MIK_GetPlatform()->stderr_write(buf, pos);
+    return true;
 }
 
 /* ── Test emit ────────────────────────────────────────────────────── */

package/src/mik_inspect.cpp

@@ -805,7 +805,7 @@ std::string mik_inspect(JSContext* ctx, JSValue value, int depth, bool colors, b
     return inspect_value(ctx, value, opts, depth);
 }
 
-/* ── JS-callable inspect function (for mikrojs/inspect module) ───── */
+/* ── JS-callable inspect function (for mikro/inspect module) ───── */
 
 static JSValue mik__inspect_js(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     if (argc < 1) return JS_NewString(ctx, "undefined");
@@ -836,14 +836,14 @@ static JSValue mik__inspect_js(JSContext* ctx, JSValue this_val, int argc, JSVal
     return JS_NewString(ctx, result.c_str());
 }
 
-/* Module init for 'mikrojs/inspect' native C module */
+/* Module init for 'mikro/inspect' native C module */
 int mik__inspect_module_init(JSContext* ctx, JSModuleDef* m) {
     return JS_SetModuleExport(ctx, m, "inspect",
                               JS_NewCFunction(ctx, mik__inspect_js, "inspect", 1));
 }
 
 void mik__inspect_register(JSContext* ctx) {
-    JSModuleDef* m = JS_NewCModule(ctx, "mikrojs/inspect", mik__inspect_module_init);
+    JSModuleDef* m = JS_NewCModule(ctx, "mikro/inspect", mik__inspect_module_init);
     if (m) {
         JS_AddModuleExport(ctx, m, "inspect");
     }

package/src/mik_repl.cpp

@@ -263,6 +263,10 @@ static JSValue repl_eval_and_pump(JSContext* ctx, const char* code, size_t len)
             return pr;
         }
         if (state == JS_PROMISE_REJECTED) {
+            /* This promise's rejection is about to be reported via the throw
+             * path below; drop it from the deferred unhandled-rejection queue
+             * so the end-of-turn flush doesn't report it a second time. */
+            mik__forget_rejection(ctx, result);
             JSValue reason = JS_PromiseResult(ctx, result);
             JS_FreeValue(ctx, result);
             JS_Throw(ctx, reason);

package/src/mik_sys.cpp

@@ -260,7 +260,17 @@ void mik__sys_api_init(JSContext* ctx, JSValue ns) {
     JS_SetPropertyStr(ctx, ns, "board", mik__sys_board(ctx));
     JS_SetPropertyStr(ctx, ns, "firmware", mik__sys_firmware(ctx));
 
-    const char* device_id = MIK_GetPlatform()->get_device_id();
+    /* Guard the platform function POINTERS, not just their results: a
+     * platform that omits an optional hook leaves a NULL pointer, and
+     * calling it is a segfault with no diagnostics (the sim was down for
+     * weeks because platform_node lacked get_reset_reason). */
+    const MIKPlatform* platform = MIK_GetPlatform();
+    const char* device_id = platform->get_device_id ? platform->get_device_id() : NULL;
     JS_SetPropertyStr(ctx, ns, "deviceId",
                       device_id ? JS_NewString(ctx, device_id) : JS_UNDEFINED);
+
+    const char* reset_reason =
+        platform->get_reset_reason ? platform->get_reset_reason() : NULL;
+    JS_SetPropertyStr(ctx, ns, "resetReason",
+                      JS_NewString(ctx, reset_reason ? reset_reason : "unknown"));
 }

package/src/mikrojs.cpp

@@ -2,6 +2,7 @@
 
 #include <quickjs.h>
 
+#include <atomic>
 #include <cerrno>
 #include <cstdio>
 #include <fcntl.h>
@@ -91,7 +92,7 @@ static void mik__add_exports(JSContext* ctx, JSModuleDef* m, const char* const*
 static const char* const sys_exports[] = {
     "evalScript", "memoryUsage", "jsMemoryUsage",  "gc",          "setTime",
     "uptime",     "restart",     "version",        "board",       "firmware",
-    "deviceId",   "activeTimers", "unloadNamespace", "isUnloadableNamespace"};
+    "deviceId",   "resetReason", "activeTimers",   "unloadNamespace", "isUnloadableNamespace"};
 
 static int mik__sys_module_init(JSContext* ctx, JSModuleDef* m) {
     JSValue ns = JS_NewObjectProto(ctx, JS_NULL);
@@ -111,21 +112,19 @@ static int mik__stdio_module_init(JSContext* ctx, JSModuleDef* m) {
     return 0;
 }
 
-static JSValue mik__dispatch_event(JSContext* ctx, JSValue* event) {
-    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    CHECK_NOT_NULL(mik_rt);
-
-    if (mik_rt->freeing) {
-        return JS_UNDEFINED;
-    }
-
-    JSValue global_obj = JS_GetGlobalObject(ctx);
-    JSValue ret = JS_Call(ctx, mik_rt->builtins.dispatch_event_func, global_obj, 1, event);
-    JS_FreeValue(ctx, global_obj);
-
-    return ret;
-}
-
+/* Host promise-rejection tracker. Rather than report eagerly the instant a
+ * promise rejects, defer the decision to the end-of-turn flush
+ * (mik__flush_unhandled_rejections): a promise that rejects without a
+ * handler is queued, and a promise that later gets a handler is removed
+ * from the queue. This mirrors the HTML/WinterCG unhandledrejection
+ * algorithm. It matters because some promises are born rejected before a
+ * handler can be attached. The clearest example is a module's evaluation
+ * promise, which the dynamic-import loader rejects (when the module body
+ * throws) and only then attaches its .then to. Reporting eagerly surfaced
+ * that transient rejection as a spurious second "Uncaught (in promise)".
+ *
+ * This is the same add-on-reject / remove-on-handle / report-after-drain
+ * pattern quickjs-libc's js_std_promise_rejection_tracker uses. */
 static void mik__promise_rejection_tracker(JSContext* ctx, JSValue promise, JSValue reason,
                                            bool is_handled, void* opaque) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
@@ -135,68 +134,109 @@ static void mik__promise_rejection_tracker(JSContext* ctx, JSValue promise, JSVa
         return;
     }
 
-    if (!is_handled) {
-        /* If the runtime hasn't loaded the event infrastructure yet,
-         * report and bail. */
-        if (JS_IsUndefined(mik_rt->builtins.promise_event_ctor) ||
-            JS_IsUndefined(mik_rt->builtins.dispatch_event_func)) {
-            /* During REPL eval, sync errors are wrapped by the async eval
-             * wrapper and appear as promise rejections — don't label them
-             * "(in promise)".  Outside eval (e.g. timer callbacks), they
-             * are genuine unhandled promise rejections. */
-            bool in_promise = !mik__repl_is_evaluating();
-            mik__report_uncaught(ctx, reason, in_promise);
-            /* Notify the error handler (e.g. host bridge) directly.
-             * Don't JS_Throw here — we're inside a QuickJS callback
-             * during promise resolution; throwing would corrupt engine
-             * state and cause mik__execute_jobs to dump the error a
-             * second time. MIK_Stop gates on whether we're inside an
-             * interactive REPL eval (skipping both the stop request and
-             * the restart) so a typo at the prompt doesn't reboot the
-             * device. */
-            if (mik_rt->error_handler_fn) {
-                mik_rt->error_handler_fn(ctx, reason, mik_rt->error_handler_opaque);
+    auto& pending = mik_rt->pending_rejections;
+    void* key = JS_VALUE_GET_PTR(promise);
+
+    if (is_handled) {
+        /* A handler was attached to a previously-rejected promise: cancel its
+         * pending report. */
+        for (size_t i = 0; i < pending.size(); i++) {
+            if (JS_VALUE_GET_PTR(pending[i].promise) == key) {
+                JS_FreeValue(ctx, pending[i].promise);
+                JS_FreeValue(ctx, pending[i].reason);
+                pending.erase(pending.begin() + i);
+                return;
             }
-            MIK_Stop(mik_rt);
-            return;
         }
+        return;
+    }
+
+    /* Rejected with no handler (yet): queue it. Hold references to both the
+     * promise and the reason so they stay alive until the end-of-turn check. */
+    pending.push_back({JS_DupValue(ctx, promise), JS_DupValue(ctx, reason)});
+}
 
-        JSValue event_name = JS_NewString(ctx, "unhandledrejection");
-        JSValue args[3];
-        args[0] = event_name;
-        args[1] = promise;
-        args[2] = reason;
-
-        JSValue event =
-            JS_CallConstructor(ctx, mik_rt->builtins.promise_event_ctor, countof(args), args);
-        if (JS_IsException(event)) {
-            JS_FreeValue(ctx, event_name);
-            mik_dump_error(ctx);
+/* Drop a promise from the pending-rejection queue without reporting it. The
+ * REPL eval pump calls this for the result promise it polls and reports via
+ * the throw path, so the end-of-turn flush doesn't report it a second time. */
+void mik__forget_rejection(JSContext* ctx, JSValue promise) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    if (!mik_rt) {
+        return;
+    }
+    auto& pending = mik_rt->pending_rejections;
+    void* key = JS_VALUE_GET_PTR(promise);
+    for (size_t i = 0; i < pending.size(); i++) {
+        if (JS_VALUE_GET_PTR(pending[i].promise) == key) {
+            JS_FreeValue(ctx, pending[i].promise);
+            JS_FreeValue(ctx, pending[i].reason);
+            pending.erase(pending.begin() + i);
             return;
         }
-        JSValue ret = mik__dispatch_event(ctx, &event);
+    }
+}
 
-        JS_FreeValue(ctx, event);
-        JS_FreeValue(ctx, event_name);
+/* End-of-turn unhandled-rejection check. Any promise still queued after a
+ * microtask drain rejected and never got a handler: report it, notify the
+ * host error handler, and halt. */
+void mik__flush_unhandled_rejections(JSContext* ctx) {
+    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+    if (!mik_rt || mik_rt->freeing || mik_rt->pending_rejections.empty()) {
+        return;
+    }
+    /* During interactive REPL eval, the eval pump polls its result promise
+     * and reports rejections via the throw path; leave the queue alone until
+     * the eval finishes so we don't fight that model. */
+    if (mik__repl_is_evaluating()) {
+        return;
+    }
 
-        if (JS_IsException(ret)) {
-            mik_dump_error(ctx);
-            goto fail;
-        } else {
-            if (JS_ToBool(ctx, ret)) {
-            // The event wasn't cancelled, maybe abort.
-            fail:;
-                MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-                CHECK_NOT_NULL(mik_rt);
-                mik__report_uncaught(ctx, reason, true);
-                if (mik_rt->error_handler_fn) {
-                    mik_rt->error_handler_fn(ctx, reason, mik_rt->error_handler_opaque);
-                }
-                MIK_Stop(mik_rt);
+    /* Move the queue aside before reporting. Reporting doesn't enqueue JS
+     * jobs, but this keeps the runtime's vector in a clean state regardless. */
+    std::vector<MIKRejectedPromise> rejected;
+    rejected.swap(mik_rt->pending_rejections);
+
+    /* One failed dynamic import leaves two never-handled promises with the
+     * SAME reason: the module's internal sync-evaluation promise (QuickJS runs
+     * a module body as an async function and reads its rejected result by
+     * value, never attaching a handler) and the promise the error propagates
+     * to up the await chain. mik__report_uncaught dedups by reason-object
+     * identity, so the second is a no-op; only act on a fresh report so the
+     * host bridge and the halt don't fire twice. (quickjs-libc reports every
+     * entry; we collapse same-error duplicates.) */
+    for (const MIKRejectedPromise& rp : rejected) {
+        if (mik__report_uncaught(ctx, rp.reason, true)) {
+            /* Notify the error handler (e.g. host bridge) directly. Don't
+             * JS_Throw here: we're between jobs, and throwing would be picked
+             * up as a spurious pending exception. */
+            if (mik_rt->error_handler_fn) {
+                mik_rt->error_handler_fn(ctx, rp.reason, mik_rt->error_handler_opaque);
             }
+            MIK_Stop(mik_rt);
         }
+        JS_FreeValue(ctx, rp.promise);
+        JS_FreeValue(ctx, rp.reason);
+    }
+}
 
-        JS_FreeValue(ctx, ret);
+/* QuickJS only runs the cycle collector automatically once malloc_size
+ * crosses the runtime's GC threshold (256 KB by default), and js_malloc_rt
+ * fails against the memory limit without attempting a GC first. On devices
+ * where mem_limit is below the default threshold the collector would never
+ * fire before allocations start failing, so cyclic garbage (promise chains,
+ * closures) accumulates straight into OOM with collectable memory still
+ * alive. Cap the threshold below the limit so collection happens first.
+ * QuickJS raises the threshold to 1.5x the live size after every GC pass,
+ * which can push it back above the limit, so MIK_Loop re-applies the cap
+ * each turn. */
+static void mik__clamp_gc_threshold(MIKRuntime* mik_rt) {
+    if (mik_rt->options.mem_limit <= 0) {
+        return;
+    }
+    size_t limit = (size_t)mik_rt->options.mem_limit;
+    size_t cap = limit - limit / 8;
+    if (JS_GetGCThreshold(mik_rt->rt) > cap) {
+        JS_SetGCThreshold(mik_rt->rt, cap);
     }
 }
 
@@ -289,12 +329,25 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
      * exhaust the heap. Overridden via MIK_SetFSReadMax. */
     mik_rt->fs_read_max = 65536;
 
+    /* Reserve the unhandled-rejection queue up-front so the rejection tracker
+     * never has to grow a std::vector on the rejection path. That path fires
+     * for a QuickJS null-OOM rejection, and a reallocation there could throw
+     * std::bad_alloc — which, with CONFIG_COMPILER_CXX_EXCEPTIONS=n on ESP32,
+     * aborts and masks the very OOM we're trying to report. Four slots covers
+     * any realistic per-turn rejection count; the runtime halts on the first
+     * one anyway. */
+    mik_rt->pending_rejections.reserve(4);
+
     /* Check for duplicate native module registrations (global registry) */
     mik__check_module_collisions();
 
     /* Set memory limit */
     JS_SetMemoryLimit(rt, options->mem_limit);
 
+    /* Make sure the cycle collector fires before the memory limit does
+     * (see mik__clamp_gc_threshold). */
+    mik__clamp_gc_threshold(mik_rt);
+
     /* Set stack size */
     JS_SetMaxStackSize(rt, options->stack_size);
     /* loader for ES modules */
@@ -337,11 +390,6 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
     mik__text_encoding_init(ctx, global_obj);
     mik__abort_init(ctx, global_obj);
 
-    /* Load some builtin references for easy access */
-    mik_rt->builtins.dispatch_event_func = JS_GetPropertyStr(ctx, global_obj, "dispatchEvent");
-    mik_rt->builtins.promise_event_ctor =
-        JS_GetPropertyStr(mik_rt->ctx, global_obj, "PromiseRejectionEvent");
-
     /* Timers */
     mik_rt->timers = MIK_NewTimerRegistry();
     mik__timers_init(ctx, global_obj);
@@ -369,6 +417,13 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt) {
         mik_rt->stdin_state.on_data = JS_UNDEFINED;
     }
 
+    /* Release any still-pending unhandled-rejection entries. */
+    for (const MIKRejectedPromise& rp : mik_rt->pending_rejections) {
+        JS_FreeValue(mik_rt->ctx, rp.promise);
+        JS_FreeValue(mik_rt->ctx, rp.reason);
+    }
+    mik_rt->pending_rejections.clear();
+
     /* Destroy registered loop consumers */
     for (const auto& consumer : mik_rt->loop_consumers) {
         if (consumer.destroy_fn) {
@@ -384,10 +439,6 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt) {
     /* Destroy the JS engine. */
     JS_FreeValue(mik_rt->ctx, mik_rt->env_obj);
     mik_rt->env_obj = JS_UNDEFINED;
-    JS_FreeValue(mik_rt->ctx, mik_rt->builtins.dispatch_event_func);
-    mik_rt->builtins.dispatch_event_func = JS_UNDEFINED;
-    JS_FreeValue(mik_rt->ctx, mik_rt->builtins.promise_event_ctor);
-    mik_rt->builtins.promise_event_ctor = JS_UNDEFINED;
     JS_FreeValue(mik_rt->ctx, mik_rt->result_ok_void_singleton);
     mik_rt->result_ok_void_singleton = JS_UNDEFINED;
     JS_FreeValue(mik_rt->ctx, mik_rt->result_proto);
@@ -510,9 +561,43 @@ static void mik__check_module_collisions(void) {
     }
 }
 
+/* A chain of already-settled promises drains as one uninterrupted storm of
+ * jobs, and the test supervisor strings whole files of such chains together
+ * with runtime recycles in between. On ESP32 the main task runs above the
+ * idle task, so a multi-second stretch like that starves idle: the task
+ * watchdog (5 s, watching IDLE0) prints a register dump, and FreeRTOS
+ * housekeeping (freeing TCBs of exited tasks, e.g. per-request HTTP tasks)
+ * stalls. Force one platform yield per second of continuous job execution
+ * so idle always gets a slice. The timestamp is global on purpose: the
+ * starvation accumulates across MIK_Loop calls and across runtime recycles.
+ * Costs at most one tick (~10 ms) per second of busy work. */
+#define MIK__YIELD_INTERVAL_US (1000 * 1000)
+
+/* Atomic because the Node addon can pump two runtimes' loops from
+ * different worker threads; relaxed ordering is enough — a missed or
+ * extra yield is harmless, a torn 64-bit write is not. */
+static std::atomic<int64_t> mik__last_yield_us{0};
+
+static void mik__maybe_yield(void) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    int64_t now = platform->get_boot_us();
+    int64_t last = mik__last_yield_us.load(std::memory_order_relaxed);
+    /* now < last happens when the boot clock resets (deep sleep) or a test
+     * swaps in a platform with a different clock; restart the interval. */
+    if (last == 0 || now < last) {
+        mik__last_yield_us.store(now, std::memory_order_relaxed);
+        return;
+    }
+    if (now - last >= MIK__YIELD_INTERVAL_US) {
+        platform->yield();
+        mik__last_yield_us.store(platform->get_boot_us(), std::memory_order_relaxed);
+    }
+}
+
 void mik__execute_jobs(JSContext* ctx) {
     JSContext* ctx1;
     int err;
+    bool ran_any = false;
 
     /* execute the pending jobs */
     for (;;) {
@@ -529,7 +614,31 @@ void mik__execute_jobs(JSContext* ctx) {
             }
             break;
         }
+        ran_any = true;
+        /* A GC pass inside this job raises the threshold to 1.5x live size,
+         * which lands above mem_limit whenever live >= ~2/3 of the limit —
+         * silently disabling cycle GC for the rest of the storm. Re-clamp
+         * between jobs so collection keeps firing; the check is a field
+         * read + compare when no GC ran. */
+        MIKRuntime* job_rt = MIK_GetRuntime(ctx1);
+        if (job_rt) {
+            mik__clamp_gc_threshold(job_rt);
+        }
+        mik__maybe_yield();
     }
+
+    /* The yield interval measures continuous BUSY work. An empty drain
+     * means the loop is idling (the idle task is getting time between
+     * turns), so re-arm the interval — otherwise the first job after a
+     * quiet period pays a spurious ~10 ms yield for wall-clock time spent
+     * doing nothing. */
+    if (!ran_any) {
+        mik__last_yield_us.store(MIK_GetPlatform()->get_boot_us(), std::memory_order_relaxed);
+    }
+
+    /* Microtask checkpoint: every reject/handle transition for this turn has
+     * now run, so whatever is still queued is a genuine unhandled rejection. */
+    mik__flush_unhandled_rejections(ctx);
 }
 
 /* main loop which calls the user JS callbacks */
@@ -576,7 +685,18 @@ int MIK_Loop(MIKRuntime* mik_rt) {
     }
 
     mik__execute_jobs(mik_rt->ctx);
-    return 0;
+
+    /* Backstop for GC passes outside the job drain (timer callbacks, loop
+     * consumers, top-level eval): a pass there may have raised the
+     * threshold above the memory limit; pull it back so the next turn's
+     * collection still fires before allocations fail. Within the job
+     * drain, mik__execute_jobs re-clamps after every job. */
+    mik__clamp_gc_threshold(mik_rt);
+
+    /* The end-of-turn unhandled-rejection flush inside mik__execute_jobs may
+     * have requested a stop; surface it this iteration rather than making the
+     * caller loop once more to notice. */
+    return mik_rt->stop_requested ? 1 : 0;
 }
 
 void MIK_SetConfig(MIKRuntime* mik_rt, const MIKConfig* config) {
@@ -961,6 +1081,13 @@ JSValue MIK_EvalModule(JSContext* ctx, const char* filename, bool is_main) {
 }
 
 int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
+    return MIK_RunEntryErr(mik_rt, entry, NULL, 0);
+}
+
+int MIK_RunEntryErr(MIKRuntime* mik_rt, const char* entry, char* err_buf, size_t err_buf_size) {
+    if (err_buf && err_buf_size > 0) {
+        err_buf[0] = '\0';
+    }
     if (!mik_rt || !entry || entry[0] == '\0') {
         return -EINVAL;
     }
@@ -987,6 +1114,7 @@ int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
 
     JSValue result = MIK_EvalModule(ctx, entry, true);
     bool failed = JS_IsException(result);
+    bool rejected = false;
     /* Modules with top-level await return a Promise. A module body that
      * throws synchronously rejects that promise before JS_EvalFunction
      * returns, but the value itself is still an Object (rejected Promise),
@@ -998,7 +1126,25 @@ int MIK_RunEntry(MIKRuntime* mik_rt, const char* entry) {
         JSPromiseStateEnum state = JS_PromiseState(ctx, result);
         if (state == JS_PROMISE_REJECTED) {
             failed = true;
+            rejected = true;
+        }
+    }
+    if (failed && err_buf && err_buf_size > 0) {
+        /* Capture the failure's string form for the caller. Without an
+         * err_buf the pending exception is intentionally left on ctx,
+         * matching MIK_RunEntry's historical behavior. */
+        JSValue exc = rejected ? JS_PromiseResult(ctx, result) : JS_GetException(ctx);
+        const char* msg = JS_ToCString(ctx, exc);
+        if (msg) {
+            snprintf(err_buf, err_buf_size, "%s", msg);
+            JS_FreeCString(ctx, msg);
+        } else {
+            /* Stringifying the exception itself threw (e.g. OOM) — drop
+             * the secondary exception so it can't leak into later evals. */
+            JSValue stray = JS_GetException(ctx);
+            JS_FreeValue(ctx, stray);
         }
+        JS_FreeValue(ctx, exc);
     }
     JS_FreeValue(ctx, result);
     return failed ? -EFAULT : 0;

package/src/modules.cpp

@@ -245,11 +245,11 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
         /* mik__load_builtin returns NULL either because the module isn't in
          * the table, or because deserialization failed (e.g. stack overflow
          * from deeply nested .bjs loading). If deserialization failed, the
-         * real exception is already on ctx — don't replace it. */
-        JSValue pending = JS_GetException(ctx);
-        if (!JS_IsNull(pending)) {
-            JS_Throw(ctx, pending);
-        } else {
+         * real exception is already on ctx — don't replace it. Probe with
+         * JS_HasException, NOT JS_GetException + JS_IsNull: quickjs-ng
+         * returns JS_UNINITIALIZED from an empty exception slot, and
+         * re-throwing that surfaced as a bare "[uninitialized]" error. */
+        if (!JS_HasException(ctx)) {
             JS_ThrowReferenceError(ctx, "Builtin module '%s' is not available in this build",
                                    module_name);
         }
@@ -285,13 +285,8 @@ JSModuleDef* mik_module_loader(JSContext* ctx, const char* module_name, void* op
         JSModuleDef* result = mik_module_loader_inner(ctx, module_name, opaque);
         if (debug) {
             if (result == nullptr) {
-                JSValue exc = JS_GetException(ctx);
-                bool has_exc = !JS_IsNull(exc) && !JS_IsUndefined(exc);
                 fprintf(stderr, "[mik-modules] FAIL: %s (exception=%s)\n", module_name,
-                        has_exc ? "set" : "NULL");
-                /* Re-throw so the caller still sees the exception. */
-                if (has_exc) JS_Throw(ctx, exc);
-                else JS_FreeValue(ctx, exc);
+                        JS_HasException(ctx) ? "set" : "NULL");
             } else {
                 fprintf(stderr, "[mik-modules] ok:   %s\n", module_name);
             }
@@ -319,12 +314,8 @@ JSModuleDef* mik_module_loader(JSContext* ctx, const char* module_name, void* op
     JSModuleDef* m = mik_module_loader_inner(ctx, module_name, opaque);
     if (debug) {
         if (m == nullptr) {
-            JSValue exc = JS_GetException(ctx);
-            bool has_exc = !JS_IsNull(exc) && !JS_IsUndefined(exc);
             fprintf(stderr, "[mik-modules] FAIL: %s (exception=%s)\n", module_name,
-                    has_exc ? "set" : "NULL");
-            if (has_exc) JS_Throw(ctx, exc);
-            else JS_FreeValue(ctx, exc);
+                    JS_HasException(ctx) ? "set" : "NULL");
         } else {
             fprintf(stderr, "[mik-modules] ok:   %s\n", module_name);
         }

package/src/platform_posix.cpp

@@ -116,6 +116,10 @@ static const char* posix_get_device_id(void) {
     return id;
 }
 
+static const char* posix_get_reset_reason(void) {
+    return "unknown";  /* Desktop processes have no chip reset concept */
+}
+
 static void posix_log(int level, const char* tag, const char* fmt, ...) {
     if (level < MIK_LOG_ERROR || level > MIK_LOG_VERBOSE) return;
     fprintf(stderr, "[%s] %s: ", mik_log_level_name(level), tag);
@@ -147,6 +151,7 @@ static const MIKPlatform posix_platform = {
     .stderr_write = posix_stderr_write,
     .stdin_read = posix_stdin_read,
     .get_device_id = posix_get_device_id,
+    .get_reset_reason = posix_get_reset_reason,
 };
 
 static const MIKPlatform* current_platform = &posix_platform;