@mikrojs/firmware 0.21.1-next.20260927212749 → 0.22.0

package/components/mikrojs/mik_main.cpp

@@ -13,12 +13,16 @@
 #include "esp_littlefs.h"
 #include "esp_log.h"
 #include "esp_partition.h"
+#include "esp_pm.h"
 #include "esp_system.h"
 #if CONFIG_ESP_TASK_WDT_EN
 #include "esp_task_wdt.h"
 #endif
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
+#if CONFIG_IDF_TARGET_ESP32 && CONFIG_BT_ENABLED
+#include "mik_ble_c_shim.h"
+#endif
 #include "mikrojs.h"
 #include "mikrojs/platform.h"
 #include "mikrojs/private.h"
@@ -37,7 +41,7 @@ static_assert(MIK_WATCHDOG_BLOCKING_DEFAULT_MS / 1000 + MIK_TWDT_MARGIN_S <
                   CONFIG_ESP_TASK_WDT_TIMEOUT_S,
               "watchdog.blocking default (30 s) must fire before the task watchdog: set "
               "CONFIG_ESP_TASK_WDT_TIMEOUT_S=60 in sdkconfig, or delete sdkconfig and re-run "
-              "`idf.py set-target` so sdkconfig.defaults applies");
+              "`mikro idf set-target` so sdkconfig.defaults applies");
 #endif
 
 /* Error handler armed during a normal boot: when the app hits a fatal JS error
@@ -116,26 +120,13 @@ static void mik__apply_nvs_log_level(void) {
     esp_log_level_set("mik_app_config", level);
 }
 
-/* Scratch buffers for the supervisor loop, heap-allocated for the duration
- * of a test-manifest run so normal boots don't carry them in BSS (~3 KB).
- *
- * Kept off the stack because the main task stack is ~24 KB and cannot
- * accommodate 1-2 KB of local buffers on top of the nested eval/module
- * normalizer call chain (observed as a stack-protection fault in
- * mik_module_normalizer on the first test file). Fixed sizes instead of
- * PATH_MAX scaling — on newlib PATH_MAX can be 4096, which is absurd for
- * our purposes. These sizes fit any realistic on-device test path. Only
- * one test manifest runs per boot, so single-ownership is safe. */
+/* Fixed sizes instead of PATH_MAX scaling — on newlib PATH_MAX can be 4096,
+ * which is absurd for our purposes. These fit any realistic on-device test
+ * path. */
 #define MIK_SUP_PATH_MAX 384
-struct MIKSupScratch {
-    char dbg[MIK_SUP_PATH_MAX + 64];
-    char esc[MIK_SUP_PATH_MAX * 2 + 8];
-    char buf[MIK_SUP_PATH_MAX * 2 + 512];
-    /* Exception text captured by MIK_RunEntryErr when a test file fails to
-     * evaluate, and its JSON-escaped form for the synthesized test event. */
-    char err[192];
-    char err_esc[sizeof(err) * 2 + 8];
-};
+/* Exception text captured by MIK_RunEntryErr when a test file fails to
+ * evaluate. */
+#define MIK_SUP_ERR_MAX 192
 
 /* Minimal JSON string-escape into a bounded buffer. Handles `"`, `\`, and
  * control characters; everything else copies verbatim. Returns bytes
@@ -166,6 +157,68 @@ static int mik__json_escape(char* dst, size_t dst_size, const char* src) {
     return (int)w;
 }
 
+/* Supervisor frame buffers live on these noinline helpers' stacks, called
+ * only while no JS runs. Not in MIK_Main's frame: it stays live under the
+ * eval chain, and 1-2 KB of locals there faulted in mik_module_normalizer.
+ * Not on the heap: that held ~3 KB through every test file's network calls. */
+
+/* Announce the file about to run so the CLI can confirm the supervisor's
+ * iteration matches its own testFiles order. The MSG_DEBUG frame is
+ * rendered as a dim log line. */
+[[gnu::noinline]] static void mik__sup_announce(MIKReplTransport* transport, size_t i, size_t count,
+                                                const char* path) {
+    char dbg[MIK_SUP_PATH_MAX + 64];
+    int n = snprintf(dbg, sizeof(dbg), "[supervisor] running %zu/%zu: %s", i + 1, count, path);
+    if (n > 0 && n < (int)sizeof(dbg)) {
+        mik__proto_send(transport, MIK_MSG_DEBUG, dbg, n);
+    }
+}
+
+/* Synthesize a failing test + run_done so the CLI accounts for this file
+ * instead of stalling waiting for a run_done the runtime will never emit.
+ * `err` is the captured exception text, or null. */
+[[gnu::noinline]] static void mik__sup_report_failure(MIKReplTransport* transport,
+                                                      const char* path, const char* reason,
+                                                      const char* err) {
+    char esc[MIK_SUP_PATH_MAX * 2 + 8];
+    char err_esc[MIK_SUP_ERR_MAX * 2 + 8];
+    char buf[MIK_SUP_PATH_MAX * 2 + 512];
+
+    ESP_LOGE(TAG, "%s: %s", reason, path);
+    /* Escape the path so any `"` or `\` in it doesn't corrupt the JSON frame. */
+    if (mik__json_escape(esc, sizeof(esc), path) < 0) {
+        /* Path too long to fit even escaped — fall back to basename so the
+         * frame at least identifies something. */
+        const char* base = strrchr(path, '/');
+        if (!base || mik__json_escape(esc, sizeof(esc), base + 1) < 0) {
+            esc[0] = '?';
+            esc[1] = '\0';
+        }
+    }
+    /* Append the captured exception text (escaped) so the CLI shows the
+     * actual error, not just "Evaluation threw". */
+    err_esc[0] = '\0';
+    if (err && err[0] != '\0') {
+        if (mik__json_escape(err_esc, sizeof(err_esc), err) < 0) {
+            err_esc[0] = '\0';
+        }
+    }
+    int n;
+    if (err_esc[0] != '\0') {
+        n = snprintf(buf, sizeof(buf),
+                     "{\"e\":3,\"s\":\"<load>\",\"t\":\"%s\",\"d\":0,\"m\":\"%s: %s\"}", esc,
+                     reason, err_esc);
+    } else {
+        n = snprintf(buf, sizeof(buf),
+                     "{\"e\":3,\"s\":\"<load>\",\"t\":\"%s\",\"d\":0,\"m\":\"%s\"}", esc, reason);
+    }
+    if (n > 0 && n < (int)sizeof(buf)) {
+        mik__proto_send(transport, MIK_MSG_TEST, buf, n);
+    }
+    static const char kRunDone[] = "{\"e\":6,\"p\":0,\"f\":1,\"k\":0,\"o\":0,\"d\":0}";
+    mik__proto_send(transport, MIK_MSG_TEST, kRunDone, sizeof(kRunDone) - 1);
+}
+
 /* ── Serial transport ───────────────────────────────────────────── */
 
 static int serial_transport_read(uint8_t* buf, size_t size, void* ctx) {
@@ -222,9 +275,10 @@ static bool platform_command_handler(MIKReplTransport* transport, uint8_t cmd_ty
         return true;
     }
 
-    /* Deploy commands (0x20-0x27) plus the build-stage command (0x2D) */
+    /* Deploy commands (0x20-0x27, 0x2F, 0x30) plus the build-stage command (0x2D) */
     if ((cmd_type >= MIK_CMD_DEPLOY_PUT && cmd_type <= MIK_CMD_DEPLOY_CHECKSUM) ||
-        cmd_type == MIK_CMD_DEPLOY_BUILD) {
+        cmd_type == MIK_CMD_DEPLOY_BUILD || cmd_type == MIK_CMD_DEPLOY_CHECKSUM_LIST ||
+        cmd_type == MIK_CMD_DEPLOY_KEEP_MANY) {
         return mik__handle_deploy_command(transport, cmd_type, payload_len);
     }
 
@@ -354,6 +408,21 @@ void MIK_Main(void) {
      * for USB SOF packets; if absent it falls back to UART. */
     mik__console_init();
 
+#if CONFIG_MIKROJS_AUTO_LIGHT_SLEEP
+    /* Keeps the DFS range from PM_DFS_INIT_AUTO and adds light sleep. */
+    {
+        esp_pm_config_t pm_config;
+        esp_err_t err = esp_pm_get_configuration(&pm_config);
+        if (err == ESP_OK) {
+            pm_config.light_sleep_enable = true;
+            err = esp_pm_configure(&pm_config);
+        }
+        if (err != ESP_OK) {
+            ESP_LOGW(TAG, "Automatic light sleep not enabled: %s", esp_err_to_name(err));
+        }
+    }
+#endif
+
     /* Gather chip/feature info early — cheap, no side effects, used to
      * print the banner AFTER runtime init succeeds. We deliberately defer
      * the banner until everything is up so its mere presence signals
@@ -387,6 +456,20 @@ void MIK_Main(void) {
     bool has_ble = false;
 #endif
 
+#if CONFIG_IDF_TARGET_ESP32 && CONFIG_BT_ENABLED
+    /* The BT controller reserves its DRAM at boot whether or not BLE is ever
+     * started. Classic BT is never used (NimBLE is BLE-only), so hand its
+     * 15 KB with the default config (0x3ffb2730-0x3ffb6388) to the heap now.
+     * nimble_port_init makes the same call later and treats the repeat as
+     * already released. */
+    {
+        int err = mik_ble_release_classic_bt_mem();
+        if (err != 0) {
+            ESP_LOGI(TAG, "Classic BT memory not released: %s", esp_err_to_name(err));
+        }
+    }
+#endif
+
     /* Capture starting heap for the later runtime-cost INFO log. */
     size_t heap_free_at_boot = esp_get_free_heap_size();
     size_t heap_total_at_boot = heap_free_at_boot;
@@ -396,18 +479,22 @@ void MIK_Main(void) {
         heap_total_at_boot = info.total_free_bytes + info.total_allocated_bytes;
     }
 
-    /* Recovery window: gives the host (or a double-reset) a chance to
-     * skip the autorun if the deployed app is crash-looping.  Costs ~500ms
-     * on every cold boot but is the only window we have before user code
-     * runs and may panic. */
-    bool safe_mode = mik__check_recovery(500);
+    /* Recovery window: lets the host (or a double reset) skip the autorun when
+     * the app crash-loops. Costs CONFIG_MIKROJS_RECOVERY_WINDOW_MS on every boot,
+     * deep-sleep wakes included; at 0 the call is skipped and a second reset has
+     * no window to land in. */
+    bool safe_mode = false;
+#if CONFIG_MIKROJS_RECOVERY_WINDOW_MS > 0
+    safe_mode = mik__check_recovery(CONFIG_MIKROJS_RECOVERY_WINDOW_MS);
+#endif
     if (safe_mode) {
         printf("\n*** SAFE MODE: autorun skipped, dropping to REPL ***\n\n");
     }
 
 #if CONFIG_ESP_TASK_WDT_EN
     /* Watch the main task: a hang in native code below JS now resets the
-     * chip instead of sitting forever. Fed from MIK_Loop and platform->yield. */
+     * chip instead of sitting forever. Fed from MIK_Loop, platform->yield and
+     * platform->wait. */
     {
         esp_err_t err = esp_task_wdt_add(NULL);
         if (err != ESP_OK) {
@@ -528,7 +615,12 @@ void MIK_Main(void) {
         options.stack_size = app_config.stack_size;
     }
 #ifdef CONFIG_MIKROJS_QUICKJS_HEAP_PSRAM
-    options.use_psram_heap = true;
+    /* Route the JS heap to PSRAM only when the heap allocator has some: with
+     * SPIRAM_IGNORE_NOTFOUND a board without the chip boots too, and every failed
+     * heap_caps_malloc(MALLOC_CAP_SPIRAM) would walk the heap registry first. */
+    if (heap_caps_get_total_size(MALLOC_CAP_SPIRAM) > 0) {
+        options.use_psram_heap = true;
+    }
 #endif
 
     auto create_runtime = [&]() -> MIKRuntime* {
@@ -678,47 +770,27 @@ void MIK_Main(void) {
     MIK_ProtocolOpen(&transport);
 
     if (test_mode) {
-        auto* sup = static_cast<MIKSupScratch*>(malloc(sizeof(MIKSupScratch)));
-        if (!sup) {
-            ESP_LOGE(TAG, "Not enough memory for the test supervisor");
-            /* Fail loud: a synthesized failing run-done plus end-of-manifest
-             * lets the CLI report the failure instead of hanging on a stream
-             * that will never produce results. */
-            static const char kOomRunDone[] = "{\"e\":6,\"p\":0,\"f\":1,\"k\":0,\"o\":0,\"d\":0}";
-            mik__proto_send(&transport, MIK_MSG_TEST, kOomRunDone, sizeof(kOomRunDone) - 1);
-            mik__proto_send(&transport, MIK_MSG_MANIFEST_DONE, nullptr, 0);
-            return;
-        }
-
         /* Discard the primary runtime — each test gets a fresh one. */
         MIK_FreeRuntime(mik_rt);
         mik_rt = nullptr;
 
         for (size_t i = 0; i < test_count; i++) {
-            /* Diagnostic: announce the file about to run so the CLI can
-             * confirm the supervisor's iteration matches its own testFiles
-             * order. The MSG_DEBUG frame is rendered as a dim log line.
-             * Uses heap scratch to avoid bloating the main task stack —
-             * the normalizer call chain during module resolution already
-             * sits a few KB deep. */
-            {
-                int n = snprintf(sup->dbg, sizeof(sup->dbg),
-                                 "[supervisor] running %zu/%zu: %s", i + 1, test_count,
-                                 test_paths[i]);
-                if (n > 0 && n < (int)sizeof(sup->dbg)) {
-                    mik__proto_send(&transport, MIK_MSG_DEBUG, sup->dbg, n);
-                }
-            }
+            mik__sup_announce(&transport, i, test_count, test_paths[i]);
             MIKRuntime* rt = create_runtime();
             MIK_EnableTestHelpers(rt);
             MIK_ProtocolAttach(rt);
-            int rc = MIK_RunEntryErr(rt, test_paths[i], sup->err, sizeof(sup->err));
+            /* Held only across the entry eval; a null buffer just drops the
+             * exception text. */
+            auto* err = static_cast<char*>(malloc(MIK_SUP_ERR_MAX));
+            int rc = MIK_RunEntryErr(rt, test_paths[i], err, err ? MIK_SUP_ERR_MAX : 0);
             const char* fail_reason = nullptr;
             if (rc == -ENOENT) {
                 fail_reason = "Test file not found";
             } else if (rc == -EFAULT) {
                 fail_reason = "Evaluation threw";
             } else {
+                free(err);
+                err = nullptr;
                 /* Entry eval returned successfully (rc == 0). The test module
                  * may still asynchronously reject (e.g. top-level throw in a
                  * module eval'd as a Promise) — that's caught after ServeLoop
@@ -729,52 +801,12 @@ void MIK_Main(void) {
                 }
             }
             if (fail_reason) {
-                /* Synthesize a failing test + run_done so the CLI accounts
-                 * for this file instead of stalling waiting for a run_done
-                 * the runtime will never emit. Escape the path so any `"`
-                 * or `\` in it doesn't corrupt the JSON frame. */
-                ESP_LOGE(TAG, "%s: %s", fail_reason, test_paths[i]);
-                if (mik__json_escape(sup->esc, sizeof(sup->esc), test_paths[i]) < 0) {
-                    /* Path too long to fit even escaped — fall back to
-                     * basename so the frame at least identifies something. */
-                    const char* base = strrchr(test_paths[i], '/');
-                    if (!base ||
-                        mik__json_escape(sup->esc, sizeof(sup->esc), base + 1) < 0) {
-                        sup->esc[0] = '?';
-                        sup->esc[1] = '\0';
-                    }
-                }
-                /* Append the captured exception text (escaped) so the CLI
-                 * shows the actual error, not just "Evaluation threw". */
-                sup->err_esc[0] = '\0';
-                if (rc == -EFAULT && sup->err[0] != '\0') {
-                    if (mik__json_escape(sup->err_esc, sizeof(sup->err_esc), sup->err) < 0) {
-                        sup->err_esc[0] = '\0';
-                    }
-                }
-                int n;
-                if (sup->err_esc[0] != '\0') {
-                    n = snprintf(sup->buf, sizeof(sup->buf),
-                                 "{\"e\":3,\"s\":\"<load>\",\"t\":\"%s\",\"d\":0,"
-                                 "\"m\":\"%s: %s\"}",
-                                 sup->esc, fail_reason, sup->err_esc);
-                } else {
-                    n = snprintf(sup->buf, sizeof(sup->buf),
-                                 "{\"e\":3,\"s\":\"<load>\",\"t\":\"%s\",\"d\":0,"
-                                 "\"m\":\"%s\"}",
-                                 sup->esc, fail_reason);
-                }
-                if (n > 0 && n < (int)sizeof(sup->buf)) {
-                    mik__proto_send(&transport, MIK_MSG_TEST, sup->buf, n);
-                }
-                static const char kRunDone[] =
-                    "{\"e\":6,\"p\":0,\"f\":1,\"k\":0,\"o\":0,\"d\":0}";
-                mik__proto_send(&transport, MIK_MSG_TEST, kRunDone, sizeof(kRunDone) - 1);
+                mik__sup_report_failure(&transport, test_paths[i], fail_reason, err);
             }
+            free(err);
             MIK_ProtocolDetach();
             MIK_FreeRuntime(rt);
         }
-        free(sup);
 
         /* Signal end-of-manifest so the CLI can finalize its report
          * without waiting on a silent stream. */

package/components/mikrojs/mik_pwm.cpp

@@ -4,6 +4,7 @@
 #include "driver/ledc.h"
 #include "soc/soc_caps.h"
 #include "esp_log.h"
+#include "esp_pm.h"
 #include "mikrojs/mikrojs.h"
 #include "mikrojs/private.h"
 #include "mikrojs/utils.h"
@@ -23,6 +24,17 @@ static uint32_t s_timer_freq[MIK_PWM_MAX_TIMERS] = {};
 static uint8_t s_timer_refcount[MIK_PWM_MAX_TIMERS] = {};
 static bool s_fade_installed = false;
 
+#if CONFIG_PM_ENABLE
+/* Held per live handle: LEDC_AUTO_CLK picks APB where the chip has it, which DFS
+ * slows; XTAL and PLL_F80M (C6/C5) keep their rate but stop in light sleep. */
+#if SOC_LEDC_SUPPORT_APB_CLOCK
+#define MIK_PWM_PM_LOCK ESP_PM_APB_FREQ_MAX
+#else
+#define MIK_PWM_PM_LOCK ESP_PM_NO_LIGHT_SLEEP
+#endif
+static esp_pm_lock_handle_t s_pwm_pm_lock = nullptr;
+#endif
+
 static int mik__pwm_alloc_channel() {
     for (int i = 0; i < MIK_PWM_MAX_CHANNELS; i++) {
         if (!(s_channel_used & (1 << i))) {
@@ -120,8 +132,9 @@ static IRAM_ATTR bool mik__pwm_fade_cb(const ledc_cb_param_t* param, void* user_
     auto* pending = static_cast<MIKPwmFadePending*>(user_arg);
     if (param->event == LEDC_FADE_END_EVT) {
         pending->complete.store(true, std::memory_order_release);
+        MIK_WakeFromISR();
     }
-    return false;  // no high-priority task woken
+    return false;  // the wake yields itself when it unblocks the main task
 }
 
 /* The channel's fade that is still running, or nullptr. */
@@ -166,6 +179,9 @@ static void mik__pwm_release(MIKPwmState* s) {
     mik__pwm_free_channel(s->channel);
     mik__pwm_free_timer(s->timer);
     MIK_ReleaseGpio(s->gpio, "Pwm");
+#if CONFIG_PM_ENABLE
+    esp_pm_lock_release(s_pwm_pm_lock);
+#endif
     s->active = false;
 }
 
@@ -231,6 +247,14 @@ static JSValue js_pwm(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
     const MIKGpioCheck check = {gpio, true};
     invalid = mik__gpio_check(ctx, &check, 1);
     if (!JS_IsUndefined(invalid)) return invalid;
+#if CONFIG_PM_ENABLE
+    if (!s_pwm_pm_lock) {
+        esp_err_t lock_err = esp_pm_lock_create(MIK_PWM_PM_LOCK, 0, "pwm", &s_pwm_pm_lock);
+        if (lock_err != ESP_OK)
+            return mik__result_err_named(ctx, "ConfigFailed", "esp_pm_lock_create failed: %s",
+                                         esp_err_to_name(lock_err));
+    }
+#endif
     const int gpios[] = {gpio};
     JSValue claim_failed = MIK_ClaimGpios(ctx, gpios, 1, "Pwm");
     if (!JS_IsUndefined(claim_failed)) return claim_failed;
@@ -304,6 +328,9 @@ static JSValue js_pwm(JSContext* ctx, JSValue this_val, int argc, JSValue* argv)
     s->resolution = resolution;
     s->duty = duty;
     s->active = true;
+#if CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(s_pwm_pm_lock);
+#endif
 
     JSValue obj = JS_NewObjectClass(ctx, mik_pwm_class_id);
     if (JS_IsException(obj)) {

package/components/mikrojs/mik_serial_io.cpp

@@ -3,6 +3,8 @@
 #include <string.h>
 
 #include "driver/uart.h"
+#include "driver/uart_select.h"
+#include "esp_attr.h"
 #include "esp_intr_alloc.h"
 #include "esp_log.h"
 #include "freertos/FreeRTOS.h"
@@ -17,6 +19,7 @@
 
 #if SOC_USB_SERIAL_JTAG_SUPPORTED
 #include "driver/usb_serial_jtag.h"
+#include "driver/usb_serial_jtag_select.h"
 #include "esp_rom_sys.h"
 #include "hal/usb_serial_jtag_ll.h"
 #include "soc/io_mux_reg.h"
@@ -66,6 +69,24 @@
 #define MIK_CONSOLE_HAS_UART 0
 #endif
 
+/* RX data wakes the sleeping serve loop through each driver's select-notify
+ * hook, its only ISR-level RX signal; the VFS layer that would own it is unused. */
+#if SOC_USB_SERIAL_JTAG_SUPPORTED
+static void mik__usj_rx_notify(usj_select_notif_t notif, int* task_woken) {
+    (void)task_woken;  // the wake yields itself
+    if (notif == USJ_SELECT_READ_NOTIF) MIK_WakeFromISR();
+}
+#endif
+#if MIK_CONSOLE_HAS_UART
+/* UART0's ISR is in IRAM and runs with the flash cache off. */
+static void IRAM_ATTR mik__uart0_rx_notify(uart_port_t port, uart_select_notif_t notif,
+                                           BaseType_t* task_woken) {
+    (void)port;
+    (void)task_woken;
+    if (notif == UART_SELECT_READ_NOTIF) MIK_WakeFromISR();
+}
+#endif
+
 static enum { CONSOLE_UART, CONSOLE_USB_SERIAL_JTAG } s_console =
 #if SOC_USB_SERIAL_JTAG_SUPPORTED
     CONSOLE_USB_SERIAL_JTAG;
@@ -105,7 +126,11 @@ static bool mik__usj_install_with_default_config(void) {
     usb_serial_jtag_driver_config_t usj_cfg = USB_SERIAL_JTAG_DRIVER_CONFIG_DEFAULT();
     usj_cfg.rx_buffer_size = 4096;
     usj_cfg.tx_buffer_size = 2048;
-    return usb_serial_jtag_driver_install(&usj_cfg) == ESP_OK;
+    if (usb_serial_jtag_driver_install(&usj_cfg) != ESP_OK) return false;
+    /* Per install: the driver object that holds the hook is freed on uninstall
+     * (light sleep detaches and re-attaches). */
+    usb_serial_jtag_set_select_notif_callback(mik__usj_rx_notify);
+    return true;
 }
 #endif
 
@@ -131,12 +156,21 @@ void mik__console_init(void) {
     uart_config.parity = UART_PARITY_DISABLE;
     uart_config.stop_bits = UART_STOP_BITS_1;
     uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
+    /* DFS slows the APB clock; keep the DFS-safe clock that esp_pm_impl_init
+     * gave the console, or RX garbles whenever the chip idles. */
+#if CONFIG_PM_ENABLE && SOC_UART_SUPPORT_REF_TICK
+    uart_config.source_clk = UART_SCLK_REF_TICK;
+#elif CONFIG_PM_ENABLE
+    uart_config.source_clk = UART_SCLK_XTAL;
+#else
     uart_config.source_clk = UART_SCLK_DEFAULT;
+#endif
     uart_param_config(UART_NUM_0, &uart_config);
     uart_set_pin(UART_NUM_0, U0TXD_GPIO_NUM, U0RXD_GPIO_NUM,
                  UART_PIN_NO_CHANGE, UART_PIN_NO_CHANGE);
     /* IRAM ISR keeps UART alive during flash writes (LittleFS deploys). */
     if (uart_driver_install(UART_NUM_0, 4096, 0, 0, NULL, ESP_INTR_FLAG_IRAM) == ESP_OK) {
+        uart_set_select_notif_callback(UART_NUM_0, mik__uart0_rx_notify);
         MIK_ClaimGpio(U0TXD_GPIO_NUM, "console");
         MIK_ClaimGpio(U0RXD_GPIO_NUM, "console");
     }
@@ -329,28 +363,6 @@ void mik__serial_io_attach_usb(void) {
 const char* MIK__NVS_NS_ENV = "mik.env";
 const char* MIK__NVS_NS_SEC = "mik.sec";
 
-void mik__nvs_clear_namespace(const char* ns) {
-    nvs_handle_t handle;
-    if (nvs_open(ns, NVS_READWRITE, &handle) == ESP_OK) {
-        nvs_erase_all(handle);
-        nvs_commit(handle);
-        nvs_close(handle);
-    }
-}
-
-bool mik__nvs_put_string(const char* ns, const char* key, const char* value) {
-    nvs_handle_t handle;
-    esp_err_t err = nvs_open(ns, NVS_READWRITE, &handle);
-    if (err != ESP_OK) return false;
-
-    err = nvs_set_str(handle, key, value);
-    if (err == ESP_OK) {
-        err = nvs_commit(handle);
-    }
-    nvs_close(handle);
-    return err == ESP_OK;
-}
-
 /* Write only if the value differs from what's already stored. `out_changed`
  * is set to true when the stored value ends up different than before, false
  * if the existing value already matched. Returns false on I/O failure. */

package/components/mikrojs/mik_sntp.cpp

@@ -39,6 +39,7 @@ static void mik__sntp_sync_cb(struct timeval* tv) {
     if (!s_event_queue) return;
     struct timeval evt = *tv;
     xQueueSend(s_event_queue, &evt, 0);
+    MIK_Wake();
 }
 
 /* ── Test helper: inject a fake sync event ─────────────────────────── */
@@ -47,6 +48,7 @@ void mik__sntp_inject_sync(int64_t epoch_sec) {
     if (!s_event_queue) return;
     struct timeval tv = {.tv_sec = static_cast<time_t>(epoch_sec), .tv_usec = 0};
     xQueueSend(s_event_queue, &tv, 0);
+    MIK_Wake();
 }
 
 /* ── JS functions ──────────────────────────────────────────────────── */

package/components/mikrojs/mik_uart.cpp

@@ -2,10 +2,14 @@
 #include <cstring>
 
 #include "driver/uart.h"
+#include "driver/uart_select.h"
+#include "esp_attr.h"
+#include "esp_pm.h"
 #include "mikrojs/mikrojs.h"
 #include "mikrojs/private.h"
 #include "mikrojs/utils.h"
 #include "mikrojs_esp32.h"
+#include "soc/soc_caps.h"
 
 #define MIK_UART_RX_BUF_SIZE 2048
 #define MIK_UART_MAX_INSTANCES 3
@@ -13,6 +17,25 @@
 static JSClassID mik_uart_class_id;
 static int mik__uart_slot = -1;
 
+#if CONFIG_PM_ENABLE
+/* Held per live handle (the driver guards only TX): the default source is APB where the
+ * chip has it, which DFS slows; PLL_F80M (C6/C5) keeps its rate but stops in light sleep. */
+#if SOC_UART_SUPPORT_APB_CLK
+#define MIK_UART_PM_LOCK ESP_PM_APB_FREQ_MAX
+#else
+#define MIK_UART_PM_LOCK ESP_PM_NO_LIGHT_SLEEP
+#endif
+static esp_pm_lock_handle_t s_uart_pm_lock = nullptr;
+#endif
+
+/* UART ISR (IRAM, so it runs with the flash cache off): RX data landed. */
+static void IRAM_ATTR mik__uart_rx_notify(uart_port_t port, uart_select_notif_t notif,
+                                          BaseType_t* task_woken) {
+    (void)port;
+    (void)task_woken;  // the wake yields itself
+    if (notif == UART_SELECT_READ_NOTIF) MIK_WakeFromISR();
+}
+
 /* Forward decl: defined alongside the iterator class further down. The Uart
  * state holds a non-owning backpointer so end() can mark the active iterator
  * as exhausted without having to reach through JS. */
@@ -75,6 +98,9 @@ static void mik__uart_release(MIKRuntime* mik_rt, MIKUartState* s) {
     uart_driver_delete(s->port);
     const int gpios[] = {s->tx_pin, s->rx_pin};
     MIK_ReleaseGpios(gpios, countof(gpios), "Uart");
+#if CONFIG_PM_ENABLE
+    esp_pm_lock_release(s_uart_pm_lock);
+#endif
     s->active = false;
 }
 
@@ -129,6 +155,15 @@ static JSValue js_uart(JSContext* ctx, JSValue this_val, int argc, JSValue* argv
     const MIKGpioCheck checks[] = {{tx, true}, {rx, false}};
     JSValue invalid = mik__gpio_check(ctx, checks, countof(checks));
     if (!JS_IsUndefined(invalid)) return invalid;
+#if CONFIG_PM_ENABLE
+    if (!s_uart_pm_lock) {
+        esp_err_t lock_err = esp_pm_lock_create(MIK_UART_PM_LOCK, 0, "uart", &s_uart_pm_lock);
+        if (lock_err != ESP_OK)
+            return mik__result_err_named(ctx, "DriverInstallFailed",
+                                         "esp_pm_lock_create failed: %s",
+                                         esp_err_to_name(lock_err));
+    }
+#endif
     const int gpios[] = {tx, rx};
     JSValue claim_failed = MIK_ClaimGpios(ctx, gpios, countof(gpios), "Uart");
     if (!JS_IsUndefined(claim_failed)) return claim_failed;
@@ -178,6 +213,9 @@ static JSValue js_uart(JSContext* ctx, JSValue this_val, int argc, JSValue* argv
                                      "uart_driver_install failed on port %d: %s", (int)port,
                                      esp_err_to_name(err));
     }
+    /* The loop consumer polls the RX buffer; this ends its wait when bytes land.
+     * uart_driver_delete clears the callback. */
+    uart_set_select_notif_callback(uart_port, mik__uart_rx_notify);
 
     auto* s = static_cast<MIKUartState*>(calloc(1, sizeof(MIKUartState)));
     if (!s) {
@@ -199,6 +237,9 @@ static JSValue js_uart(JSContext* ctx, JSValue this_val, int argc, JSValue* argv
         return obj;
     }
     JS_SetOpaque(obj, s);
+#if CONFIG_PM_ENABLE
+    esp_pm_lock_acquire(s_uart_pm_lock);
+#endif
     mik__uart_track(MIK_GetRuntime(ctx), s);
     MIK_KeepHandle(ctx, obj);
     return mik__result_ok(ctx, obj);

package/components/mikrojs/mik_wifi.cpp

@@ -250,6 +250,7 @@ static void mik__wifi_event_handler(void* arg, esp_event_base_t event_base, int3
 
     if (s_event_queue) {
         xQueueSend(s_event_queue, &evt, 0);
+        MIK_Wake();
     }
 }