@mikrojs/native 0.12.0 → 0.14.0-pr-229.g0d8db1b

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/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"));
 }