@mikrojs/native 0.21.1-next.20260927212749 → 0.22.0

package/src/mik_inspect.cpp

@@ -20,6 +20,7 @@ struct InspectOpts {
     std::vector<void*> seen;
     /* Nesting of [cause] rendering, capped like mik__report_uncaught */
     int cause_level = 0;
+    const MIKInspectCache* cache = nullptr;
 };
 
 /* ── Helpers ─────────────────────────────────────────────────────── */
@@ -106,23 +107,10 @@ static JSValue mik__custom_inspect_cb(JSContext* ctx, JSValue /*this_val*/, int
  * Returns true and sets `out` if custom inspect was used. */
 static bool try_custom_inspect(JSContext* ctx, JSValue value, InspectOpts& opts, int depth,
                                std::string& out) {
-    JSValue global = JS_GetGlobalObject(ctx);
-    JSValue symbol_ctor = JS_GetPropertyStr(ctx, global, "Symbol");
-    JSValue for_fn = JS_GetPropertyStr(ctx, symbol_ctor, "for");
-
-    JSValue key_str = JS_NewString(ctx, "mikrojs.inspect");
-    JSValue inspect_sym = JS_Call(ctx, for_fn, symbol_ctor, 1, &key_str);
-    JS_FreeValue(ctx, key_str);
-    JS_FreeValue(ctx, for_fn);
-
     bool used = false;
 
-    if (JS_IsException(inspect_sym)) {
-        drain_exception(ctx);
-    } else {
-        JSAtom sym_atom = JS_ValueToAtom(ctx, inspect_sym);
-        JSValue custom_fn = JS_GetProperty(ctx, value, sym_atom);
-        JS_FreeAtom(ctx, sym_atom);
+    if (opts.cache->inspect_symbol != JS_ATOM_NULL) {
+        JSValue custom_fn = JS_GetProperty(ctx, value, opts.cache->inspect_symbol);
         if (JS_IsException(custom_fn)) drain_exception(ctx);
 
         if (JS_IsFunction(ctx, custom_fn)) {
@@ -153,9 +141,6 @@ static bool try_custom_inspect(JSContext* ctx, JSValue value, InspectOpts& opts,
         }
         JS_FreeValue(ctx, custom_fn);
     }
-    JS_FreeValue(ctx, inspect_sym);
-    JS_FreeValue(ctx, symbol_ctor);
-    JS_FreeValue(ctx, global);
 
     return used;
 }
@@ -206,16 +191,11 @@ static std::string escape_string(const char* str, size_t len) {
     return out;
 }
 
-/* ── Type detection via Object.prototype.toString ────────────────── */
+/* ── Type detection ──────────────────────────────────────────────── */
 
-static std::string get_object_type(JSContext* ctx, JSValue value) {
-    /* Call Object.prototype.toString.call(value) */
-    JSValue global = JS_GetGlobalObject(ctx);
-    JSValue object_ctor = JS_GetPropertyStr(ctx, global, "Object");
-    JSValue prototype = JS_GetPropertyStr(ctx, object_ctor, "prototype");
-    JSValue to_string = JS_GetPropertyStr(ctx, prototype, "toString");
-
-    JSValue result = JS_Call(ctx, to_string, value, 0, nullptr);
+/* Tag from the engine's Object.prototype.toString, "Foo" out of "[object Foo]" */
+static std::string to_string_type(JSContext* ctx, JSValue value) {
+    JSValue result = JS_ToObjectString(ctx, value);
 
     std::string type;
     if (JS_IsException(result)) {
@@ -236,11 +216,47 @@ static std::string get_object_type(JSContext* ctx, JSValue value) {
     }
 
     JS_FreeValue(ctx, result);
-    JS_FreeValue(ctx, to_string);
-    JS_FreeValue(ctx, prototype);
-    JS_FreeValue(ctx, object_ctor);
-    JS_FreeValue(ctx, global);
+    return type;
+}
 
+/* Class checks plus one Symbol.toStringTag read give toString's tag; other
+ * classes go through toString. */
+static std::string get_object_type(JSContext* ctx, JSValue value, const MIKInspectCache& cache) {
+    const char* builtin = nullptr;
+    if (JS_IsError(value)) {
+        builtin = "Error";
+    } else if (JS_IsDate(value)) {
+        builtin = "Date";
+    } else if (JS_IsRegExp(value)) {
+        builtin = "RegExp";
+    } else if (JS_GetClassID(value) == cache.object_class_id || JS_IsMap(value) ||
+               JS_IsSet(value) || JS_IsWeakMap(value) || JS_IsWeakSet(value) ||
+               JS_IsWeakRef(value) || JS_IsPromise(value) || JS_IsArrayBuffer(value) ||
+               JS_IsDataView(value) || JS_GetTypedArrayType(value) >= 0) {
+        builtin = "Object";
+    }
+    if (!builtin || cache.to_string_tag == JS_ATOM_NULL) {
+        return to_string_type(ctx, value);
+    }
+
+    JSValue tag = JS_GetProperty(ctx, value, cache.to_string_tag);
+    std::string type;
+    if (JS_IsException(tag)) {
+        /* A throwing Symbol.toStringTag getter or proxy trap */
+        drain_exception(ctx);
+    } else if (JS_IsString(tag)) {
+        const char* str = JS_ToCString(ctx, tag);
+        if (str) {
+            /* An empty tag gives "[object ]", which to_string_type keeps whole */
+            type = str[0] ? str : "[object ]";
+            JS_FreeCString(ctx, str);
+        } else {
+            drain_exception(ctx);
+        }
+    } else {
+        type = builtin;
+    }
+    JS_FreeValue(ctx, tag);
     return type;
 }
 
@@ -275,28 +291,31 @@ static std::string inspect_array_items(JSContext* ctx, JSValue arr, uint32_t len
 
 /* ── Inspect object properties ───────────────────────────────────── */
 
-static std::string inspect_properties(JSContext* ctx, JSValue obj, InspectOpts& opts, int depth,
-                                      const char* const* skip_keys = nullptr,
-                                      size_t skip_count = 0) {
-    JSPropertyEnum* ptab = nullptr;
-    uint32_t plen = 0;
-
+/* Own string keys to render (enumerable only unless showHidden). On failure
+ * drains the exception and returns false. Free with JS_FreePropertyEnum. */
+static bool get_own_keys(JSContext* ctx, JSValue obj, const InspectOpts& opts,
+                         JSPropertyEnum** ptab, uint32_t* plen) {
     int flags = JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY;
     if (opts.show_hidden) {
         flags = JS_GPN_STRING_MASK;
     }
 
-    if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, obj, flags) != 0) {
+    if (JS_GetOwnPropertyNames(ctx, ptab, plen, obj, flags) != 0) {
         drain_exception(ctx);
-        return "";
+        return false;
     }
+    return true;
+}
 
+static std::string inspect_properties(JSContext* ctx, JSValue obj, const JSPropertyEnum* ptab,
+                                      uint32_t plen, InspectOpts& opts, int depth,
+                                      const char* const* skip_keys = nullptr,
+                                      size_t skip_count = 0) {
     std::string out;
     bool first = true;
     for (uint32_t i = 0; i < plen; i++) {
         const char* key = JS_AtomToCString(ctx, ptab[i].atom);
         if (!key) {
-            JS_FreeAtom(ctx, ptab[i].atom);
             continue;
         }
 
@@ -315,7 +334,7 @@ static std::string inspect_properties(JSContext* ctx, JSValue obj, InspectOpts&
             if (!first) out += ", ";
             first = false;
 
-            JSValue val = JS_GetPropertyStr(ctx, obj, key);
+            JSValue val = JS_GetProperty(ctx, obj, ptab[i].atom);
             out += quote_key(key);
             out += ": ";
             if (JS_IsException(val)) {
@@ -327,9 +346,7 @@ static std::string inspect_properties(JSContext* ctx, JSValue obj, InspectOpts&
         }
 
         JS_FreeCString(ctx, key);
-        JS_FreeAtom(ctx, ptab[i].atom);
     }
-    js_free(ctx, ptab);
     return out;
 }
 
@@ -375,12 +392,8 @@ static std::string inspect_function(JSContext* ctx, JSValue value, InspectOpts&
 
     /* Check for Symbol.toStringTag */
     std::string func_type = "Function";
-    JSValue global = JS_GetGlobalObject(ctx);
-    JSValue symbol_ctor = JS_GetPropertyStr(ctx, global, "Symbol");
-    JSValue tag_sym = JS_GetPropertyStr(ctx, symbol_ctor, "toStringTag");
-    if (!JS_IsUndefined(tag_sym)) {
-        JSAtom tag_atom = JS_ValueToAtom(ctx, tag_sym);
-        JSValue tag_val = JS_GetProperty(ctx, value, tag_atom);
+    if (opts.cache->to_string_tag != JS_ATOM_NULL) {
+        JSValue tag_val = JS_GetProperty(ctx, value, opts.cache->to_string_tag);
         if (JS_IsException(tag_val)) drain_exception(ctx);
         if (JS_IsString(tag_val)) {
             const char* tag = JS_ToCString(ctx, tag_val);
@@ -390,11 +403,7 @@ static std::string inspect_function(JSContext* ctx, JSValue value, InspectOpts&
             }
         }
         JS_FreeValue(ctx, tag_val);
-        JS_FreeAtom(ctx, tag_atom);
     }
-    JS_FreeValue(ctx, tag_sym);
-    JS_FreeValue(ctx, symbol_ctor);
-    JS_FreeValue(ctx, global);
 
     if (name && name[0]) {
         result = "[" + func_type + " " + name + "]";
@@ -554,8 +563,14 @@ static std::string inspect_error(JSContext* ctx, JSValue value, InspectOpts& opt
     static const char* const error_keys[] = {"stack",     "line",       "column",     "name",
                                              "message",   "fileName",   "lineNumber", "columnNumber",
                                              "number",    "description", "cause"};
-    std::string props =
-        inspect_properties(ctx, value, opts, depth, error_keys, countof(error_keys));
+    std::string props;
+    JSPropertyEnum* ptab = nullptr;
+    uint32_t plen = 0;
+    if (get_own_keys(ctx, value, opts, &ptab, &plen)) {
+        props = inspect_properties(ctx, value, ptab, plen, opts, depth, error_keys,
+                                   countof(error_keys));
+        JS_FreePropertyEnum(ctx, ptab, plen);
+    }
     if (!props.empty()) {
         result += " { " + props + " }";
     }
@@ -708,15 +723,10 @@ static std::string inspect_set(JSContext* ctx, JSValue value, InspectOpts& opts,
     if (is_seen(opts, value)) return "[Circular]";
     opts.seen.push_back(JS_VALUE_GET_PTR(value));
 
-    /* Get values via forEach */
-    JSValue for_each_fn = JS_GetPropertyStr(ctx, value, "forEach");
-
-    /* Build array of values to inspect */
     std::string items;
     JSValue values_fn = JS_GetPropertyStr(ctx, value, "values");
     JSValue iterator = JS_Call(ctx, values_fn, value, 0, nullptr);
     JS_FreeValue(ctx, values_fn);
-    JS_FreeValue(ctx, for_each_fn);
 
     if (JS_IsException(iterator)) {
         drain_exception(ctx);
@@ -799,30 +809,20 @@ static std::string inspect_typed_array(JSContext* ctx, JSValue value, const std:
 static std::string inspect_object(JSContext* ctx, JSValue value, InspectOpts& opts, int depth) {
     if (is_seen(opts, value)) return "[Circular]";
 
-    /* Check for empty object */
     JSPropertyEnum* ptab = nullptr;
     uint32_t plen = 0;
-    int flags = JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY;
-    if (opts.show_hidden) {
-        flags = JS_GPN_STRING_MASK;
-    }
-
-    if (JS_GetOwnPropertyNames(ctx, &ptab, &plen, value, flags) != 0) {
-        drain_exception(ctx);
+    if (!get_own_keys(ctx, value, opts, &ptab, &plen)) return "{}";
+    if (plen == 0) {
+        JS_FreePropertyEnum(ctx, ptab, plen);
         return "{}";
     }
-    for (uint32_t i = 0; i < plen; i++) {
-        JS_FreeAtom(ctx, ptab[i].atom);
-    }
-    js_free(ctx, ptab);
-
-    if (plen == 0) return "{}";
 
     /* A cause field chains below the braces like an Error's, so a Result
      * error wrapped around another keeps its whole chain readable */
     static const char* const cause_key[] = {"cause"};
     opts.seen.push_back(JS_VALUE_GET_PTR(value));
-    std::string props = inspect_properties(ctx, value, opts, depth, cause_key, 1);
+    std::string props = inspect_properties(ctx, value, ptab, plen, opts, depth, cause_key, 1);
+    JS_FreePropertyEnum(ctx, ptab, plen);
     std::string result = props.empty() ? "{}" : "{ " + props + " }";
     result += inspect_cause(ctx, value, opts, depth);
     opts.seen.pop_back();
@@ -915,9 +915,12 @@ static std::string inspect_value(JSContext* ctx, JSValue value, InspectOpts& opt
     }
 
     /* Objects — detect type */
-    std::string type = get_object_type(ctx, value);
+    if (JS_IsArray(value)) {
+        return inspect_array(ctx, value, opts, depth - 1);
+    }
+    std::string type = get_object_type(ctx, value, *opts.cache);
 
-    if (JS_IsArray(value) || type == "Array") {
+    if (type == "Array") {
         return inspect_array(ctx, value, opts, depth - 1);
     }
     if (JS_IsError(value) || type == "Error") {
@@ -955,16 +958,8 @@ static std::string inspect_value(JSContext* ctx, JSValue value, InspectOpts& opt
     /* Plain object vs class instance */
     JSValue proto = JS_GetPrototype(ctx, value);
     if (JS_IsException(proto)) drain_exception(ctx);
-    JSValue global = JS_GetGlobalObject(ctx);
-    JSValue obj_ctor = JS_GetPropertyStr(ctx, global, "Object");
-    JSValue obj_proto = JS_GetPropertyStr(ctx, obj_ctor, "prototype");
-
     bool is_plain = JS_IsNull(proto) ||
-                    (JS_VALUE_GET_PTR(proto) == JS_VALUE_GET_PTR(obj_proto));
-
-    JS_FreeValue(ctx, obj_proto);
-    JS_FreeValue(ctx, obj_ctor);
-    JS_FreeValue(ctx, global);
+                    (JS_VALUE_GET_PTR(proto) == JS_VALUE_GET_PTR(opts.cache->object_proto));
     JS_FreeValue(ctx, proto);
 
     if (is_plain) {
@@ -982,6 +977,7 @@ std::string mik_inspect(JSContext* ctx, JSValue value, int depth, bool colors, b
     opts.truncate = 0;  /* 0 = unlimited */
     opts.colors = colors;
     opts.show_hidden = show_hidden;
+    opts.cache = &MIK_GetRuntime(ctx)->inspect_cache;
     return inspect_value(ctx, value, opts, depth);
 }
 
@@ -1026,6 +1022,25 @@ int mik__inspect_module_init(JSContext* ctx, JSModuleDef* m) {
 }
 
 void mik__inspect_register(JSContext* ctx) {
+    MIKInspectCache& cache = MIK_GetRuntime(ctx)->inspect_cache;
+    /* is_global makes this the registered symbol Symbol.for returns */
+    JSValue sym = JS_NewSymbol(ctx, "mikrojs.inspect", true);
+    if (!JS_IsException(sym)) cache.inspect_symbol = JS_ValueToAtom(ctx, sym);
+    JS_FreeValue(ctx, sym);
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue symbol_ctor = JS_GetPropertyStr(ctx, global, "Symbol");
+    JSValue tag_sym = JS_GetPropertyStr(ctx, symbol_ctor, "toStringTag");
+    if (JS_IsSymbol(tag_sym)) cache.to_string_tag = JS_ValueToAtom(ctx, tag_sym);
+    JS_FreeValue(ctx, tag_sym);
+    JS_FreeValue(ctx, symbol_ctor);
+
+    JSValue object_ctor = JS_GetPropertyStr(ctx, global, "Object");
+    cache.object_proto = JS_GetPropertyStr(ctx, object_ctor, "prototype");
+    cache.object_class_id = JS_GetClassID(cache.object_proto);
+    JS_FreeValue(ctx, object_ctor);
+    JS_FreeValue(ctx, global);
+
     JSModuleDef* m = JS_NewCModule(ctx, "mikro/inspect", mik__inspect_module_init);
     if (m) {
         JS_AddModuleExport(ctx, m, "inspect");

package/src/mik_observable.cpp

@@ -71,6 +71,10 @@ extern "C" {
 #include "quickjs.h"
 }
 
+/* Property names the per-value paths use, atomized once per runtime */
+enum ObservableAtom { OBS_NEXT, OBS_DONE, OBS_VALUE, OBS_ATOM_COUNT };
+static const char* const observable_atom_names[OBS_ATOM_COUNT] = {"next", "done", "value"};
+
 /* Per-runtime dispatch queue. Entries hold their own references (dup on
  * enqueue, freed after the drained delivery). The queue is only non-empty
  * while a dispatch is on the stack, so runtime teardown never sees values. */
@@ -83,6 +87,7 @@ struct MIKObservableDispatch {
     bool active = false;
     size_t head = 0;
     std::vector<Entry> queue;
+    JSAtom atoms[OBS_ATOM_COUNT] = {};
 };
 
 namespace {
@@ -234,6 +239,11 @@ static MIKObservableDispatch* dispatch_state(JSContext* ctx) {
     return mik_rt ? mik_rt->observable_dispatch : nullptr;
 }
 
+/* JS_NewAtom(name) without hashing the name: dups the cached atom. Free with JS_FreeAtom. */
+static JSAtom observable_atom(JSContext* ctx, ObservableAtom which) {
+    return JS_DupAtom(ctx, dispatch_state(ctx)->atoms[which]);
+}
+
 /* True once a panic is armed. The producer's own callback keeps running (JS
  * cannot be stopped mid-function), so its later next/complete calls have to
  * become no-ops rather than delivering against crashed state. */
@@ -656,12 +666,14 @@ static JSValue get_iterator(JSContext* ctx, JSValueConst src) {
  * Sets *done = true if iteration is complete (and returns JS_UNDEFINED).
  * Returns JS_EXCEPTION on protocol error. Caller frees the returned value. */
 static JSValue iterator_next(JSContext* ctx, JSValueConst iterator, bool* done) {
-    JSAtom next_atom = JS_NewAtom(ctx, "next");
+    JSAtom next_atom = observable_atom(ctx, OBS_NEXT);
     JSValue result = JS_Invoke(ctx, iterator, next_atom, 0, nullptr);
     JS_FreeAtom(ctx, next_atom);
     if (JS_IsException(result)) return result;
 
-    JSValue done_val = JS_GetPropertyStr(ctx, result, "done");
+    JSAtom done_atom = observable_atom(ctx, OBS_DONE);
+    JSValue done_val = JS_GetProperty(ctx, result, done_atom);
+    JS_FreeAtom(ctx, done_atom);
     int done_int = JS_ToBool(ctx, done_val);
     JS_FreeValue(ctx, done_val);
     if (done_int < 0) {
@@ -674,7 +686,9 @@ static JSValue iterator_next(JSContext* ctx, JSValueConst iterator, bool* done)
         JS_FreeValue(ctx, result);
         return JS_UNDEFINED;
     }
-    JSValue value = JS_GetPropertyStr(ctx, result, "value");
+    JSAtom value_atom = observable_atom(ctx, OBS_VALUE);
+    JSValue value = JS_GetProperty(ctx, result, value_atom);
+    JS_FreeAtom(ctx, value_atom);
     JS_FreeValue(ctx, result);
     return value;
 }
@@ -721,7 +735,7 @@ static JSValue from_iterable_subscribe(JSContext* ctx, JSValueConst this_val, in
     JSValue iterator = get_iterator(ctx, c->iterable);
     if (JS_IsException(iterator)) return iterator;
 
-    JSAtom next_atom = JS_NewAtom(ctx, "next");
+    JSAtom next_atom = observable_atom(ctx, OBS_NEXT);
 
     bool done = false;
     while (!done) {
@@ -792,7 +806,7 @@ static JSValue from_promise_on_resolve(JSContext* ctx, JSValueConst this_val, in
     if (!sd || sd->closed) return JS_UNDEFINED;
 
     JSValue value = argc > 0 ? argv[0] : JS_UNDEFINED;
-    JSAtom next_atom = JS_NewAtom(ctx, "next");
+    JSAtom next_atom = observable_atom(ctx, OBS_NEXT);
     invoke_safely(ctx, subscriber, next_atom, 1, &value);
     JS_FreeAtom(ctx, next_atom);
 
@@ -1008,7 +1022,7 @@ static JSValue multicast_emit_next(JSContext* ctx, JSValueConst this_val, int ar
     for (auto& s : m->subscribers) snapshot.push_back(JS_DupValue(ctx, s));
 
     JSValue value = argc > 0 ? argv[0] : JS_UNDEFINED;
-    JSAtom next_atom = JS_NewAtom(ctx, "next");
+    JSAtom next_atom = observable_atom(ctx, OBS_NEXT);
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     for (auto& s : snapshot) {
         auto* sd = static_cast<SubscriberData*>(JS_GetOpaque(s, subscriber_class_id));
@@ -1982,6 +1996,9 @@ int mik__observable_multicast_new(JSContext* ctx, JSValue* observable, JSValue*
 }
 
 void mik__observable_dispatch_free(MIKRuntime* mik_rt) {
+    if (mik_rt->observable_dispatch) {
+        for (JSAtom a : mik_rt->observable_dispatch->atoms) JS_FreeAtom(mik_rt->ctx, a);
+    }
     delete mik_rt->observable_dispatch;
     mik_rt->observable_dispatch = nullptr;
 }
@@ -1992,6 +2009,9 @@ JSModuleDef* mik__observable_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     if (mik_rt && !mik_rt->observable_dispatch) {
         mik_rt->observable_dispatch = new MIKObservableDispatch();
+        for (int i = 0; i < OBS_ATOM_COUNT; i++) {
+            mik_rt->observable_dispatch->atoms[i] = JS_NewAtom(ctx, observable_atom_names[i]);
+        }
     }
 
     /* The IDs are process-wide (MIK_NewClassID); the classes register once per runtime. */

package/src/mik_ota_client.cpp

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "mikrojs/cbor_helpers.h"
+#include "mikrojs/mikrojs.h"
 #include "mikrojs/ota_config.h"
 #include "mikrojs/ota_slots.h"
 #include "mikrojs/platform.h"
@@ -388,6 +389,8 @@ void MIKOtaClient::Check(const MIKOtaCheckOptions& options, MIKOtaCheckSink sink
         return;
     }
     queue_.push_back(std::move(round));
+    /* Poll runs from the loop consumer, which may have run already this pass. */
+    MIK_Wake();
 }
 
 /* Floor for the check-in cadence: each round's TLS session leaves heap and

package/src/mik_ota_js_hooks.cpp

@@ -2,6 +2,7 @@
 
 #include <map>
 
+#include "mikrojs/mikrojs.h"
 #include "mikrojs/utils.h"
 
 namespace mikrojs {
@@ -178,6 +179,8 @@ JSValue MIKOtaJsHooks::OnFulfilled(JSContext* ctx, JSValueConst this_val, int ar
     (void)this_val;
     MIKOtaJsHooks* hooks = take_self(ctx, func_data);
     if (!hooks) return JS_UNDEFINED;
+    /* A job settled the hook; the OTA consumer that polls it has run this pass. */
+    MIK_Wake();
     if (magic == 0) {
         /* Rejected: a failed hook, whichever half was running. */
         hooks->state_ = MIKOtaHookState::kFailed;

package/src/mik_repl.cpp

@@ -62,6 +62,30 @@ bool mik__repl_is_protocol_mode(void) {
     return repl_protocol_mode && repl_active;
 }
 
+/* Longest sleep between passes: a backstop against a producer that forgot
+ * MIK_Wake, not a poll period. */
+static constexpr int64_t LOOP_WAIT_CAP_US = 100 * 1000;
+
+/* Sleep until the next deadline, a wake, or the cap. Work due now yields
+ * instead; a paused or absent runtime waits for the cap (console RX wakes it). */
+static void repl_wait_for_work(void) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    int64_t wake_us = LOOP_WAIT_CAP_US;
+    if (repl_mik_rt && !repl_paused) {
+        wake_us = mik__next_wake_us(repl_mik_rt);
+        if (wake_us == 0) {
+            platform->yield();
+            return;
+        }
+        if (wake_us < 0 || wake_us > LOOP_WAIT_CAP_US) wake_us = LOOP_WAIT_CAP_US;
+    }
+    if (platform->wait) {
+        platform->wait(wake_us);
+    } else {
+        platform->yield();
+    }
+}
+
 /* ── TLV frame helpers ───────────────────────────────────────────── */
 
 /* Plain bool, not atomic — relies on the assumption that mik__proto_send
@@ -124,7 +148,6 @@ void mik__repl_proto_send_output(uint8_t msg_type, const void* data, size_t len)
  * reports the attached runtime has halted without a panic grace window
  * (e.g. an unhandled rejection in a test that crashed mid-execution). */
 bool mik__proto_read_exact(MIKReplTransport* transport, void* buf, size_t n) {
-    const MIKPlatform* platform = MIK_GetPlatform();
     uint8_t* p = static_cast<uint8_t*>(buf);
     size_t total = 0;
     while (total < n) {
@@ -143,19 +166,12 @@ bool mik__proto_read_exact(MIKReplTransport* transport, void* buf, size_t n) {
                     return false;
                 }
             }
-            /* Microtasks are deferred user JS: settling them re-enters .then
-             * handlers that can write to the transport (console.log → MSG_LOG)
-             * or touch the filesystem mid-deploy. Gate on pause too — and
-             * on a pending panic-restart, since the runtime is on its way
-             * out and no further user JS should fire on it. */
-            if (repl_ctx && !repl_paused &&
-                (!repl_mik_rt || repl_mik_rt->restart_at_us == 0)) {
-                mik__execute_jobs(repl_ctx);
-            }
+            /* Microtasks drain inside MIK_Loop, so none run while paused or
+             * while a panic-restart is pending. */
             /* A pumped job (e.g. the test runtime's __testFileDone) may
-             * have signalled exit. Bail before yielding another time slice. */
+             * have signalled exit. Bail before sleeping again. */
             if (s_exit_serve_loop) return false;
-            platform->yield();
+            repl_wait_for_work();
         }
     }
     return true;
@@ -264,8 +280,6 @@ static JSValue repl_eval_and_pump(JSContext* ctx, const char* code, size_t len)
         return result;
     }
 
-    const MIKPlatform* platform = MIK_GetPlatform();
-
     for (;;) {
         JSPromiseStateEnum state = JS_PromiseState(ctx, result);
         if (state == JS_PROMISE_FULFILLED) {
@@ -296,8 +310,8 @@ static JSValue repl_eval_and_pump(JSContext* ctx, const char* code, size_t len)
         }
 
         MIK_Loop(repl_mik_rt);
-        mik__execute_jobs(ctx);
-        platform->yield();
+        /* The pass may have settled it (a job or a due timer): report now. */
+        if (JS_PromiseState(ctx, result) == JS_PROMISE_PENDING) repl_wait_for_work();
     }
 }
 
@@ -903,17 +917,19 @@ static std::vector<uint8_t> proto_complete(JSContext* ctx, const char* partial,
 /* ── Protocol-mode REPL ──────────────────────────────────────────── */
 
 /* Fills ready_buf/ready_len with CBOR device info:
- * {"chip": tstr, "id": tstr, "v": tstr, "board": tstr, "fw": tstr (when built
- * with MIK_BOARD_NAME), "name": tstr (only when named), "features": [tstr] (when
- * built with MIK_FW_FEATURES; host builds omit it), "natives": [tstr]}.
+ * {"chip": tstr, "id": tstr, "v": tstr, "board": tstr, "proto": uint
+ * (MIK_PROTO_REV), "fw": tstr (when built with MIK_BOARD_NAME), "name": tstr
+ * (only when named), "features": [tstr] (when built with MIK_FW_FEATURES; host
+ * builds omit it), "natives": [tstr]}.
  * `board` is mik__board_name(). `features` lists the firmware features the
  * build compiled in (from the comma-separated MIK_FW_FEATURES define), so the
  * host knows which feature-gated builtins this firmware carries. `natives`
  * lists the registered C modules outside the core namespace (package native
  * modules compiled in, e.g. "@mikrojs/drivers/sh8601"; empty on a generic
  * build), so the host can refuse an app importing one this firmware lacks.
- * `fw` is the firmware identity: the board name the build set (MIK_BOARD_NAME),
- * which `board` also reports. The host only auto-flashes its bundled image over
+ * `fw` is the firmware identity: the name the build set (MIK_BOARD_NAME). `board`
+ * reports the same unless `mikro flash` wrote a board's name into a generic
+ * image (mik__board_name). The host only auto-flashes its bundled image over
  * a device whose identity matches that image's name; omitting it reads as
  * firmware predating identity reporting, which the host treats as its own
  * bundled firmware.
@@ -949,7 +965,7 @@ static size_t encode_ready(uint8_t* buf, size_t cap, const char* chip, const cha
     static uint8_t measure_base;
     nanocbor_encoder_t enc;
     nanocbor_encoder_init(&enc, buf ? buf : &measure_base, buf ? cap : 0);
-    nanocbor_fmt_map(&enc, 4 + (fw ? 1 : 0) + (name ? 1 : 0) + (features ? 1 : 0) +
+    nanocbor_fmt_map(&enc, 5 + (fw ? 1 : 0) + (name ? 1 : 0) + (features ? 1 : 0) +
                                (natives ? 1 : 0) + (mem ? 3 : 0));
     nanocbor_put_tstr(&enc, "chip");
     nanocbor_put_tstr(&enc, chip);
@@ -959,6 +975,8 @@ static size_t encode_ready(uint8_t* buf, size_t cap, const char* chip, const cha
     nanocbor_put_tstr(&enc, version);
     nanocbor_put_tstr(&enc, "board");
     nanocbor_put_tstr(&enc, board);
+    nanocbor_put_tstr(&enc, "proto");
+    nanocbor_fmt_uint(&enc, MIK_PROTO_REV);
     if (fw) {
         nanocbor_put_tstr(&enc, "fw");
         nanocbor_put_tstr(&enc, fw);
@@ -1324,9 +1342,6 @@ void MIK_ProtocolServeLoop(void) {
         if (repl_mik_rt && !repl_paused) {
             MIK_Loop(repl_mik_rt);
         }
-        if (ctx && !repl_paused) {
-            mik__execute_jobs(ctx);
-        }
     }
 }