@mikrojs/firmware 0.13.0 → 0.14.0-pr-229.g46bcbe2

package/README.md

@@ -6,20 +6,19 @@ ESP32 firmware package for Mikro.js. Provides the ESP-IDF integration, build sys
 
 - **`project.cmake`** - CMake module that integrates with ESP-IDF. Handles component discovery, SDK config merging, and partition table defaults.
 - **`components/mikrojs/`** - ESP-IDF component that compiles the Mikro.js runtime, QuickJS engine, and platform-specific C modules.
-- **`idf.py` wrapper** - Runs `idf.py` through `eim run`, so you don't need to manually activate ESP-IDF.
 - **Default configs** - `sdkconfig.defaults` and `partitions.csv` for common setups.
 
 ## Usage
 
-A custom firmware project depends on this package and includes `project.cmake`:
+A custom firmware project depends on this package and includes `project.cmake` (resolved via `resolve.js`, see the docs below for the CMakeLists boilerplate):
 
 ```
 my-firmware/
 ├── package.json          # depends on @mikrojs/firmware
-├── CMakeLists.txt        # include($ENV{MIKROJS_PROJECT_CMAKE})
-└── main/
-    ├── CMakeLists.txt
-    └── main.cpp          # calls MIK_Main()
+├── CMakeLists.txt        # resolves and includes project.cmake via resolve.js
+└── main/                 # optional: omit it and the package's default main
+    ├── CMakeLists.txt    # (which calls MIK_Main()) is used automatically
+    └── main.cpp
 ```
 
 See the [Custom Firmware](https://mikrojs.dev/develop/custom-firmware) docs for details.
@@ -27,4 +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/esp-idf/en/stable/esp32/get-started/index.html))
+- ESP-IDF >= 6.0.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_http.cpp

@@ -581,6 +581,14 @@ static JSValue mik__http_request(JSContext* ctx, JSValue this_val, int argc, JSV
     MIKHttpPending pending = {};
     pending.id = mik__http_st(mik_rt)->next_id++;
     JSValue headers_promise = MIK_InitPromise(ctx, &pending.headers_promise);
+    if (JS_IsException(headers_promise)) {
+        /* OOM building the promise. Nothing is registered yet, so just free the
+         * request and propagate. Do NOT register this pending entry: its
+         * headers_promise.rfuncs are unwritten on failure, and a later
+         * consume/destroy would free dangling values (gc_decref underflow). */
+        mik__http_free_request(&req);
+        return JS_EXCEPTION;
+    }
 
     auto* cancelled = new std::atomic<bool>(false);
     pending.cancelled = cancelled;
@@ -672,6 +680,12 @@ static JSValue mik__http_next_message(JSContext* ctx, JSValue this_val, int argc
 
     /* Slow path: wait. Create a new promise stored on the pending entry. */
     JSValue promise = MIK_InitPromise(ctx, &p->next_promise);
+    if (JS_IsException(promise)) {
+        /* OOM building the promise. Do NOT mark next_promise_active: rfuncs are
+         * unwritten on failure, so a later resolve/destroy would free dangling
+         * values (gc_decref underflow). */
+        return JS_EXCEPTION;
+    }
     p->next_promise_active = true;
     return promise;
 }

package/components/mikrojs/mik_sntp.cpp

@@ -144,6 +144,15 @@ static JSValue mik__sntp_sync(JSContext* ctx, JSValue this_val, int argc, JSValu
 
     /* Create and return promise wrapped in result */
     JSValue promise = MIK_InitPromise(ctx, &state->sync_promise);
+    if (JS_IsException(promise)) {
+        /* OOM building the promise. Tear down so we don't leave a half-started
+         * sync, and crucially do NOT set sync_pending: MIK_InitPromise leaves
+         * sync_promise.rfuncs unwritten on failure, so a later consume/destroy
+         * would free dangling values (gc_decref refcount underflow). */
+        esp_netif_sntp_deinit();
+        state->running = false;
+        return JS_EXCEPTION;
+    }
     state->sync_pending = true;
 
     return mik__result_ok(ctx, promise);

package/components/mikrojs/mik_wifi.cpp

@@ -2,6 +2,7 @@
 #include <vector>
 
 #include "esp_event.h"
+#include "esp_heap_caps.h"
 #include "esp_log.h"
 #include "esp_mac.h"
 #include "esp_netif.h"
@@ -332,6 +333,17 @@ fail_after_init:
     return err;
 }
 
+/* Minimum free internal (DMA-capable) RAM required before bringing up the
+ * radio. esp_wifi_start() enables the PHY, which calloc()s its RF
+ * calibration data from internal RAM and calls abort() on failure
+ * (esp_phy/src/phy_init.c: "failed to allocate memory for RF calibration
+ * data"). That hard-abort reboots the device instead of surfacing a
+ * catchable error, so we pre-flight the heap here and refuse gracefully
+ * when it's too low. The figure covers the PHY cal buffers plus the WiFi
+ * driver's start-time internal allocations with margin; it is a heuristic,
+ * not an exact bound. Tune if a healthy device ever trips it. */
+static constexpr size_t MIK_WIFI_MIN_INTERNAL_HEAP = 40 * 1024;
+
 /* Start the WiFi radio.  Deferred from init so the radio is not active
  * until connect() or scan() is actually called. */
 static esp_err_t mik__wifi_ensure_started(JSContext* ctx) {
@@ -339,6 +351,13 @@ static esp_err_t mik__wifi_ensure_started(JSContext* ctx) {
     if (err != ESP_OK) return err;
     if (s_wifi_started) return ESP_OK;
 
+    /* Refuse to start under low internal RAM rather than let the PHY init
+     * abort() the whole device. The caller turns ESP_ERR_NO_MEM into a
+     * catchable StartFailed result. */
+    if (heap_caps_get_free_size(MALLOC_CAP_INTERNAL) < MIK_WIFI_MIN_INTERNAL_HEAP) {
+        return ESP_ERR_NO_MEM;
+    }
+
     err = esp_wifi_start();
     if (err != ESP_OK) return err;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.13.0",
+  "version": "0.14.0-pr-229.g46bcbe2",
   "description": "Mikro.js ESP32 firmware: ESP-IDF component, build tools, and project template",
   "keywords": [
     "esp-idf",
@@ -18,9 +18,6 @@
     "type": "git",
     "url": "git+https://github.com/mikrojs/mikro.git"
   },
-  "bin": {
-    "idf.py": "./bin/idf.py"
-  },
   "files": [
     "components",
     "default-app",
@@ -28,7 +25,6 @@
     "sdkconfig.defaults",
     "sdkconfig.defaults.*",
     "partitions.csv",
-    "bin",
     "chips.json",
     "cmake.js",
     "discover.js",
@@ -51,8 +47,8 @@
   },
   "dependencies": {
     "esbuild": "^0.28.0",
-    "@mikrojs/native": "0.13.0",
-    "@mikrojs/quickjs": "0.13.0"
+    "@mikrojs/native": "0.14.0-pr-229.g46bcbe2",
+    "@mikrojs/quickjs": "0.14.0-pr-229.g46bcbe2"
   },
   "engines": {
     "node": ">=24.0.0"

package/sdkconfig.defaults

@@ -21,11 +21,11 @@ CONFIG_ESPTOOLPY_FLASHSIZE_4MB=y
 # Use -Os to reduce code size (less IRAM pressure, smaller function frames)
 CONFIG_COMPILER_OPTIMIZATION_SIZE=y
 
-# Move system functions from IRAM to flash (IRAM and DRAM share the same
-# SRAM on single-core chips like C3/C6, so freeing IRAM also frees DRAM)
+# Move heap functions from IRAM to flash (IRAM and DRAM share the same
+# SRAM on single-core chips like C3/C6, so freeing IRAM also frees DRAM).
+# FreeRTOS and esp_ringbuf functions are placed in flash by default since
+# ESP-IDF 6.0; their *_PLACE_FUNCTIONS_INTO_FLASH options were removed.
 CONFIG_HEAP_PLACE_FUNCTION_INTO_FLASH=y
-CONFIG_FREERTOS_PLACE_FUNCTIONS_INTO_FLASH=y
-CONFIG_RINGBUF_PLACE_FUNCTIONS_INTO_FLASH=y
 
 # Trade WiFi throughput for ~15-20KB IRAM savings. Fine for mikrojs
 # workloads (HTTP requests, small payloads — not high-throughput streaming).

package/bin/idf.py

@@ -1,7 +0,0 @@
-#!/bin/sh
-# Thin wrapper: runs idf.py via eim in the activated ESP-IDF environment.
-# Usage: idf.py <args>
-#   idf.py build
-#   idf.py set-target esp32c6
-#   idf.py build flash monitor
-exec eim run "idf.py $*"