@mikrojs/firmware 0.18.1 → 0.18.2

package/README.md

@@ -26,6 +26,6 @@ See the [Custom Firmware](https://mikrojs.dev/develop/custom-firmware) docs for
 ## Requirements
 
 - Node.js >= 24
-- ESP-IDF >= 6.0.1 (installed via [EIM](https://docs.espressif.com/projects/idf-im-ui/en/latest/))
+- ESP-IDF >= 6.1 (installed via [EIM](https://docs.espressif.com/projects/idf-im-ui/en/latest/))
 
 To build, activate ESP-IDF in your shell first: run `eim select` and source the activation script it prints, then use `idf.py` as usual.

package/components/mikrojs/mik_ble.cpp

@@ -1480,7 +1480,7 @@ static int mik__ble_module_init(JSContext* ctx, JSModuleDef* m) {
 static JSModuleDef* mik__ble_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     CHECK_NOT_NULL(mik_rt);
-    mik__ble_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__ble_slot < 0) mik__ble_slot = MIK_ReserveModuleSlot();
 
     auto* state = new MIKBleState();
     mik__ble_st(mik_rt) = state;

package/components/mikrojs/mik_http.cpp

@@ -923,7 +923,7 @@ static void mik__http_ensure_initialized(JSContext* ctx) {
 void mik__http_ensure_native(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     if (!mik_rt) return;
-    if (mik__http_slot < 0) mik__http_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__http_slot < 0) mik__http_slot = MIK_ReserveModuleSlot();
     mik__http_ensure_initialized(ctx);
     MIK_RegisterLoopConsumer(mik_rt, mik__http_consume, mik__http_destroy);
 }
@@ -941,10 +941,9 @@ static int mik__http_module_init(JSContext* ctx, JSModuleDef* m) {
 }
 
 static JSModuleDef* mik__http_init(JSContext* ctx) {
-    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    /* The slot may already exist: a native consumer can bring the transport up
-     * before anything imports the JS module. */
-    if (mik__http_slot < 0) mik__http_slot = MIK_AllocModuleSlot(mik_rt);
+    /* The slot may already be reserved: a native consumer can bring the
+     * transport up before anything imports the JS module. */
+    if (mik__http_slot < 0) mik__http_slot = MIK_ReserveModuleSlot();
 
     JSModuleDef* m = JS_NewCModule(ctx, "native:mikro/http", mik__http_module_init);
     if (!m) return nullptr;
@@ -973,10 +972,12 @@ void mik__http_consume(JSContext* ctx) {
         if (!p->sink.done || p->deadline_us == 0 || now_us < p->deadline_us) continue;
         MIKHttpNativeSink sink = p->sink;
         /* Stop delivering and let the task's terminal message drop the entry;
-         * the sink hears about it once, here. */
+         * the sink hears about it once, here. `done` must stay set: it is what
+         * marks the entry native, and js_cancelled is what suppresses the
+         * second call. Clearing it would route the terminal message into the
+         * JS branch, onto promises a native entry never created. */
         p->sink.headers = nullptr;
         p->sink.data = nullptr;
-        p->sink.done = nullptr;
         p->js_cancelled = true;
         p->deadline_us = 0;
         if (p->cancelled) p->cancelled->store(true, std::memory_order_relaxed);

package/components/mikrojs/mik_http_server.cpp

@@ -671,8 +671,7 @@ static int mik__hs_module_init(JSContext* ctx, JSModuleDef* m) {
 }
 
 static JSModuleDef* mik__http_server_init(JSContext* ctx) {
-    MIKRuntime* rt = MIK_GetRuntime(ctx);
-    mik__http_server_slot = MIK_AllocModuleSlot(rt);
+    if (mik__http_server_slot < 0) mik__http_server_slot = MIK_ReserveModuleSlot();
 
     JSModuleDef* m = JS_NewCModule(ctx, "native:mikro/http_server", mik__hs_module_init);
     if (!m) return nullptr;

package/components/mikrojs/mik_i2s.cpp

@@ -663,7 +663,7 @@ static int mik__i2s_module_init(JSContext* ctx, JSModuleDef* m) {
 
 static JSModuleDef* mik__i2s_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    mik__i2s_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__i2s_slot < 0) mik__i2s_slot = MIK_ReserveModuleSlot();
 
     auto* slot_data = static_cast<MIKI2sSlot*>(calloc(1, sizeof(MIKI2sSlot)));
     if (!slot_data) return nullptr;

package/components/mikrojs/mik_ota_client_module.cpp

@@ -14,10 +14,12 @@
 #include "esp_log.h"
 #include "mik_http_internal.h"
 #include "mik_ota_native.h"
+#include "mikrojs/cbor_helpers.h"
 #include "mikrojs/ota_client.h"
 #include "mikrojs/ota_config.h"
 #include "mikrojs/ota_js_hooks.h"
 #include "mikrojs/ota_policy.h"
+#include "mikrojs/ota_slots.h"
 #include "mikrojs/private.h"
 #include "mikrojs/utils.h"
 
@@ -26,6 +28,7 @@ using mikrojs::MIKOtaCheckResult;
 using mikrojs::MIKOtaCheckStatus;
 using mikrojs::MIKOtaClient;
 using mikrojs::MIKOtaConfigReader;
+using mikrojs::MIKOtaConfigWrite;
 using mikrojs::MIKOtaJsHooks;
 using mikrojs::MIKOtaApplyOutcome;
 using mikrojs::MIKOtaApplySession;
@@ -628,6 +631,174 @@ JSValue ota_apply_offer(JSContext* ctx, JSValue, int argc, JSValue* argv) {
     return promise;
 }
 
+// ── config delivery ─────────────────────────────────────────────────────────
+//
+// The write side of config sync, for a client that received a document over its
+// own transport. Where the slot policy lives is src/mik_ota_config.cpp, shared
+// with the built-in client, so the two cannot disagree about the trial or the
+// rollback baseline. What is here is the marshalling.
+
+/* Copy a string field into a fixed buffer. False when it is the wrong type or
+ * too long to hold: a truncated rev never matches the one the registry issued,
+ * so the device would be served the same document forever. */
+bool take_config_field(JSContext* ctx, JSValue obj, const char* key, char* out, size_t out_len,
+                       bool* out_present) {
+    *out_present = false;
+    JSValue value = JS_GetPropertyStr(ctx, obj, key);
+    if (JS_IsUndefined(value) || JS_IsNull(value)) {
+        JS_FreeValue(ctx, value);
+        return true;
+    }
+    if (!JS_IsString(value)) {
+        JS_FreeValue(ctx, value);
+        return false;
+    }
+    const char* text = JS_ToCString(ctx, value);
+    JS_FreeValue(ctx, value);
+    if (!text) return false;
+    bool fits = strlen(text) < out_len;
+    if (fits) {
+        snprintf(out, out_len, "%s", text);
+        *out_present = text[0] != '\0';
+    }
+    JS_FreeCString(ctx, text);
+    return fits;
+}
+
+/* Validate a raw value into the fields a stored config carries. `*out_doc` is
+ * the document to store, or JS_UNDEFINED for the clear; the caller owns it. */
+bool config_from_js(JSContext* ctx, JSValue raw, MIKOtaStoredConfig* out, JSValue* out_doc) {
+    *out_doc = JS_UNDEFINED;
+    if (!JS_IsObject(raw) || JS_IsArray(raw) || JS_IsFunction(ctx, raw)) return false;
+
+    /* The stamp is what says which release the document was computed for, and
+     * every read is decided by it. A document without one cannot be placed. */
+    bool has_version = false;
+    if (!take_config_field(ctx, raw, "version", out->version, sizeof(out->version),
+                           &has_version)) {
+        return false;
+    }
+    if (!has_version) return false;
+
+    bool has_rev = false;
+    if (!take_config_field(ctx, raw, "rev", out->rev, sizeof(out->rev), &has_rev)) return false;
+
+    JSValue doc = JS_GetPropertyStr(ctx, raw, "doc");
+    if (JS_IsUndefined(doc) || JS_IsNull(doc)) {
+        /* An absent document is the clear, not a malformed config. */
+        JS_FreeValue(ctx, doc);
+        return true;
+    }
+    /* The document is spread over the manifest defaults, top level only.
+     * Anything that is not a plain object has no keys to spread, so storing one
+     * would read back as an empty overlay rather than as the error it is. */
+    if (!JS_IsObject(doc) || JS_IsArray(doc) || JS_IsFunction(ctx, doc)) {
+        JS_FreeValue(ctx, doc);
+        return false;
+    }
+    *out_doc = doc;
+    return true;
+}
+
+/* Encode a document to the CBOR the slots store. False for a value CBOR cannot
+ * carry (a function, a cycle, past the depth limit). */
+bool encode_config_doc(JSContext* ctx, JSValue doc, std::vector<uint8_t>* out) {
+    /* Pass 1 sizes it against a zero-capacity buffer; the base pointer must be
+     * non-null because a zero-length append still reaches memcpy. */
+    static uint8_t measure_base;
+    nanocbor_encoder_t enc;
+    nanocbor_encoder_init(&enc, &measure_base, 0);
+    bool ok = mik__cbor_encode_value(ctx, &enc, doc, 0) >= 0;
+    size_t needed = nanocbor_encoded_len(&enc);
+    if (ok && needed > 0) {
+        out->resize(needed);
+        nanocbor_encoder_init(&enc, out->data(), needed);
+        ok = mik__cbor_encode_value(ctx, &enc, doc, 0) >= 0;
+    } else {
+        ok = false;
+    }
+    /* Property enumeration can throw on the way out, and an exception left on
+     * the context would surface at whatever ran next. */
+    if (JS_HasException(ctx)) JS_FreeValue(ctx, JS_GetException(ctx));
+    return ok;
+}
+
+/* parseConfig(raw) -> StoredConfig | undefined */
+JSValue ota_parse_config(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+    MIKOtaStoredConfig cfg = {};
+    JSValue doc = JS_UNDEFINED;
+    if (argc < 1 || !config_from_js(ctx, argv[0], &cfg, &doc)) {
+        JS_FreeValue(ctx, doc);
+        return JS_UNDEFINED;
+    }
+    JSValue obj = JS_NewObject(ctx);
+    if (cfg.rev[0]) JS_SetPropertyStr(ctx, obj, "rev", JS_NewString(ctx, cfg.rev));
+    JS_SetPropertyStr(ctx, obj, "version", JS_NewString(ctx, cfg.version));
+    if (JS_IsUndefined(doc)) return obj;
+    /* The document travels on as it arrived: whether it survives CBOR is
+     * settled by applyConfig, which is where the bytes are actually made. */
+    JS_SetPropertyStr(ctx, obj, "doc", doc);
+    return obj;
+}
+
+/* applyConfig(cfg, {trialBoots}) -> ConfigWrite */
+JSValue ota_apply_config(JSContext* ctx, JSValue, int argc, JSValue* argv) {
+    MIKOtaClientState* state = state_of(ctx);
+    CHECK_NOT_NULL(state);
+
+    MIKOtaStoredConfig cfg = {};
+    JSValue doc = JS_UNDEFINED;
+    if (argc < 1 || !config_from_js(ctx, argv[0], &cfg, &doc)) {
+        JS_FreeValue(ctx, doc);
+        return JS_NewString(ctx, "invalid");
+    }
+
+    /* Held until the write is done: the stored config's span points into it. */
+    std::vector<uint8_t> bytes;
+    if (!JS_IsUndefined(doc)) {
+        bool encoded = encode_config_doc(ctx, doc, &bytes);
+        JS_FreeValue(ctx, doc);
+        if (!encoded) return JS_NewString(ctx, "invalid");
+        cfg.doc_cbor = bytes.data();
+        cfg.doc_cbor_len = bytes.size();
+    }
+
+    MIKOtaCheckOptions defaults;
+    int trial_boots = defaults.trial_boots;
+    if (argc > 1 && JS_IsObject(argv[1])) {
+        trial_boots = (int)opt_u32(ctx, argv[1], "trialBoots", (uint32_t)trial_boots);
+    }
+    /* A budget of zero would roll the document back on the first read that
+     * serves it, which is never what an app meant by delivering one. */
+    if (trial_boots < 1) trial_boots = 1;
+
+    MIKOtaConfigWrite write = mikrojs::mik__ota_deliver_config(state->env, &cfg, trial_boots);
+    return JS_NewString(ctx, mikrojs::mik__ota_config_write_to_str(write));
+}
+
+/* configState() -> {rev?, error?} */
+JSValue ota_config_state(JSContext* ctx, JSValue, int, JSValue*) {
+    MIKOtaClientState* state = state_of(ctx);
+    CHECK_NOT_NULL(state);
+
+    JSValue obj = JS_NewObject(ctx);
+    MIKOtaConfigErrorReport report = {};
+    bool has_error = mikrojs::mik__ota_load_config_error(state->env, &report);
+    if (has_error) {
+        JSValue error = JS_NewObject(ctx);
+        JS_SetPropertyStr(ctx, error, "rev", JS_NewString(ctx, report.rev));
+        JS_SetPropertyStr(ctx, error, "message", JS_NewString(ctx, report.message));
+        JS_SetPropertyStr(ctx, obj, "error", error);
+    }
+    /* After a rollback the FAILED document's rev is the one to echo, not the
+     * restored one's: echoed-equals-held is what stops the registry serving the
+     * document that just failed, until an operator changes it. */
+    mikrojs::MIKOtaLoadedConfig held = mikrojs::mik__ota_load_slot(state->env, MIK_OTA_CFG_CURRENT);
+    const char* rev = has_error ? report.rev : (held.present ? held.cfg.rev : "");
+    if (rev[0]) JS_SetPropertyStr(ctx, obj, "rev", JS_NewString(ctx, rev));
+    return obj;
+}
+
 int mik__ota_client_module_init(JSContext* ctx, JSModuleDef* m) {
     JS_SetModuleExport(ctx, m, "check", JS_NewCFunction(ctx, mik__ota_client_check, "check", 1));
     JS_SetModuleExport(ctx, m, "watch", JS_NewCFunction(ctx, mik__ota_client_watch, "watch", 1));
@@ -642,6 +813,12 @@ int mik__ota_client_module_init(JSContext* ctx, JSModuleDef* m) {
                        JS_NewCFunction(ctx, ota_parse_offer, "parseOffer", 2));
     JS_SetModuleExport(ctx, m, "applyOffer",
                        JS_NewCFunction(ctx, ota_apply_offer, "applyOffer", 3));
+    JS_SetModuleExport(ctx, m, "parseConfig",
+                       JS_NewCFunction(ctx, ota_parse_config, "parseConfig", 1));
+    JS_SetModuleExport(ctx, m, "applyConfig",
+                       JS_NewCFunction(ctx, ota_apply_config, "applyConfig", 2));
+    JS_SetModuleExport(ctx, m, "configState",
+                       JS_NewCFunction(ctx, ota_config_state, "configState", 0));
     return 0;
 }
 
@@ -650,7 +827,7 @@ int mik__ota_client_module_init(JSContext* ctx, JSModuleDef* m) {
 JSModuleDef* mik__ota_client_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     CHECK_NOT_NULL(mik_rt);
-    mik__ota_client_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__ota_client_slot < 0) mik__ota_client_slot = MIK_ReserveModuleSlot();
 
     /* The bytecode version needs a context to derive (JS_WriteObject's first
      * byte), so it is read here and handed to the env, which has none. */
@@ -689,6 +866,9 @@ JSModuleDef* mik__ota_client_init(JSContext* ctx) {
     JS_AddModuleExport(ctx, m, "registry");
     JS_AddModuleExport(ctx, m, "parseOffer");
     JS_AddModuleExport(ctx, m, "applyOffer");
+    JS_AddModuleExport(ctx, m, "parseConfig");
+    JS_AddModuleExport(ctx, m, "applyConfig");
+    JS_AddModuleExport(ctx, m, "configState");
     return m;
 }
 

package/components/mikrojs/mik_pwm.cpp

@@ -464,8 +464,7 @@ static int mik__pwm_module_init(JSContext* ctx, JSModuleDef* m) {
 }
 
 static JSModuleDef* mik__pwm_init(JSContext* ctx) {
-    MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    mik__pwm_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__pwm_slot < 0) mik__pwm_slot = MIK_ReserveModuleSlot();
 
     JSRuntime* rt = JS_GetRuntime(ctx);
 

package/components/mikrojs/mik_sntp.cpp

@@ -196,7 +196,7 @@ static int mik__sntp_module_init(JSContext* ctx, JSModuleDef* m) {
 static JSModuleDef* mik__sntp_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     CHECK_NOT_NULL(mik_rt);
-    mik__sntp_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__sntp_slot < 0) mik__sntp_slot = MIK_ReserveModuleSlot();
 
     auto* state = new MIKSntpState();
     state->event_queue = xQueueCreate(4, sizeof(struct timeval));

package/components/mikrojs/mik_uart.cpp

@@ -465,7 +465,7 @@ static int mik__uart_module_init(JSContext* ctx, JSModuleDef* m) {
 
 static JSModuleDef* mik__uart_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
-    mik__uart_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__uart_slot < 0) mik__uart_slot = MIK_ReserveModuleSlot();
 
     /* Allocate per-runtime slot data */
     auto* slot_data = static_cast<MIKUartSlot*>(calloc(1, sizeof(MIKUartSlot)));

package/components/mikrojs/mik_wifi.cpp

@@ -1236,7 +1236,7 @@ static int mik__wifi_module_init(JSContext* ctx, JSModuleDef* m) {
 static JSModuleDef* mik__wifi_init(JSContext* ctx) {
     MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
     CHECK_NOT_NULL(mik_rt);
-    mik__wifi_slot = MIK_AllocModuleSlot(mik_rt);
+    if (mik__wifi_slot < 0) mik__wifi_slot = MIK_ReserveModuleSlot();
 
     auto* state = new MIKWifiState();
     state->event_queue = xQueueCreate(8, sizeof(MIKWifiEvent));

package/components/mikrojs/test/http_test.cpp

@@ -473,3 +473,107 @@ TEST_CASE("cancel sets the pending cancelled flag", "[http]") {
     TEST_ASSERT_TRUE_MESSAGE(flagAfterCancel, "cancel sets the shared flag");
     TEST_ASSERT_EQUAL_MESSAGE(0, pendingCount, "pending dropped after cancellation settles");
 }
+
+/* ── Native sink (OTA client) ─────────────────────────────────────── */
+
+static int native_done_calls;
+static int native_done_status;
+static char native_done_error[64];
+
+static void native_sink_done(void*, int status, const char* error_msg) {
+    native_done_calls++;
+    native_done_status = status;
+    snprintf(native_done_error, sizeof(native_done_error), "%s", error_msg ? error_msg : "");
+}
+
+/* Install a native pending whose deadline has already passed, the way
+ * mik__http_start_native would minus the background task. Ownership of
+ * `cancelled` transfers to the entry; mik__pending_drop frees it. */
+static uint32_t seed_expired_native_pending() {
+    native_done_calls = 0;
+    native_done_status = -1;
+    native_done_error[0] = '\0';
+
+    MIKHttpState* state = mik__http(rt);
+    MIKHttpPending p = {};
+    p.id = state->next_id++;
+    p.cancelled = new std::atomic<bool>(false);
+    p.sink.done = native_sink_done;
+    p.deadline_us = 1; /* in the past for any running device */
+    state->pending[state->pending_count++] = p;
+    return p.id;
+}
+
+TEST_CASE("a timed-out native request stays tagged native", "[http]") {
+    setup();
+    ensure_http_initialized();
+
+    uint32_t id = seed_expired_native_pending();
+
+    mik__http_consume(ctx);
+    int callsAfterTimeout = native_done_calls;
+    int statusAfterTimeout = native_done_status;
+    char errorAfterTimeout[64];
+    snprintf(errorAfterTimeout, sizeof(errorAfterTimeout), "%s", native_done_error);
+    size_t countAfterTimeout = mik__http(rt)->pending_count;
+    /* The entry outlives the timeout waiting for the task's terminal message.
+     * sink.done is what marks it native; clearing it would send that message
+     * into the JS branch and onto promises this entry never created. */
+    bool stillTaggedNative = mik__http(rt)->pending[0].sink.done != nullptr;
+
+    push_error(id, "connection closed");
+    mik__http_consume(ctx);
+    int callsAfterTerminal = native_done_calls;
+    size_t countAfterTerminal = mik__http(rt)->pending_count;
+
+    teardown();
+
+    TEST_ASSERT_EQUAL_MESSAGE(1, callsAfterTimeout, "deadline sweep reports once");
+    TEST_ASSERT_EQUAL(0, statusAfterTimeout);
+    TEST_ASSERT_EQUAL_STRING("timeout", errorAfterTimeout);
+    TEST_ASSERT_EQUAL_MESSAGE(1, countAfterTimeout, "entry waits for the terminal message");
+    TEST_ASSERT_TRUE_MESSAGE(stillTaggedNative, "sink.done survives the timeout");
+    TEST_ASSERT_EQUAL_MESSAGE(1, callsAfterTerminal, "done is terminal, not repeated");
+    TEST_ASSERT_EQUAL_MESSAGE(0, countAfterTerminal, "terminal message drops the entry");
+}
+
+TEST_CASE("destroy skips promises on a timed-out native request", "[http]") {
+    setup();
+    ensure_http_initialized();
+
+    uint32_t id = seed_expired_native_pending();
+    mik__http_consume(ctx);
+
+    /* Leave the entry in place and let destroy drain the terminal message.
+     * It must take the native branch and free no promises: a native entry's
+     * headers_promise was never built. */
+    push_error(id, "connection closed");
+    int callsBeforeTeardown = native_done_calls;
+
+    teardown();
+
+    TEST_ASSERT_EQUAL(1, callsBeforeTeardown);
+}
+
+TEST_CASE("the http module slot is stable across runtimes", "[http]") {
+    setup();
+    ensure_http_initialized();
+    int slotInFirstRuntime = mik__http_slot;
+    teardown();
+
+    /* A second runtime must find http at the same index, and no other module
+     * may be handed that index here. */
+    setup();
+    int burned = MIK_ReserveModuleSlot();
+    ensure_http_initialized();
+    int slotInSecondRuntime = mik__http_slot;
+    MIKHttpState* state = mik__http(rt);
+    size_t pendingCount = state ? state->pending_count : 999;
+    teardown();
+
+    TEST_ASSERT_EQUAL_MESSAGE(slotInFirstRuntime, slotInSecondRuntime,
+                              "the same module keeps the same slot");
+    TEST_ASSERT_NOT_EQUAL_MESSAGE(burned, slotInSecondRuntime,
+                                  "http must not share a slot with another module");
+    TEST_ASSERT_EQUAL_MESSAGE(0, pendingCount, "fresh state, not another module's bytes");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.18.1",
+  "version": "0.18.2",
   "description": "Mikro.js ESP32 firmware: ESP-IDF component, build tools, and project template",
   "keywords": [
     "esp-idf",
@@ -47,8 +47,8 @@
   },
   "dependencies": {
     "esbuild": "^0.28.0",
-    "@mikrojs/native": "0.18.1",
-    "@mikrojs/quickjs": "0.18.1"
+    "@mikrojs/native": "0.18.2",
+    "@mikrojs/quickjs": "0.18.2"
   },
   "engines": {
     "node": ">=24.0.0"

package/project.cmake

@@ -11,9 +11,9 @@
 
 # ── Validate ESP-IDF version ─────────────────────────────────────────
 if(IDF_VERSION_MAJOR LESS 6 OR
-   (IDF_VERSION_MAJOR EQUAL 6 AND IDF_VERSION_MINOR EQUAL 0 AND IDF_VERSION_PATCH LESS 1))
+   (IDF_VERSION_MAJOR EQUAL 6 AND IDF_VERSION_MINOR LESS 1))
     message(FATAL_ERROR
-        "mikrojs requires ESP-IDF >= 6.0.1, found ${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}.${IDF_VERSION_PATCH}. "
+        "mikrojs requires ESP-IDF >= 6.1, found ${IDF_VERSION_MAJOR}.${IDF_VERSION_MINOR}.${IDF_VERSION_PATCH}. "
         "Install a supported version via EIM: https://docs.espressif.com/projects/esp-idf/en/stable/esp32/get-started/index.html"
     )
 endif()

package/sdkconfig.defaults

@@ -185,7 +185,7 @@ CONFIG_MBEDTLS_ECP_DP_BP512R1_ENABLED=n
 
 # Use smaller cert bundle (common CAs only)
 CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
-# Deliberate deviation from IDF 6.0.2, which defaults this to n to save ~700 B
+# Deliberate deviation from IDF, which defaults this to n to save ~700 B
 # of heap. We need it: with n, esp_crt_bundle looks up only the top served
 # cert's issuer, so any chain that serves a cross-signed root fails outright.
 # That is ~2 in 5 real hosts, mostly Google Trust Services roots cross-signed
@@ -193,10 +193,5 @@ CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_DEFAULT_CMN=y
 # Device-confirmed against registry.npmjs.org (MBEDTLS_ERR_X509_FATAL_ERROR,
 # -0x3000). Neither cross-signing root ships in the CMN or the full bundle, so
 # bundle selection is not an escape either.
-#
-# The cost on 6.0.2 is a leak: ~215 B of issuer-name copies per successful
-# handshake, ~10 KB/day at a 30-minute check-in cadence. Fixed upstream by
-# 0d8ff68f8a47 and a1f1d9072900, landing in an upcoming release. Until our
-# IDF floor gets there, patch IDF rather than turning this off.
 CONFIG_MBEDTLS_CERTIFICATE_BUNDLE_CROSS_SIGNED_VERIFY=y