@mikrojs/firmware 0.15.0 → 0.16.0-next.20260618225923

package/components/mikrojs/mik_wifi.cpp

@@ -477,12 +477,66 @@ static JSValue mik__wifi_connect(JSContext* ctx, JSValue this_val, int argc, JSV
     return mik__result_ok(ctx, promise);
 }
 
+/* Fully tear down the WiFi driver so the heap used by the radio stack, beacon
+ * offsets, event handlers, and netif interfaces is returned to the pool. Shared
+ * by disconnect({shutdown:true}) and runtime teardown. Safe to call when the
+ * radio is already down. */
+static void mik__wifi_radio_teardown(void) {
+    if (!s_wifi_initialized) return;
+    if (s_wifi_started) {
+        esp_wifi_stop();
+        s_wifi_started = false;
+    }
+    /* ensure_initialized registered these via esp_event_handler_instance_register
+     * with a nullptr context out-param, so we can't use instance_unregister.
+     * esp_event_handler_unregister matches on (base, id, handler fn) instead. */
+    esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID, mik__wifi_event_handler);
+    esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP, mik__wifi_event_handler);
+    esp_wifi_deinit();
+    if (s_sta_netif) {
+        esp_netif_destroy_default_wifi(s_sta_netif);
+        s_sta_netif = nullptr;
+    }
+    if (s_ap_netif) {
+        esp_netif_destroy_default_wifi(s_ap_netif);
+        s_ap_netif = nullptr;
+    }
+    s_wifi_initialized = false;
+}
+
 static JSValue mik__wifi_disconnect(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    bool shutdown = argc < 1 || JS_IsUndefined(argv[0]) || JS_ToBool(ctx, argv[0]);
+
     esp_err_t err = esp_wifi_disconnect();
-    if (err != ESP_OK) {
+    /* When shutting down we proceed to teardown even if the radio was never
+     * started, so a plain disconnect() reliably powers things down. */
+    if (err != ESP_OK && !(shutdown && (err == ESP_ERR_WIFI_NOT_STARTED ||
+                                        err == ESP_ERR_WIFI_NOT_INIT))) {
         return mik__result_err_named(ctx, "DisconnectFailed",
                                "Failed to disconnect from WiFi: %s", esp_err_to_name(err));
     }
+
+    if (shutdown) {
+        /* Teardown unregisters the event handlers, so a connect/scan in flight
+         * would never be settled by the event loop. Settle them now (with an
+         * error Result, matching the consume failure path) so the awaiting JS
+         * resolves deterministically instead of hanging until runtime teardown. */
+        MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+        MIKWifiState* state = mik_rt ? mik__wifi_st(mik_rt) : nullptr;
+        if (state && state->connect_pending) {
+            JSValue result = mik__result_err_named(ctx, "ConnectFailed",
+                                                   "WiFi disconnected before connecting");
+            MIK_ResolvePromise(ctx, &state->connect_promise, 1, &result);
+            state->connect_pending = false;
+        }
+        if (state && state->scan_pending) {
+            JSValue result = mik__result_err_named(ctx, "ScanFailed",
+                                                   "WiFi shut down during scan");
+            MIK_ResolvePromise(ctx, &state->scan_promise, 1, &result);
+            state->scan_pending = false;
+        }
+        mik__wifi_radio_teardown();
+    }
     return mik__result_ok_void(ctx);
 }
 
@@ -1100,7 +1154,7 @@ static JSValue mik__wifi_ap_set_inactive_timeout(JSContext* ctx, JSValue this_va
 
 static const JSCFunctionListEntry mik__wifi_proto_funcs[] = {
     MIK_CFUNC_DEF("connect", 2, mik__wifi_connect),
-    MIK_CFUNC_DEF("disconnect", 0, mik__wifi_disconnect),
+    MIK_CFUNC_DEF("disconnect", 1, mik__wifi_disconnect),
     MIK_CFUNC_DEF("rssi", 0, mik__wifi_rssi),
     MIK_CFUNC_DEF("ip", 0, mik__wifi_ip),
     MIK_CFUNC_DEF("status", 0, mik__wifi_status),
@@ -1410,35 +1464,11 @@ void mik__wifi_destroy(JSContext* ctx) {
     delete state;
     mik__wifi_st(mik_rt) = nullptr;
 
-    /* Fully tear down the WiFi driver so the heap used by the radio stack,
-     * beacon offsets, event handlers, and netif interfaces is returned to
-     * the pool. Without this, repeated runtime lifecycles (e.g. on-device
-     * test suites that create + destroy a runtime per test) eventually hit
-     * `alloc pm_beacon_offset fail` when the heap is too fragmented for
-     * even small internal allocations. */
-    if (s_wifi_initialized) {
-        if (s_wifi_started) {
-            esp_wifi_stop();
-            s_wifi_started = false;
-        }
-        /* ensure_initialized registered these via esp_event_handler_instance_register
-         * with a nullptr context out-param, so we can't use instance_unregister.
-         * esp_event_handler_unregister matches on (base, id, handler fn) instead. */
-        esp_event_handler_unregister(WIFI_EVENT, ESP_EVENT_ANY_ID,
-                                     mik__wifi_event_handler);
-        esp_event_handler_unregister(IP_EVENT, IP_EVENT_STA_GOT_IP,
-                                     mik__wifi_event_handler);
-        esp_wifi_deinit();
-        if (s_sta_netif) {
-            esp_netif_destroy_default_wifi(s_sta_netif);
-            s_sta_netif = nullptr;
-        }
-        if (s_ap_netif) {
-            esp_netif_destroy_default_wifi(s_ap_netif);
-            s_ap_netif = nullptr;
-        }
-        s_wifi_initialized = false;
-    }
+    /* Return the radio heap to the pool. Without this, repeated runtime
+     * lifecycles (e.g. on-device test suites that create + destroy a runtime
+     * per test) eventually hit `alloc pm_beacon_offset fail` when the heap is
+     * too fragmented for even small internal allocations. */
+    mik__wifi_radio_teardown();
 }
 
 MIK_REGISTER_MODULE(wifi, "native:mikro/wifi", mik__wifi_init, mik__wifi_consume, mik__wifi_destroy)

package/components/mikrojs/test/wifi_test.cpp

@@ -151,13 +151,13 @@ TEST_CASE("Wifi connect returns a promise", "[wifi]") {
     setup();
 
     // Only test that connect() returns a Promise — don't actually wait for connection.
-    // We call disconnect() right after to avoid leaving WiFi in "connecting" state.
+    // disconnect(false) keeps the radio up to avoid tearing it down between tests.
     JSValue ret = eval_module(R"(
         import { Wifi } from "native:mikro/wifi";
         const wifi = new Wifi();
         const result = wifi.connect("test", "pass");
         globalThis.__isPromise = result.ok && result.value instanceof Promise;
-        wifi.disconnect();
+        wifi.disconnect(false);
     )");
     TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
 
@@ -169,6 +169,68 @@ TEST_CASE("Wifi connect returns a promise", "[wifi]") {
     teardown();
 }
 
+/* ── Disconnect shutdown powers the radio down and stays reusable ──── */
+
+TEST_CASE("Wifi disconnect({shutdown:true}) tears down and re-inits on reuse", "[wifi]") {
+    setup();
+
+    // disconnect(true) is the default: it powers the radio down. A subsequent
+    // call (here getTxPower, which lazily restarts the radio) must still work.
+    JSValue ret = eval_module(R"(
+        import { Wifi } from "native:mikro/wifi";
+        const wifi = new Wifi();
+        wifi.connect("test", "pass");
+        const down = wifi.disconnect(true);
+        const reuse = wifi.getTxPower();
+        globalThis.__downOk = down.ok;
+        globalThis.__reuseOk = reuse.ok;
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue downOk = JS_GetPropertyStr(ctx, global, "__downOk");
+    JSValue reuseOk = JS_GetPropertyStr(ctx, global, "__reuseOk");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, downOk), "disconnect(true) should return ok");
+    TEST_ASSERT_TRUE_MESSAGE(JS_ToBool(ctx, reuseOk), "radio should re-init after shutdown");
+    JS_FreeValue(ctx, downOk);
+    JS_FreeValue(ctx, reuseOk);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
+/* ── Disconnect shutdown settles a connect in flight ──────────────── */
+
+TEST_CASE("Wifi disconnect({shutdown:true}) settles a pending connect", "[wifi]") {
+    setup();
+
+    // Teardown unregisters the event handlers, so the connect promise must be
+    // settled by disconnect() itself — otherwise the await would hang forever.
+    JSValue ret = eval_module(R"(
+        import { Wifi } from "native:mikro/wifi";
+        const wifi = new Wifi();
+        const result = wifi.connect("test", "pass");
+        globalThis.__settled = "pending";
+        if (result.ok) {
+            result.value.then((res) => {
+                globalThis.__settled = res.ok ? "ok" : res.error.name;
+            });
+        }
+        wifi.disconnect(true);
+    )");
+    TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
+
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue settled = JS_GetPropertyStr(ctx, global, "__settled");
+    const char* settled_str = JS_ToCString(ctx, settled);
+    TEST_ASSERT_NOT_NULL(settled_str);
+    TEST_ASSERT_EQUAL_STRING_MESSAGE("ConnectFailed", settled_str,
+                                     "pending connect should settle as ConnectFailed, not hang");
+    JS_FreeCString(ctx, settled_str);
+    JS_FreeValue(ctx, settled);
+    JS_FreeValue(ctx, global);
+    teardown();
+}
+
 /* ── Scan returns a promise ────────────────────────────────────────── */
 
 TEST_CASE("Wifi scan returns a promise", "[wifi]") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.15.0",
+  "version": "0.16.0-next.20260618225923",
   "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.15.0",
-    "@mikrojs/quickjs": "0.15.0"
+    "@mikrojs/native": "0.16.0-next.20260618225923+79c8761",
+    "@mikrojs/quickjs": "0.16.0-next.20260618225923+79c8761"
   },
   "engines": {
     "node": ">=24.0.0"