@mikrojs/firmware 0.21.1-next.20260927212749 → 0.22.0

package/components/mikrojs/CMakeLists.txt

@@ -49,14 +49,13 @@ endif()
 # idf_component.yml.
 idf_component_register(
     INCLUDE_DIRS "include" "${MIK_INCLUDE_DIR}"
-    REQUIRES bt littlefs esp_adc esp_app_format esp_driver_gpio esp_driver_i2c esp_driver_i2s esp_driver_ledc esp_driver_rmt esp_driver_spi esp_psram esp_timer esp_http_client esp_http_server esp-tls esp_netif esp_event esp_wifi nvs_flash esp_driver_uart esp_driver_usb_serial_jtag spi_flash
+    REQUIRES bt littlefs esp_adc esp_app_format esp_driver_gpio esp_driver_i2c esp_driver_i2s esp_driver_ledc esp_driver_rmt esp_driver_spi esp_pm esp_psram esp_timer esp_http_client esp_http_server esp-tls esp_netif esp_event esp_wifi nvs_flash esp_driver_uart esp_driver_usb_serial_jtag spi_flash
     SRCS
     # QuickJS engine
     ${QUICKJS_SOURCES}
     # Standalone library portable sources
     "${MIK_SRC_DIR}/cutils_compat.c"
     "${MIK_SRC_DIR}/builtins.cpp"
-    "${MIK_SRC_DIR}/eval_bytecode.cpp"
     "${MIK_SRC_DIR}/mik_abort.cpp"
     "${MIK_SRC_DIR}/mik_http_client.cpp"
     "${MIK_SRC_DIR}/mik_wifi_client.cpp"
@@ -74,6 +73,7 @@ idf_component_register(
     "${MIK_SRC_DIR}/mik_text_encoding.cpp"
     "${MIK_SRC_DIR}/mik_cbor.cpp"
     "${MIK_SRC_DIR}/mik_schema.cpp"
+    "${MIK_SRC_DIR}/mik_test.cpp"
     "${MIK_SRC_DIR}/mik_sys_codec.cpp"
     "${MIK_SRC_DIR}/mik_result.cpp"
     "${MIK_SRC_DIR}/mik_udp.cpp"

package/components/mikrojs/Kconfig

@@ -1,3 +1,31 @@
+menu "mikrojs boot"
+
+    config MIKROJS_RECOVERY_WINDOW_MS
+        int "Recovery window at boot (ms)"
+        default 500
+        range 0 5000
+        help
+            How long the firmware listens on the console at the start of
+            every boot, before it runs the app, for the recovery trigger:
+            the sync sequence that `mikro deploy --recover`, `mikro clean
+            --recover` and `mikro console --recover` send after resetting
+            the chip, or a second press of the reset button inside the
+            window. Either one skips the app and drops to the REPL, which
+            is how you replace a crash-looping app.
+
+            Every boot pays the whole window at full power, including
+            every wake from deep sleep, since a wake is a reboot. The
+            double reset needs a window long enough to press reset twice,
+            and --recover needs it to outlast the host's reconnect after
+            the reset, so a short value is in practice the same as 0. At
+            0 the device boots straight into the app, and --recover and
+            the double reset stop working. A crash-looping app then has
+            to be erased over USB from the ROM bootloader (`mikro erase`,
+            then `mikro flash`). Keep the default unless you have another
+            way back into a broken device.
+
+endmenu
+
 menu "mikrojs console"
 
     config MIKROJS_CONSOLE_FALLBACK_UART
@@ -22,6 +50,49 @@ menu "mikrojs console"
 
 endmenu
 
+menu "mikrojs power"
+
+    config MIKROJS_AUTO_LIGHT_SLEEP
+        bool "Enter light sleep automatically when idle (experimental)"
+        default n
+        # select skips PM_ENABLE's own conditions, so repeat them here.
+        depends on SOC_PM_SUPPORTED && !FREERTOS_SMP
+        depends on ESP_CONSOLE_USB_SERIAL_JTAG_ENABLED
+        depends on !MIKROJS_CONSOLE_FALLBACK_UART
+        select PM_ENABLE
+        select PM_DFS_INIT_AUTO
+        select FREERTOS_USE_TICKLESS_IDLE
+        select USJ_NO_AUTO_LS_ON_CONNECTION
+        help
+            When enabled, the chip enters light sleep whenever no task needs
+            to run and no driver holds a power lock, and wakes for the next
+            timer. It also turns on ESP-IDF power management with frequency
+            scaling (DFS), which lowers the CPU clock while the app waits.
+
+            MIK_Main switches light sleep on. A custom main that does not call
+            MIK_Main gets frequency scaling and tickless idle but no light
+            sleep, unless it calls esp_pm_configure itself.
+
+            The USB-Serial/JTAG console stops in light sleep, so
+            USJ_NO_AUTO_LS_ON_CONNECTION keeps the chip awake while a USB host
+            is connected: the console, REPL and deploy work as before, and the
+            savings start once the host is gone.
+
+            An open Pwm, Uart, NeoPixel or I2s handle keeps the chip awake, and
+            I2C and SPI transfers do too. WiFi sleeps between beacons in the
+            "min" and "max" power save modes. BLE keeps the chip awake while
+            the controller is enabled.
+
+            Known limits: GPIO edges do not wake the chip, so an edge during
+            sleep can be missed. A USB host plugged in while the chip sleeps
+            can fail to enumerate; reset the board. On the ESP32-S3 the CPU
+            state saved across sleep takes up to about 17 KB of internal RAM.
+
+            Not available with a UART console (the ESP32, or
+            MIKROJS_CONSOLE_FALLBACK_UART), since UART RX stops in light sleep.
+
+endmenu
+
 menu "mikrojs WiFi"
 
     config MIKROJS_WIFI
@@ -70,7 +141,8 @@ menu "mikrojs runtime memory"
 
             Defaults on for chips with PSRAM. Disable if your workload
             is JS-execution-bound and you can fit the JS heap in
-            internal SRAM. No effect on chips without PSRAM.
+            internal SRAM. No effect on chips without PSRAM, or when no
+            PSRAM chip is found at boot.
 
 endmenu
 

package/components/mikrojs/include/mikrojs_esp32.h

@@ -78,6 +78,10 @@ void mik__console_init(void);
 /* Read from the active console.  Returns bytes read, 0 if no data, or -1. */
 int mik__console_read(void* buf, size_t len);
 
+/* MIK_Wake for interrupt handlers (platform_esp32.cpp). IRAM-resident, so a
+ * handler installed with ESP_INTR_FLAG_IRAM may call it with the flash cache off. */
+void MIK_WakeFromISR(void);
+
 /* Write to the active console.  Returns bytes written. */
 int mik__console_write(const void* buf, size_t len);
 
@@ -94,7 +98,6 @@ void mik__console_set_tap(mik_console_tap_fn fn);
 typedef struct MIKConfig MIKConfig;
 void mik_logfile_init(const MIKConfig* config);
 void mik_logfile_close(void);
-void mik_logfile_flush(void);
 /* Release/restore the underlying FILE* so the host can read the file
  * without contention. Output between suspend/resume is dropped. No-op
  * when file logging is disabled. */
@@ -140,8 +143,6 @@ void mik__serial_io_attach_usb(void);
 extern const char* MIK__NVS_NS_ENV;  /* env var values */
 extern const char* MIK__NVS_NS_SEC;  /* secret-flag markers (u8) */
 /* ENV_FLAG_SECRET is defined in mikrojs/private.h as MIK_ENV_FLAG_SECRET */
-void mik__nvs_clear_namespace(const char* ns);
-bool mik__nvs_put_string(const char* ns, const char* key, const char* value);
 bool mik__nvs_put_string_if_diff(const char* ns, const char* key, const char* value,
                                  bool* out_changed);
 bool mik__nvs_is_secret(const char* key);

package/components/mikrojs/mik_ble.cpp

@@ -577,7 +577,9 @@ static int mik__ble_gatt_access_cb(uint16_t conn_handle, uint16_t attr_handle,
                 evt.attr_handle = attr_handle;
                 evt.write_data = pool_buf;
                 evt.write_data_len = len;
-                if (xQueueSend(s_ble_event_queue, &evt, 0) != pdTRUE) {
+                if (xQueueSend(s_ble_event_queue, &evt, 0) == pdTRUE) {
+                    MIK_Wake();
+                } else {
                     /* Queue full — return the buffer to the pool. */
                     mik__ble_pool_free(pool_buf);
                     ESP_LOGW(MIK_BLE_TAG, "event queue full, dropping write event");
@@ -641,7 +643,10 @@ static int mik__ble_gap_event_cb(struct ble_gap_event* event, void* arg) {
             evt.mtu = mtu;
             /* Connection formed — NimBLE stopped advertising automatically. */
             s_advertising = false;
-            if (s_ble_event_queue) xQueueSend(s_ble_event_queue, &evt, 0);
+            if (s_ble_event_queue) {
+                xQueueSend(s_ble_event_queue, &evt, 0);
+                MIK_Wake();
+            }
             return 0;
         }
         case BLE_GAP_EVENT_DISCONNECT: {
@@ -669,7 +674,10 @@ static int mik__ble_gap_event_cb(struct ble_gap_event* event, void* arg) {
             memcpy(evt.peer_addr, peer_addr, 6);
             evt.mtu = cached_mtu;
             evt.disconnect_reason = static_cast<uint8_t>(event->disconnect.reason & 0xff);
-            if (s_ble_event_queue) xQueueSend(s_ble_event_queue, &evt, 0);
+            if (s_ble_event_queue) {
+                xQueueSend(s_ble_event_queue, &evt, 0);
+                MIK_Wake();
+            }
             return 0;
         }
         case BLE_GAP_EVENT_MTU: {
@@ -684,7 +692,10 @@ static int mik__ble_gap_event_cb(struct ble_gap_event* event, void* arg) {
             evt.type = MIK_BLE_EVT_MTU;
             evt.conn_handle = event->mtu.conn_handle;
             evt.mtu = event->mtu.value;
-            if (s_ble_event_queue) xQueueSend(s_ble_event_queue, &evt, 0);
+            if (s_ble_event_queue) {
+                xQueueSend(s_ble_event_queue, &evt, 0);
+                MIK_Wake();
+            }
             return 0;
         }
         case BLE_GAP_EVENT_SUBSCRIBE: {

package/components/mikrojs/mik_ble_c_shim.c

@@ -59,3 +59,13 @@ int mik_ble_controller_deinit(void) {
     if (status == ESP_BT_CONTROLLER_STATUS_IDLE) return 0;
     return (int)esp_bt_controller_deinit();
 }
+
+/* ── Boot-time memory release ──────────────────────────────────────── */
+
+#if CONFIG_IDF_TARGET_ESP32
+/* Only the original ESP32 has a classic-BT controller region to give back
+ * (SOC_MEM_BT_EM_BREDR_START..SOC_MEM_BT_EM_BREDR_REAL_END). */
+int mik_ble_release_classic_bt_mem(void) {
+    return (int)esp_bt_controller_mem_release(ESP_BT_MODE_CLASSIC_BT);
+}
+#endif

package/components/mikrojs/mik_ble_c_shim.h

@@ -30,6 +30,15 @@ int mik_ble_controller_disable(void);
  */
 int mik_ble_controller_deinit(void);
 
+/* ── Boot-time memory release ──────────────────────────────────────── */
+
+/**
+ * Release the classic-BT controller memory to the heap. Original ESP32
+ * only; call before the controller is initialized. Returns 0 on success
+ * or a non-zero esp_err_t code on failure.
+ */
+int mik_ble_release_classic_bt_mem(void);
+
 #ifdef __cplusplus
 }
 #endif

package/components/mikrojs/mik_deploy.cpp

@@ -265,6 +265,16 @@ static const char* copy_file(const char* src, const char* dst) {
     return failed;
 }
 
+/* Stage a live file for the next commit. Returns NULL on success, otherwise
+ * the step that failed, with errno set. */
+static const char* keep_file(const char* name) {
+    char src_path[512], dst_path[512];
+    snprintf(src_path, sizeof(src_path), "%s%s", FS_BASE, name);
+    snprintf(dst_path, sizeof(dst_path), "%s%s", DEPLOY_TMP, name);
+    if (!make_parent_dir(dst_path)) return "create directory failed";
+    return copy_file(src_path, dst_path);
+}
+
 /* ── Deploy recovery ─────────────────────────────────────────────── */
 
 void MIK_DeployRecover(void) {
@@ -414,16 +424,7 @@ bool mik__handle_deploy_command(MIKReplTransport* transport, uint8_t cmd_type,
             if (!mik__proto_read_exact(transport, name, name_len)) return false;
             name[name_len] = '\0';
 
-            char src_path[512], dst_path[512];
-            snprintf(src_path, sizeof(src_path), "%s%s", FS_BASE, name);
-            snprintf(dst_path, sizeof(dst_path), "%s%s", DEPLOY_TMP, name);
-
-            if (!make_parent_dir(dst_path)) {
-                send_errno(transport, "create directory failed", errno);
-                return true;
-            }
-
-            const char* failed = copy_file(src_path, dst_path);
+            const char* failed = keep_file(name);
             if (failed) {
                 send_errno(transport, failed, errno);
             } else {
@@ -432,6 +433,87 @@ bool mik__handle_deploy_command(MIKReplTransport* transport, uint8_t cmd_type,
             return true;
         }
 
+        case MIK_CMD_DEPLOY_KEEP_MANY: {
+            /* Payload: repeated u16le name_len | name. Each file is staged as
+             * KEEP stages it. The first failure ends the batch: the rest of
+             * the payload is dropped and the error names the file. */
+            uint32_t consumed = 0;
+            while (consumed < payload_len) {
+                if (payload_len - consumed < 2) {
+                    mik__proto_drain(transport, payload_len - consumed);
+                    mik__proto_send_err(transport, "keep list truncated");
+                    return true;
+                }
+                uint8_t nl[2];
+                if (!mik__proto_read_exact(transport, nl, 2)) return false;
+                consumed += 2;
+                uint16_t name_len = nl[0] | (nl[1] << 8);
+
+                char name[256];
+                if (name_len >= sizeof(name) || name_len > payload_len - consumed) {
+                    mik__proto_drain(transport, payload_len - consumed);
+                    mik__proto_send_err(transport, "keep filename too long");
+                    return true;
+                }
+                if (!mik__proto_read_exact(transport, name, name_len)) return false;
+                consumed += name_len;
+                name[name_len] = '\0';
+
+                const char* failed = keep_file(name);
+                if (failed) {
+                    int err = errno;
+                    mik__proto_drain(transport, payload_len - consumed);
+                    char msg[384];
+                    snprintf(msg, sizeof(msg), "%s: %s: %s", name, failed, strerror(err));
+                    mik__proto_send_err(transport, msg);
+                    return true;
+                }
+            }
+            mik__proto_send_ok(transport);
+            return true;
+        }
+
+        case MIK_CMD_DEPLOY_CHECKSUM_LIST: {
+            /* Reply: u16le file_count | the manifest lines whose file is on
+             * disk, so the host never KEEPs a file a stale manifest still
+             * names (see CHECKSUM). file_count counts every manifest entry. */
+            mik__proto_drain(transport, payload_len);
+            const ChecksumsManifest& m = s_deploy_manifest;
+            auto* reply = static_cast<uint8_t*>(malloc(2 + m.len));
+            if (!reply) {
+                mik__proto_send_err(transport, "out of memory");
+                return true;
+            }
+            reply[0] = static_cast<uint8_t>(s_deploy_manifest_files & 0xff);
+            reply[1] = static_cast<uint8_t>(s_deploy_manifest_files >> 8);
+            size_t out = 2;
+            if (m.data) {
+                const char* p = m.data;
+                const char* end = m.data + m.len;
+                while (p < end) {
+                    const char* nl = static_cast<const char*>(memchr(p, '\n', end - p));
+                    const char* next = nl ? nl + 1 : end;
+                    size_t entry_len = static_cast<size_t>((nl ? nl : end) - p);
+                    /* "<64 hex>  <name>", the name no longer than KEEP accepts. */
+                    if (entry_len >= 67 && entry_len < 66 + 256 && p[0] != '#') {
+                        char path[512];
+                        snprintf(path, sizeof(path), "%s%.*s", FS_BASE,
+                                 static_cast<int>(entry_len - 66), p + 66);
+                        feed_watchdog();
+                        if (path_exists(path)) {
+                            size_t line_len = static_cast<size_t>(next - p);
+                            memcpy(reply + out, p, line_len);
+                            out += line_len;
+                        }
+                    }
+                    p = next;
+                }
+            }
+            mik__proto_send(transport, MIK_MSG_OK, reply, out);
+            free(reply);
+            return true;
+        }
+
         case MIK_CMD_DEPLOY_PUT: {
             /* Begin a streaming PUT.
              * Payload: u16le name_len | name | u32le total_size

package/components/mikrojs/mik_gpio.cpp

@@ -476,7 +476,11 @@ static JSValue js_digital_out_write(JSContext* ctx, JSValueConst this_val, int a
 /* ── DigitalIn ───────────────────────────────────────────────────── */
 
 static IRAM_ATTR void mik__gpio_isr(void* arg) {
-    static_cast<MIKGpioState*>(arg)->pending.store(true, std::memory_order_relaxed);
+    auto* s = static_cast<MIKGpioState*>(arg);
+    /* One wake per batch of edges: the consumer reads the level once for them all. */
+    if (s->pending.load(std::memory_order_relaxed)) return;
+    s->pending.store(true, std::memory_order_relaxed);
+    MIK_WakeFromISR();
 }
 
 static JSValue js_digital_in_read(JSContext* ctx, JSValueConst this_val, int argc,
@@ -681,6 +685,7 @@ void mik__gpio_wake_done(int gpio) {
         gpio_set_intr_type(num, GPIO_INTR_ANYEDGE);
         /* The level may have changed while edges were off; let the consumer compare. */
         s->pending.store(true, std::memory_order_relaxed);
+        MIK_Wake();
         /* Re-adding re-enables the interrupt on the service's core. */
         gpio_isr_handler_add(num, mik__gpio_isr, s);
         return;

package/components/mikrojs/mik_http.cpp

@@ -118,6 +118,12 @@ static esp_err_t mik__http_event_handler(esp_http_client_event_t* evt) {
     return ESP_OK;
 }
 
+/* Queues a message for the loop consumer and wakes the loop to take it. */
+static void mik__post(QueueHandle_t q, const MIKHttpMsg* m) {
+    xQueueSend(q, m, portMAX_DELAY);
+    MIK_Wake();
+}
+
 static void mik__post_headers(QueueHandle_t q, uint32_t id, int status,
                               MIKHttpHeader* headers, size_t header_count) {
     MIKHttpMsg m = {};
@@ -126,7 +132,7 @@ static void mik__post_headers(QueueHandle_t q, uint32_t id, int status,
     m.status = status;
     m.headers = headers;
     m.header_count = header_count;
-    xQueueSend(q, &m, portMAX_DELAY);
+    mik__post(q, &m);
 }
 
 static void mik__post_chunk(QueueHandle_t q, uint32_t id, uint8_t* data, size_t len) {
@@ -135,14 +141,14 @@ static void mik__post_chunk(QueueHandle_t q, uint32_t id, uint8_t* data, size_t
     m.kind = MIK_HTTP_MSG_CHUNK;
     m.chunk_data = data;
     m.chunk_len = len;
-    xQueueSend(q, &m, portMAX_DELAY);
+    mik__post(q, &m);
 }
 
 static void mik__post_end(QueueHandle_t q, uint32_t id) {
     MIKHttpMsg m = {};
     m.id = id;
     m.kind = MIK_HTTP_MSG_END;
-    xQueueSend(q, &m, portMAX_DELAY);
+    mik__post(q, &m);
 }
 
 static void mik__post_error(QueueHandle_t q, uint32_t id, const char* msg, bool cancelled) {
@@ -154,7 +160,7 @@ static void mik__post_error(QueueHandle_t q, uint32_t id, const char* msg, bool
     /* If strdup fails under OOM, the downstream consumer treats NULL as "" but
      * the JS side then sees an empty error message. Leave NULL here — the
      * empty-string fallback in mik__error_msg_value keeps the flow intact. */
-    xQueueSend(q, &m, portMAX_DELAY);
+    mik__post(q, &m);
 }
 
 static bool mik__task_cancelled(MIKHttpTaskArgs* args) {

package/components/mikrojs/mik_http_server.cpp

@@ -110,6 +110,7 @@ static void mik__hs_free_exchange(MIKHsExchange* ex) {
 static void mik__hs_post_ack(QueueHandle_t q, MIKHsExchange* ex, bool ok) {
     MIKHsAck a = {ex, ok};
     xQueueSend(q, &a, portMAX_DELAY);
+    MIK_Wake();
 }
 
 static void mik__hs_set_head(httpd_req_t* req, MIKHsExchange* ex) {
@@ -183,6 +184,7 @@ static esp_err_t mik__hs_handler(httpd_req_t* req) {
         httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, nullptr);
         return ESP_OK;
     }
+    MIK_Wake();
 
     /* Drive the response from JS commands. httpd_stop() can't complete until
      * this handler returns, so stop() sets `stopping` before calling it. */

package/components/mikrojs/mik_i2s.cpp

@@ -2,6 +2,7 @@
 #include <cstring>
 
 #include "driver/i2s_std.h"
+#include "esp_attr.h"
 /* soc_caps.h has no I2S controller count in IDF 6.1; the HAL header does. */
 #include "hal/i2s_ll.h"
 #include "soc/soc_caps.h"
@@ -229,6 +230,16 @@ static void mik__i2s_del_channels(MIKI2sState* s) {
     }
 }
 
+/* I2S ISR: a DMA buffer went out. With a chunk queued, the loop consumer can
+ * push the next piece now instead of at its wait's cap. */
+static bool IRAM_ATTR mik__i2s_on_sent(i2s_chan_handle_t handle, i2s_event_data_t* event,
+                                       void* user_ctx) {
+    (void)handle;
+    (void)event;
+    if (static_cast<MIKI2sState*>(user_ctx)->tx_count > 0) MIK_WakeFromISR();
+    return false;  // the wake yields itself
+}
+
 /* Creates, configures and enables the channels. */
 static esp_err_t mik__i2s_start(MIKI2sState* s, uint32_t sample_rate, int dma_frames,
                                 int dma_buffers) {
@@ -291,6 +302,12 @@ static esp_err_t mik__i2s_start(MIKI2sState* s, uint32_t sample_rate, int dma_fr
             return err;
     }
 
+    if (s->tx_chan) {
+        i2s_event_callbacks_t cbs = {};
+        cbs.on_sent = mik__i2s_on_sent;
+        if ((err = i2s_channel_register_event_callback(s->tx_chan, &cbs, s)) != ESP_OK)
+            return err;
+    }
     if (s->tx_chan && (err = i2s_channel_enable(s->tx_chan)) != ESP_OK) return err;
     if (s->rx_chan && (err = i2s_channel_enable(s->rx_chan)) != ESP_OK) return err;
     return ESP_OK;

package/components/mikrojs/mik_logfile.cpp

@@ -281,13 +281,6 @@ void mik_logfile_reset(void) {
     xSemaphoreGive(s_mtx);
 }
 
-void mik_logfile_flush(void) {
-    if (!s_mtx || !s_file) return;
-    if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(50)) != pdTRUE) return;
-    flush_to_flash();
-    xSemaphoreGive(s_mtx);
-}
-
 void mik_logfile_close(void) {
     if (!s_mtx) return;
     if (xSemaphoreTake(s_mtx, pdMS_TO_TICKS(100)) != pdTRUE) return;