@mikrojs/native 0.21.1-next.20260927212749 → 0.22.0

package/src/mik_text_encoding.cpp

@@ -2,6 +2,7 @@
 #include <string.h>
 
 #include "mikrojs/mikrojs.h"
+#include "mikrojs/private.h"
 #include "mikrojs/utils.h"
 
 /* ---- TextEncoder ---- */
@@ -23,11 +24,12 @@ static JSValue mik__text_encoder_constructor(JSContext* ctx, JSValue new_target,
 
 static JSValue mik__text_encoder_encode(JSContext* ctx, JSValue this_val, int argc,
                                         JSValue* argv) {
-    const char* str = JS_ToCString(ctx, argv[0]);
+    size_t len = 0;
+    const char* str = JS_ToCStringLen(ctx, &len, argv[0]);
     if (!str) {
         return JS_EXCEPTION;
     }
-    JSValue ret = JS_NewUint8ArrayCopy(ctx, (const uint8_t*)str, strlen(str));
+    JSValue ret = JS_NewUint8ArrayCopy(ctx, (const uint8_t*)str, len);
     JS_FreeCString(ctx, str);
     return ret;
 }
@@ -135,11 +137,38 @@ static bool utf8_seq_valid(const uint8_t* p, int len) {
     return false;
 }
 
-/* Append U+FFFD (EF BF BD) to buffer. */
-static void append_replacement(uint8_t* out, size_t* out_len) {
-    out[(*out_len)++] = 0xEF;
-    out[(*out_len)++] = 0xBF;
-    out[(*out_len)++] = 0xBD;
+/* Copy `n` bytes to the output when there is one; always count them. */
+static void utf8_put(uint8_t* out, size_t* out_len, const uint8_t* src, size_t n) {
+    if (out) memcpy(out + *out_len, src, n);
+    *out_len += n;
+}
+
+size_t mik__utf8_replace(const uint8_t* in, size_t len, bool hold_tail, uint8_t* out,
+                         size_t* tail) {
+    static const uint8_t replacement[3] = {0xEF, 0xBF, 0xBD};
+    size_t out_len = 0;
+    size_t i = 0;
+    *tail = 0;
+    while (i < len) {
+        int seq = utf8_seq_len(in[i]);
+        if (seq > 0 && i + seq > len) {
+            /* Incomplete trailing sequence: hold it, or one U+FFFD per byte. */
+            if (hold_tail) {
+                *tail = len - i;
+                break;
+            }
+            for (; i < len; i++) utf8_put(out, &out_len, replacement, 3);
+            break;
+        }
+        if (seq == 0 || !utf8_seq_valid(in + i, seq)) {
+            utf8_put(out, &out_len, replacement, 3);
+            i++;
+            continue;
+        }
+        utf8_put(out, &out_len, in + i, seq);
+        i += seq;
+    }
+    return out_len;
 }
 
 static JSValue mik__text_decoder_decode(JSContext* ctx, JSValue this_val, int argc,
@@ -185,53 +214,28 @@ static JSValue mik__text_decoder_decode(JSContext* ctx, JSValue this_val, int ar
         memcpy(heap_input + state->pending_len, data, len);
         input = heap_input;
     }
-    state->pending_len = 0;
-
-    /* Worst case output: every byte becomes U+FFFD (3 bytes). */
-    size_t out_cap = total * 3;
-    if (out_cap == 0) out_cap = 1;
-    uint8_t* out = static_cast<uint8_t*>(js_malloc(ctx, out_cap));
-    if (!out) {
-        if (heap_input) js_free(ctx, heap_input);
-        return JS_EXCEPTION;
-    }
-    size_t out_len = 0;
 
-    size_t i = 0;
-    while (i < total) {
-        uint8_t b = input[i];
-        int seq = utf8_seq_len(b);
-        if (seq == 0) {
-            append_replacement(out, &out_len);
-            i++;
-            continue;
-        }
-        if (i + seq > total) {
-            /* Incomplete trailing sequence. */
-            if (stream) {
-                size_t held = total - i;
-                for (size_t k = 0; k < held; k++) state->pending[k] = input[i + k];
-                state->pending_len = (uint8_t)held;
-                break;
-            }
-            /* Flush: one U+FFFD per held byte. */
-            for (size_t k = i; k < total; k++) append_replacement(out, &out_len);
-            i = total;
-            break;
-        }
-        if (!utf8_seq_valid(input + i, seq)) {
-            append_replacement(out, &out_len);
-            i++;
-            continue;
+    /* Valid input (the usual case) becomes a string as is; only invalid input
+     * pays for a repaired copy, sized by the counting pass. */
+    size_t tail = 0;
+    size_t out_len = mik__utf8_replace(input, total, stream, nullptr, &tail);
+    size_t used = total - tail;
+    JSValue ret;
+    if (out_len == used) {
+        ret = JS_NewStringLen(ctx, (const char*)input, used);
+    } else {
+        uint8_t* out = static_cast<uint8_t*>(js_malloc(ctx, out_len));
+        if (!out) {
+            if (heap_input) js_free(ctx, heap_input);
+            return JS_EXCEPTION;
         }
-        memcpy(out + out_len, input + i, seq);
-        out_len += seq;
-        i += seq;
+        mik__utf8_replace(input, total, stream, out, &tail);
+        ret = JS_NewStringLen(ctx, (const char*)out, out_len);
+        js_free(ctx, out);
     }
-
+    if (tail) memcpy(state->pending, input + used, tail);
+    state->pending_len = (uint8_t)tail;
     if (heap_input) js_free(ctx, heap_input);
-    JSValue ret = JS_NewStringLen(ctx, (const char*)out, out_len);
-    js_free(ctx, out);
     return ret;
 }
 
@@ -353,55 +357,41 @@ static size_t b64_decode(const char* src, size_t len, uint8_t* dst, int* err) {
 
 /* btoa: encode a binary string to base64.
  * Per the web spec, the argument is first coerced to a string (ToString), then
- * each character's code point is treated as a raw byte. We iterate by code
- * point, not by UTF-8 bytes, since JS_ToCStringLen would turn e.g. U+0080 into
- * two bytes (\xC2\x80). */
+ * each character's code point is treated as a raw byte. The string arrives as
+ * UTF-8, so a code point is one byte (ASCII), two bytes (U+0080..U+00FF), or
+ * out of range. */
 static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    JSValue str_val = JS_ToString(ctx, argv[0]);
-    if (JS_IsException(str_val)) return JS_EXCEPTION;
-
-    JSValue len_val = JS_GetPropertyStr(ctx, str_val, "length");
-    int64_t len;
-    if (JS_ToInt64(ctx, &len, len_val)) {
-        JS_FreeValue(ctx, len_val);
-        JS_FreeValue(ctx, str_val);
-        return JS_EXCEPTION;
-    }
-    JS_FreeValue(ctx, len_val);
+    size_t str_len = 0;
+    const char* str = JS_ToCStringLen(ctx, &str_len, argv[0]);
+    if (!str) return JS_EXCEPTION;
 
-    /* Extract code points into a byte buffer, validating latin1 range */
-    uint8_t* bytes = static_cast<uint8_t*>(js_malloc(ctx, len > 0 ? len : 1));
+    /* Never more code points than UTF-8 bytes. */
+    uint8_t* bytes = static_cast<uint8_t*>(js_malloc(ctx, str_len > 0 ? str_len : 1));
     if (!bytes) {
-        JS_FreeValue(ctx, str_val);
+        JS_FreeCString(ctx, str);
         return JS_EXCEPTION;
     }
-
-    JSAtom charCodeAt_atom = JS_NewAtom(ctx, "charCodeAt");
-    for (int64_t i = 0; i < len; i++) {
-        JSValue idx = JS_NewInt64(ctx, i);
-        JSValue code = JS_Invoke(ctx, str_val, charCodeAt_atom, 1, &idx);
-        JS_FreeValue(ctx, idx);
-        if (JS_IsException(code)) {
-            JS_FreeAtom(ctx, charCodeAt_atom);
-            js_free(ctx, bytes);
-            JS_FreeValue(ctx, str_val);
-            return JS_EXCEPTION;
+    size_t len = 0;
+    for (size_t i = 0; i < str_len;) {
+        uint8_t b = (uint8_t)str[i];
+        uint32_t cp = 0x100;
+        if (b < 0x80) {
+            cp = b;
+            i += 1;
+        } else if ((b & 0xE0) == 0xC0 && i + 1 < str_len) {
+            cp = ((b & 0x1Fu) << 6) | ((uint8_t)str[i + 1] & 0x3Fu);
+            i += 2;
         }
-        int32_t cp;
-        JS_ToInt32(ctx, &cp, code);
-        JS_FreeValue(ctx, code);
         if (cp > 0xFF) {
-            JS_FreeAtom(ctx, charCodeAt_atom);
             js_free(ctx, bytes);
-            JS_FreeValue(ctx, str_val);
+            JS_FreeCString(ctx, str);
             return JS_ThrowRangeError(ctx,
                                       "The string to be encoded contains characters outside of the "
                                       "Latin1 range");
         }
-        bytes[i] = (uint8_t)cp;
+        bytes[len++] = (uint8_t)cp;
     }
-    JS_FreeAtom(ctx, charCodeAt_atom);
-    JS_FreeValue(ctx, str_val);
+    JS_FreeCString(ctx, str);
 
     size_t out_len = 4 * ((len + 2) / 3);
     char* out = static_cast<char*>(js_malloc(ctx, out_len + 1));
@@ -411,7 +401,7 @@ static JSValue mik__btoa(JSContext* ctx, JSValue this_val, int argc, JSValue* ar
     }
 
     size_t j = 0;
-    for (int64_t i = 0; i < len; i += 3) {
+    for (size_t i = 0; i < len; i += 3) {
         uint32_t a = bytes[i];
         uint32_t b = (i + 1 < len) ? bytes[i + 1] : 0;
         uint32_t c = (i + 2 < len) ? bytes[i + 2] : 0;

package/src/mik_udp.cpp

@@ -520,7 +520,10 @@ static JSValue mik__udp_bind(JSContext* ctx, JSValue this_val, int argc, JSValue
     JS_FreeValue(ctx, rq_val);
     if (recv_queue < 1) recv_queue = 1;
 
-    /* Create socket */
+    /* Create socket. The stack may not be running yet on platforms that
+     * start it on demand (nothing else in this file needs an interface). */
+    const MIKPlatform* platform = MIK_GetPlatform();
+    if (platform->net_init) platform->net_init();
     int fd = socket(family, SOCK_DGRAM, 0);
     if (fd < 0) {
         if (address) JS_FreeCString(ctx, address);
@@ -650,6 +653,13 @@ static JSValue mik__udp_bind(JSContext* ctx, JSValue this_val, int argc, JSValue
 
 /* ── Loop consumer ───────────────────────────────────────────────────*/
 
+bool mik__udp_has_open_sockets(JSContext* ctx) {
+    for (UdpSocketState* s : g_open_sockets) {
+        if (s && !s->dead && !s->closed && s->ctx == ctx) return true;
+    }
+    return false;
+}
+
 static void mik__udp_consume(JSContext* ctx) {
     g_iteration_depth++;
 

package/src/mikrojs.cpp

@@ -316,6 +316,7 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
     mik_rt->result_proto = JS_UNDEFINED;
     mik_rt->result_ok_void_singleton = JS_UNDEFINED;
     mik_rt->http_body_consumed_ctor = JS_UNDEFINED;
+    mik_rt->inspect_cache.object_proto = JS_UNDEFINED;
 
     /* Default fs read cap: 64 KiB. Large enough for typical config/JSON
      * payloads on MCU; small enough that a runaway readFile() can't
@@ -379,11 +380,6 @@ MIKRuntime* MIK_NewRuntimeInternal(MIKRunOptions* options) {
     mik__inspect_register(ctx);
     mik__pub_fs_register(ctx);
 
-    /* Call registered native module init functions */
-    for (const auto& mod : mik_rt->native_modules) {
-        mod.init_fn(ctx);
-    }
-
     JSModuleDef* stdio_mod = JS_NewCModule(ctx, "native:mikro/stdio", mik__stdio_module_init);
     CHECK_NOT_NULL(stdio_mod);
     mik__add_exports(ctx, stdio_mod, stdio_exports, countof(stdio_exports));
@@ -455,7 +451,16 @@ void MIK_FreeRuntime(MIKRuntime* mik_rt) {
     mik_rt->http_body_consumed_ctor = JS_UNDEFINED;
     JS_FreeValue(mik_rt->ctx, mik_rt->result_proto);
     mik_rt->result_proto = JS_UNDEFINED;
+    MIKInspectCache& ic = mik_rt->inspect_cache;
+    JS_FreeValue(mik_rt->ctx, ic.object_proto);
+    ic.object_proto = JS_UNDEFINED;
     JS_FreeContext(mik_rt->ctx);
+    MIKResultAtoms& ra = mik_rt->result_atoms;
+    JS_FreeAtomsRT(mik_rt->rt, ra.ok, ra.value, ra.error, ra.err, ra.code, ra.message, ra.name);
+    ra = {};
+    JS_FreeAtomsRT(mik_rt->rt, ic.inspect_symbol, ic.to_string_tag);
+    ic.inspect_symbol = JS_ATOM_NULL;
+    ic.to_string_tag = JS_ATOM_NULL;
     JS_FreeRuntime(mik_rt->rt);
 
     /* Call destructor for C++ members, then free */
@@ -531,11 +536,6 @@ void MIK_SetTestEmitHandler(MIKRuntime* mik_rt, MIKTestEmitHandlerFn fn, void* o
     mik_rt->test_emit_opaque = opaque;
 }
 
-void MIK_RegisterNativeModuleInit(MIKRuntime* mik_rt, const char* name,
-                                  MIKNativeModuleInitFn init_fn) {
-    mik_rt->native_modules.push_back({name, init_fn});
-}
-
 void MIK_RegisterLoopConsumer(MIKRuntime* mik_rt, MIKLoopConsumeFn consume_fn,
                               MIKLoopDestroyFn destroy_fn) {
     /* Idempotent: a module can be brought up twice — once by native code that
@@ -768,6 +768,51 @@ int MIK_Loop(MIKRuntime* mik_rt) {
     return mik_rt->stop_requested ? 1 : 0;
 }
 
+/* The nearer of a wake (-1 = none) and a deadline `delay` us away. */
+static int64_t mik__nearer_wake(int64_t wake, int64_t delay) {
+    if (delay <= 0) return 0;
+    return (wake < 0 || delay < wake) ? delay : wake;
+}
+
+/* The UDP consumer polls recvfrom: bound sockets get this poll period. */
+static constexpr int64_t MIK__UDP_POLL_US = 10 * 1000;
+
+int64_t mik__next_wake_us(MIKRuntime* mik_rt) {
+    int64_t now = MIK_GetPlatform()->get_boot_us();
+    /* The grace window has one job, the restart, and MIK_Loop takes it at
+     * the deadline; nothing else runs meanwhile. */
+    if (mik_rt->restart_at_us > 0) {
+        return mik__nearer_wake(-1, mik_rt->restart_at_us - now);
+    }
+    if (mik_rt->stop_requested || JS_IsJobPending(mik_rt->rt)) {
+        return 0;
+    }
+    int64_t wake = -1;
+    for (const auto& entry : mik_rt->timers->entries) {
+        wake = mik__nearer_wake(wake, entry.next_deadline - now);
+        if (wake == 0) return 0;
+    }
+    /* The feed and awake checks run at the top of the pass, so a wait must
+     * end by their deadlines for them to fire on time. */
+    if (mik_rt->feed_armed) {
+        wake = mik__nearer_wake(
+            wake, mik_rt->feed_last_us + (int64_t)mik_rt->config.feed_timeout_ms * 1000 - now);
+    }
+    if (mik_rt->awake_armed) {
+        wake = mik__nearer_wake(wake, mik_rt->awake_pause_offset_us +
+                                          (int64_t)mik_rt->config.awake_timeout_ms * 1000 - now);
+    }
+    if (mik__udp_has_open_sockets(mik_rt->ctx)) {
+        wake = mik__nearer_wake(wake, MIK__UDP_POLL_US);
+    }
+    return wake;
+}
+
+void MIK_Wake(void) {
+    const MIKPlatform* platform = MIK_GetPlatform();
+    if (platform->wake) platform->wake();
+}
+
 void MIK_SetConfig(MIKRuntime* mik_rt, const MIKConfig* config) {
     CHECK_NOT_NULL(mik_rt);
     CHECK_NOT_NULL(config);

package/src/modules.cpp

@@ -252,6 +252,7 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
             {"mikro/http/helpers", mik__http_helpers_load},
             {"mikro/http/request", mik__http_request_load},
             {"mikro/observable/operators", mik__observable_operators_load},
+            {"mikro/test", mik__test_load},
             {"mikro/wifi", mik__wifi_client_load},
         };
         for (const auto& cm : c_modules) {

package/src/platform_posix.cpp

@@ -1,5 +1,7 @@
 #include "mikrojs/platform.h"
 
+#include <errno.h>
+#include <pthread.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -29,6 +31,38 @@ static void posix_yield(void) {
     usleep(1000);
 }
 
+/* One waiter (the serve loop's thread); wakes are latched so one that lands
+ * before the wait is not lost. */
+static pthread_mutex_t posix_wake_mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t posix_wake_cond = PTHREAD_COND_INITIALIZER;
+static bool posix_wake_pending = false;
+
+static void posix_wait(int64_t timeout_us) {
+    struct timespec deadline;
+    clock_gettime(CLOCK_REALTIME, &deadline);
+    deadline.tv_sec += timeout_us / 1000000;
+    deadline.tv_nsec += (timeout_us % 1000000) * 1000;
+    if (deadline.tv_nsec >= 1000000000L) {
+        deadline.tv_sec += 1;
+        deadline.tv_nsec -= 1000000000L;
+    }
+    pthread_mutex_lock(&posix_wake_mutex);
+    while (!posix_wake_pending) {
+        if (pthread_cond_timedwait(&posix_wake_cond, &posix_wake_mutex, &deadline) == ETIMEDOUT) {
+            break;
+        }
+    }
+    posix_wake_pending = false;
+    pthread_mutex_unlock(&posix_wake_mutex);
+}
+
+static void posix_wake(void) {
+    pthread_mutex_lock(&posix_wake_mutex);
+    posix_wake_pending = true;
+    pthread_cond_signal(&posix_wake_cond);
+    pthread_mutex_unlock(&posix_wake_mutex);
+}
+
 static size_t posix_get_free_system_mem(void) {
     return 0;  /* Not available on desktop */
 }
@@ -152,6 +186,8 @@ static const MIKPlatform posix_platform = {
     .random = posix_random,
     .restart = posix_restart,
     .yield = posix_yield,
+    .wait = posix_wait,
+    .wake = posix_wake,
     .get_free_system_mem = posix_get_free_system_mem,
     .get_min_free_system_mem = posix_get_min_free_system_mem,
     .get_total_system_mem = posix_get_total_system_mem,

package/src/timers.cpp

@@ -152,9 +152,9 @@ void mik__timers_consume(JSContext* ctx) {
 
     for (auto& entry : timers->entries) {
         if (entry.next_deadline <= now) {
-            if (due_count < MIK_MAX_DUE_TIMERS) {
-                due_ids[due_count++] = entry.id;
-            }
+            // Past the cap, a timer stays due and runs on the next pass.
+            if (due_count == MIK_MAX_DUE_TIMERS) break;
+            due_ids[due_count++] = entry.id;
             // Drift-free: advance from the previous deadline, not from now, so the rate
             // stays exact. After a stall of a whole period, resume from now; never burst.
             if (entry.is_interval) {

package/src/utils.cpp

@@ -24,8 +24,7 @@ JSValue mik_throw_errno(JSContext* ctx, int err) {
 }
 
 void mik_assert(const struct AssertionInfo info) {
-    fprintf(stderr, "%s:%s%s Assertion `%s' failed.\n", info.file_line, info.function,
-            *info.function ? ":" : "", info.message);
+    fprintf(stderr, "%s Assertion '%s' failed\n", info.file_line, info.message);
     fflush(stderr);
     abort();
 }
@@ -234,12 +233,6 @@ void MIK_ClearPromise(JSContext* ctx, MIKPromise* p) {
     p->rfuncs[1] = JS_UNDEFINED;
 }
 
-void MIK_MarkPromise(JSRuntime* rt, MIKPromise* p, JS_MarkFunc* mark_func) {
-    JS_MarkValue(rt, p->p, mark_func);
-    JS_MarkValue(rt, p->rfuncs[0], mark_func);
-    JS_MarkValue(rt, p->rfuncs[1], mark_func);
-}
-
 void MIK_SettlePromise(JSContext* ctx, MIKPromise* p, bool is_reject, int argc, JSValue* argv) {
     JSValue ret = JS_Call(ctx, p->rfuncs[is_reject], JS_UNDEFINED, argc, argv);
     for (int i = 0; i < argc; i++) {
@@ -301,7 +294,19 @@ static void* mik__buf_realloc(JSRuntime* rt, void* opaque, void* ptr, size_t siz
 }
 
 JSValue MIK_NewUint8Array(JSContext* ctx, uint8_t* data, size_t size) {
-    return JS_NewUint8Array(ctx, data, size, mik__buf_realloc, NULL, false);
+    /* JS_NewUint8Array leaks `data` when the ArrayBuffer object cannot be
+     * allocated. Once JS_NewArrayBuffer succeeds, the buffer owns `data`. */
+    JSValue ab = JS_NewArrayBuffer(ctx, data, size, 0, mik__buf_realloc, NULL, false);
+    if (JS_IsException(ab)) {
+        js_free(ctx, data);
+        return ab;
+    }
+    /* Before quickjs-ng 0.17.0, JS_NewTypedArray reads argv[1] and argv[2]
+     * whatever argc says, so pass all three. */
+    JSValueConst args[3] = {ab, JS_UNDEFINED, JS_UNDEFINED};
+    JSValue u8 = JS_NewTypedArray(ctx, 3, args, JS_TYPED_ARRAY_UINT8);
+    JS_FreeValue(ctx, ab);
+    return u8;
 }
 
 void mik_dbuf_init(JSContext* ctx, DynBuf* s) {