@mikrojs/native 0.18.0 → 0.18.1

package/src/mik_result.cpp

@@ -86,7 +86,9 @@ JSValue mik__result_err(JSContext* ctx, int code, int platform_errno, const char
 JSValue mik__result_err_named(JSContext* ctx, const char* name, const char* fmt, ...) {
     va_list ap;
     va_start(ap, fmt);
-    char msg[256];
+    /* 384 matches the HTTP task's error_buf: fetch errors pass through here
+     * verbatim, and a smaller buffer truncates their trailing heap figures. */
+    char msg[384];
     vsnprintf(msg, sizeof(msg), fmt, ap);
     va_end(ap);
 

package/src/mik_sys_codec.cpp

@@ -0,0 +1,167 @@
+#include "mikrojs/sys_codec.h"
+
+#include <nanocbor/nanocbor.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <cstring>
+
+size_t mik__kv_encode_str(const char* value, uint8_t* out, size_t out_len) {
+    /* The measuring pass needs a non-null base: an empty string still reaches
+     * memcpy with length 0, and memcpy(NULL, ..., 0) is undefined behavior. */
+    static uint8_t measure_base;
+    nanocbor_encoder_t enc;
+    nanocbor_encoder_init(&enc, &measure_base, 0);
+    nanocbor_put_tstr(&enc, value ? value : "");
+    size_t needed = nanocbor_encoded_len(&enc);
+    if (!out || out_len < needed) return needed;
+    nanocbor_encoder_init(&enc, out, out_len);
+    nanocbor_put_tstr(&enc, value ? value : "");
+    return needed;
+}
+
+bool mik__kv_decode_str(const uint8_t* in, size_t in_len, char* out, size_t out_len) {
+    if (!in || in_len == 0 || !out || out_len == 0) return false;
+    nanocbor_value_t it;
+    nanocbor_decoder_init(&it, in, in_len);
+    const uint8_t* ptr = nullptr;
+    size_t len = 0;
+    if (nanocbor_get_tstr(&it, &ptr, &len) < 0) return false;
+    if (len + 1 > out_len) return false;
+    memcpy(out, ptr, len);
+    out[len] = '\0';
+    return true;
+}
+
+size_t mik__kv_encode_i32(int32_t value, uint8_t* out, size_t out_len) {
+    static uint8_t measure_base;
+    nanocbor_encoder_t enc;
+    nanocbor_encoder_init(&enc, &measure_base, 0);
+    nanocbor_fmt_int(&enc, value);
+    size_t needed = nanocbor_encoded_len(&enc);
+    if (!out || out_len < needed) return needed;
+    nanocbor_encoder_init(&enc, out, out_len);
+    nanocbor_fmt_int(&enc, value);
+    return needed;
+}
+
+bool mik__kv_decode_i32(const uint8_t* in, size_t in_len, int32_t* out) {
+    if (!in || in_len == 0 || !out) return false;
+    nanocbor_value_t it;
+    nanocbor_decoder_init(&it, in, in_len);
+    return nanocbor_get_int32(&it, out) >= 0;
+}
+
+
+/* ── Device name pair ─────────────────────────────────────────────────────── */
+
+namespace {
+
+const char* skip_space(const char* p) {
+    while (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r') p++;
+    return p;
+}
+
+}  // namespace
+
+bool mik__device_name_parse(const char* json, int* out_rev, char* out_name, size_t name_len) {
+    if (!json || !out_rev || !out_name || name_len == 0) return false;
+    out_name[0] = '\0';
+
+    const char* p = skip_space(json);
+    if (*p != '[') return false;
+    p = skip_space(p + 1);
+
+    /* The revision. Negative and non-integer values are not pairs. */
+    if (*p < '0' || *p > '9') return false;
+    long rev = 0;
+    while (*p >= '0' && *p <= '9') {
+        rev = rev * 10 + (*p - '0');
+        if (rev > INT32_MAX) return false;
+        p++;
+    }
+    p = skip_space(p);
+    *out_rev = (int)rev;
+
+    if (*p == ']') return true;  /* [rev] — cleared */
+    if (*p != ',') return false;
+    p = skip_space(p + 1);
+
+    /* A cleared name may also arrive as an explicit null. */
+    if (strncmp(p, "null", 4) == 0) {
+        p = skip_space(p + 4);
+        return *p == ']';
+    }
+    if (*p != '"') return false;
+    p++;
+
+    size_t written = 0;
+    while (*p && *p != '"') {
+        /* Escapes: the writer is JSON.stringify, so a name can carry them. Only
+         * the forms it emits are handled; anything else fails the parse rather
+         * than storing a half-decoded name. */
+        char c = *p;
+        if (c == '\\') {
+            p++;
+            switch (*p) {
+                case '"':
+                case '\\':
+                case '/':
+                    c = *p;
+                    break;
+                case 'n':
+                    c = '\n';
+                    break;
+                case 't':
+                    c = '\t';
+                    break;
+                case 'r':
+                    c = '\r';
+                    break;
+                case 'b':
+                    c = '\b';
+                    break;
+                case 'f':
+                    c = '\f';
+                    break;
+                default:
+                    return false;
+            }
+        }
+        if (written + 1 >= name_len) return false;
+        out_name[written++] = c;
+        p++;
+    }
+    if (*p != '"') return false;
+    out_name[written] = '\0';
+    p = skip_space(p + 1);
+    return *p == ']';
+}
+
+size_t mik__device_name_format(int rev, const char* name, char* out, size_t out_len) {
+    if (rev < 0) rev = 0;
+    if (!name || !name[0]) {
+        int needed = snprintf(nullptr, 0, "[%d]", rev);
+        if (out && out_len > (size_t)needed) snprintf(out, out_len, "[%d]", rev);
+        return (size_t)needed;
+    }
+    /* Escape what JSON requires. Control characters below 0x20 have no short
+     * form here, so they are dropped rather than emitted raw — a name is display
+     * text, and a device is not the place to grow a \u encoder. */
+    char escaped[128];
+    size_t w = 0;
+    for (const char* p = name; *p && w + 2 < sizeof(escaped); p++) {
+        unsigned char c = (unsigned char)*p;
+        if (c == '"' || c == '\\') {
+            escaped[w++] = '\\';
+            escaped[w++] = (char)c;
+        } else if (c >= 0x20) {
+            escaped[w++] = (char)c;
+        }
+    }
+    escaped[w] = '\0';
+
+    int needed = snprintf(nullptr, 0, "[%d,\"%s\"]", rev, escaped);
+    if (out && out_len > (size_t)needed) snprintf(out, out_len, "[%d,\"%s\"]", rev, escaped);
+    return (size_t)needed;
+}

package/src/mikrojs.cpp

@@ -16,7 +16,16 @@
 #include "mikrojs/private.h"
 #include "mikrojs/utils.h"
 
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+#if defined(__SANITIZE_ADDRESS__) || __has_feature(address_sanitizer)
+/* ASan inflates native frames severalfold; the regular default overflows
+ * on shallow JS recursion in instrumented builds. Never active on device. */
+#define MIK__DEFAULT_STACK_SIZE 8 * 1024 * 1024
+#else
 #define MIK__DEFAULT_STACK_SIZE 1024 * 1024  // 1 MB
+#endif
 
 /* JS malloc functions. Routed through the mik__js_* family so the QuickJS
  * heap can be relocated to PSRAM on chips with both internal SRAM and PSRAM,
@@ -497,6 +506,12 @@ void MIK_RegisterNativeModuleInit(MIKRuntime* mik_rt, const char* name,
 
 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
+     * uses its machinery directly, once by the loader when JS imports it — and
+     * registering the pair twice would run its destroy twice at teardown. */
+    for (const auto& consumer : mik_rt->loop_consumers) {
+        if (consumer.consume_fn == consume_fn && consumer.destroy_fn == destroy_fn) return;
+    }
     mik_rt->loop_consumers.push_back({consume_fn, destroy_fn});
 }
 

package/src/modules.cpp

@@ -61,10 +61,10 @@ static JSModuleDef* mik__load_bjs_module(JSContext* ctx, const char* module_name
         JS_FreeValue(ctx, func_val);
         return NULL;
     }
-    if (JS_ResolveModule(ctx, func_val) < 0) {
-        JS_FreeValue(ctx, func_val);
-        return NULL;
-    }
+    /* No JS_ResolveModule here: this runs inside the module loader, and its
+     * failure path frees every unresolved module in the context — including
+     * a partially-read parent an outer JS_ReadModule frame still holds. The
+     * root resolve covers loader-returned modules. */
     js_module_set_import_meta(ctx, func_val, true, false);
     JSModuleDef* m = static_cast<JSModuleDef*>(JS_VALUE_GET_PTR(func_val));
     JS_FreeValue(ctx, func_val);
@@ -452,7 +452,19 @@ static const char* mik__resolve_export_condition(JSContext* ctx, JSValue exp) {
  *
  * TODO: check publishConfig.exports before exports
  */
-static const char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, const char* subpath) {
+/* Copy a JS_ToCString result into a js_malloc'd buffer, so every return
+ * from mik__resolve_pkg_entry uses one allocator — the "./index.js"
+ * fallback has no JSString to borrow, and mixing JS_FreeCString with
+ * js_strdup'd pointers walks back to a fake string header. */
+static char* mik__dup_cstring(JSContext* ctx, const char* cstr) {
+    if (!cstr) return NULL;
+    char* copy = js_strdup(ctx, cstr);
+    JS_FreeCString(ctx, cstr);
+    return copy;
+}
+
+/* Returns a js_malloc'd entry path (caller frees with js_free), or NULL. */
+static char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, const char* subpath) {
     JSValue exports = JS_GetPropertyStr(ctx, pkg_json, "exports");
 
     if (JS_IsUndefined(exports)) {
@@ -460,7 +472,7 @@ static const char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, cons
         /* No exports field — fall back to "main", then "./index.js" */
         JSValue main_val = JS_GetPropertyStr(ctx, pkg_json, "main");
         if (JS_IsString(main_val)) {
-            const char* result = JS_ToCString(ctx, main_val);
+            char* result = mik__dup_cstring(ctx, JS_ToCString(ctx, main_val));
             JS_FreeValue(ctx, main_val);
             return result;
         }
@@ -470,7 +482,7 @@ static const char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, cons
 
     /* exports is a plain string — use it directly */
     if (JS_IsString(exports)) {
-        const char* result = JS_ToCString(ctx, exports);
+        char* result = mik__dup_cstring(ctx, JS_ToCString(ctx, exports));
         JS_FreeValue(ctx, exports);
         return result;
     }
@@ -479,7 +491,7 @@ static const char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, cons
     if (JS_IsObject(exports)) {
         JSValue subpath_val = JS_GetPropertyStr(ctx, exports, subpath);
         if (!JS_IsUndefined(subpath_val) && !JS_IsException(subpath_val)) {
-            const char* result = mik__resolve_export_condition(ctx, subpath_val);
+            char* result = mik__dup_cstring(ctx, mik__resolve_export_condition(ctx, subpath_val));
             JS_FreeValue(ctx, subpath_val);
             JS_FreeValue(ctx, exports);
             return result;
@@ -490,7 +502,7 @@ static const char* mik__resolve_pkg_entry(JSContext* ctx, JSValue pkg_json, cons
          * itself as a conditions object. This handles the common shorthand where
          * exports is {"default": "./index.js"} instead of {".": {"default": ...}} */
         if (strcmp(subpath, ".") == 0) {
-            const char* result = mik__resolve_export_condition(ctx, exports);
+            char* result = mik__dup_cstring(ctx, mik__resolve_export_condition(ctx, exports));
             JS_FreeValue(ctx, exports);
             return result;
         }
@@ -593,7 +605,7 @@ static char* mik__try_resolve_pkg(JSContext* ctx, const char* dir, const MIKPkgS
         return NULL;
     }
 
-    const char* entry = mik__resolve_pkg_entry(ctx, pkg_json, spec->subpath);
+    char* entry = mik__resolve_pkg_entry(ctx, pkg_json, spec->subpath);
     JS_FreeValue(ctx, pkg_json);
 
     if (!entry) {
@@ -608,7 +620,7 @@ static char* mik__try_resolve_pkg(JSContext* ctx, const char* dir, const MIKPkgS
     char result[PATH_MAX];
     snprintf(result, sizeof(result), "%s/node_modules/%.*s/%s", dir, spec->pkg_name_len,
              spec->pkg_name, entry_path);
-    JS_FreeCString(ctx, entry);
+    js_free(ctx, entry);
     return js_strdup(ctx, result);
 }
 
@@ -754,6 +766,8 @@ static char* mik__module_normalizer_impl(JSContext* ctx, const char* base_name,
     } else {
         len = 0;
     }
+    /* A rooted base ('/main.js') has dirname '/', not "" */
+    bool rooted = base_name[0] == MIK__PATHSEP_POSIX;
 
     filename = static_cast<char*>(js_malloc(ctx, len + strlen(name) + 1 + 1));
     if (!filename) {
@@ -771,7 +785,12 @@ static char* mik__module_normalizer_impl(JSContext* ctx, const char* base_name,
             /* remove the last path element of filename, except if "."
                or ".." */
             if (filename[0] == '\0') {
-                break;
+                if (!rooted) {
+                    break;
+                }
+                /* the parent of the root is the root */
+                r += 3;
+                continue;
             }
             p = strrchr(filename, MIK__PATHSEP);
             if (!p) {
@@ -791,7 +810,7 @@ static char* mik__module_normalizer_impl(JSContext* ctx, const char* base_name,
             break;
         }
     }
-    if (filename[0] != '\0') {
+    if (filename[0] != '\0' || rooted) {
         strcat(filename, MIK__PATHSEP_STR);
     }
     strcat(filename, r);