@mikrojs/firmware 0.6.0-pr-70.gd2fdc0d → 0.6.0

package/chips.json

@@ -1,3 +1,3 @@
 {
-  "chips": ["esp32", "esp32c3", "esp32c6", "esp32s3"]
+  "chips": ["esp32", "esp32c3", "esp32c5", "esp32c6", "esp32s3"]
 }

package/components/mikrojs/CMakeLists.txt

@@ -132,7 +132,7 @@ include("${MIK_BYTECODE_CMAKE}")
 
 # Force linker to include self-registering native modules
 set(_MIK_MODULES cbor pin i2c spi http wifi rtc nvs_kv sntp sleep neopixel pwm uart)
-set(_MIK_BYTECODE_MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel observable observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi)
+set(_MIK_BYTECODE_MODULES cbor env result schema fs http/helpers http/request i2c kv/nvs kv/rtc kv/shared neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi)
 if(CONFIG_BT_ENABLED)
     list(APPEND _MIK_MODULES ble)
     list(APPEND _MIK_BYTECODE_MODULES ble)

package/components/mikrojs/mik_http.cpp

@@ -3,7 +3,6 @@
 
 #include "esp_crt_bundle.h"
 #include "esp_event.h"
-#include "esp_heap_caps.h"
 #include "esp_http_client.h"
 #include "esp_log.h"
 #include "esp_netif.h"
@@ -212,24 +211,18 @@ static void mik__http_task(void* arg) {
     }
 
     {
-        /* Diagnostic: internal-SRAM contiguous block right before the mbedTLS
-         * handshake. mbedTLS needs ~16 KB twice (in/out content buffers); when
-         * `internal_largest` drops near or below that, HTTPS connects fail with
-         * ESP_ERR_HTTP_CONNECT (0x7002). Tracking this until the JS-heap-on-
-         * PSRAM work lands; see .claude/plans/internal-sram-budget.md. */
-        printf("[probe] pre-open: internal_free=%u internal_largest=%u total_free=%u\n",
-               (unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-               (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL),
-               (unsigned)heap_caps_get_free_size(MALLOC_CAP_8BIT));
         esp_err_t err = esp_http_client_open(client, args->req.body_len);
         if (err != ESP_OK) {
-            printf("[probe] esp_http_client_open failed: %s (0x%x) "
-                   "internal_free=%u internal_largest=%u\n",
-                   esp_err_to_name(err), (unsigned)err,
-                   (unsigned)heap_caps_get_free_size(MALLOC_CAP_INTERNAL),
-                   (unsigned)heap_caps_get_largest_free_block(MALLOC_CAP_INTERNAL));
-            snprintf(error_buf, sizeof(error_buf), "fetch failed: could not connect to %s",
-                     args->req.url);
+            int sock_errno = esp_http_client_get_errno(client);
+            int tls_code = 0;
+            int tls_flags = 0;
+            esp_err_t last_tls_err =
+                esp_http_client_get_and_clear_last_tls_error(client, &tls_code, &tls_flags);
+            snprintf(error_buf, sizeof(error_buf),
+                     "fetch failed: could not connect to %s (%s, errno=%d, "
+                     "esp_tls=%s, mbedtls=-0x%04x, flags=0x%x)",
+                     args->req.url, esp_err_to_name(err), sock_errno,
+                     esp_err_to_name(last_tls_err), tls_code, tls_flags);
             have_error = true;
             goto cleanup;
         }

package/components/mikrojs/mik_wifi.cpp

@@ -9,6 +9,7 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/queue.h"
 #include "nvs_flash.h"
+#include "mikrojs/platform.h"
 #include "private.h"
 #include "utils.h"
 
@@ -251,7 +252,29 @@ static void mik__wifi_event_handler(void* arg, esp_event_base_t event_base, int3
     }
 }
 
-esp_err_t mik__wifi_ensure_initialized() {
+/* Pick the DHCP hostname for the STA netif: configured `wifi.hostname` from
+ * mikro.config.json takes priority; otherwise default to `mikrojs-<device-id>`.
+ * Returns true if a hostname was applied. */
+static bool mik__wifi_apply_hostname(JSContext* ctx) {
+    if (!s_sta_netif) return false;
+    char buf[64];
+    const char* hostname = nullptr;
+    if (ctx) {
+        MIKRuntime* mik_rt = MIK_GetRuntime(ctx);
+        if (mik_rt && mik_rt->config.wifi_hostname[0] != '\0') {
+            hostname = mik_rt->config.wifi_hostname;
+        }
+    }
+    if (!hostname) {
+        const char* dev_id = MIK_GetPlatform()->get_device_id();
+        if (!dev_id || !dev_id[0]) return false;
+        snprintf(buf, sizeof(buf), "mikrojs-%s", dev_id);
+        hostname = buf;
+    }
+    return esp_netif_set_hostname(s_sta_netif, hostname) == ESP_OK;
+}
+
+esp_err_t mik__wifi_ensure_initialized(JSContext* ctx) {
     if (s_wifi_initialized) return ESP_OK;
 
     esp_err_t err = nvs_flash_init();
@@ -272,6 +295,7 @@ esp_err_t mik__wifi_ensure_initialized() {
      * asserting in esp_netif_create_default_wifi_sta. */
     if (!s_sta_netif) {
         s_sta_netif = esp_netif_create_default_wifi_sta();
+        if (s_sta_netif) mik__wifi_apply_hostname(ctx);
     }
     if (!s_sta_netif) return ESP_FAIL;
 
@@ -310,8 +334,8 @@ fail_after_init:
 
 /* 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() {
-    esp_err_t err = mik__wifi_ensure_initialized();
+static esp_err_t mik__wifi_ensure_started(JSContext* ctx) {
+    esp_err_t err = mik__wifi_ensure_initialized(ctx);
     if (err != ESP_OK) return err;
     if (s_wifi_started) return ESP_OK;
 
@@ -374,7 +398,7 @@ static JSClassDef mik_wifi_classdef = {
 };
 
 static JSValue mik__wifi_constructor(JSContext* ctx, JSValue new_target, int argc, JSValue* argv) {
-    esp_err_t err = mik__wifi_ensure_initialized();
+    esp_err_t err = mik__wifi_ensure_initialized(ctx);
     if (err != ESP_OK) {
         return JS_ThrowInternalError(ctx, "WiFi init failed: %s", esp_err_to_name(err));
     }
@@ -386,7 +410,7 @@ static JSValue mik__wifi_connect(JSContext* ctx, JSValue this_val, int argc, JSV
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(start_err));
@@ -478,7 +502,7 @@ static JSValue mik__wifi_scan(JSContext* ctx, JSValue this_val, int argc, JSValu
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(start_err));
@@ -631,22 +655,6 @@ static JSValue mik__wifi_get_hostname(JSContext* ctx, JSValue this_val, int argc
     return JS_NewString(ctx, hostname);
 }
 
-static JSValue mik__wifi_set_hostname(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    if (!s_sta_netif) {
-        return mik__result_err_tag(ctx, "NotInitialized");
-    }
-    const char* hostname = JS_ToCString(ctx, argv[0]);
-    if (!hostname) return JS_EXCEPTION;
-
-    esp_err_t err = esp_netif_set_hostname(s_sta_netif, hostname);
-    JS_FreeCString(ctx, hostname);
-    if (err != ESP_OK) {
-        return mik__result_err_named(ctx, "SetFailed",
-                               "Failed to set hostname: %s", esp_err_to_name(err));
-    }
-    return mik__result_ok_void(ctx);
-}
-
 static JSValue mik__wifi_get_ip_config(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     if (!s_sta_netif) {
         return JS_UNDEFINED;
@@ -746,7 +754,7 @@ static JSValue mik__wifi_ap_start(JSContext* ctx, JSValue this_val, int argc, JS
         return mik__result_err_tag(ctx, "CountryNotSet");
     }
 
-    esp_err_t err = mik__wifi_ensure_started();
+    esp_err_t err = mik__wifi_ensure_started(ctx);
     if (err != ESP_OK) {
         return mik__result_err_named(ctx, "StartFailed",
                                "Failed to start WiFi radio: %s", esp_err_to_name(err));
@@ -952,26 +960,11 @@ static JSValue mik__wifi_get_country(JSContext* ctx, JSValue this_val, int argc,
     return JS_NewStringLen(ctx, cc, 2);
 }
 
-static JSValue mik__wifi_set_country(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
-    const char* cc = JS_ToCString(ctx, argv[0]);
-    if (!cc) return JS_EXCEPTION;
-
-    esp_err_t err = esp_wifi_set_country_code(cc, true);
-    JS_FreeCString(ctx, cc);
-
-    if (err != ESP_OK) {
-        return mik__result_err_named(ctx, "SetFailed",
-                               "Failed to set WiFi country code: %s", esp_err_to_name(err));
-    }
-    s_country_configured = true;
-    return mik__result_ok_void(ctx);
-}
-
 /* ── TX power ──────────────────────────────────────────────────────── */
 
 static JSValue mik__wifi_get_tx_power(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     /* esp_wifi_get_max_tx_power requires the radio to be started. */
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "GetFailed",
                                "Failed to get TX power: %s", esp_err_to_name(start_err));
@@ -988,7 +981,7 @@ static JSValue mik__wifi_get_tx_power(JSContext* ctx, JSValue this_val, int argc
 static JSValue mik__wifi_set_tx_power(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     double dbm;
     if (JS_ToFloat64(ctx, &dbm, argv[0])) return JS_EXCEPTION;
-    esp_err_t start_err = mik__wifi_ensure_started();
+    esp_err_t start_err = mik__wifi_ensure_started(ctx);
     if (start_err != ESP_OK) {
         return mik__result_err_named(ctx, "SetFailed",
                                "Failed to set TX power: %s", esp_err_to_name(start_err));
@@ -1097,7 +1090,6 @@ static const JSCFunctionListEntry mik__wifi_proto_funcs[] = {
     MIK_CFUNC_DEF("off", 2, mik__wifi_off),
     MIK_CFUNC_DEF("mac", 0, mik__wifi_mac),
     MIK_CFUNC_DEF("getHostname", 0, mik__wifi_get_hostname),
-    MIK_CFUNC_DEF("setHostname", 1, mik__wifi_set_hostname),
     MIK_CFUNC_DEF("getIpConfig", 0, mik__wifi_get_ip_config),
     MIK_CFUNC_DEF("setIpConfig", 1, mik__wifi_set_ip_config),
     MIK_CFUNC_DEF("apStart", 1, mik__wifi_ap_start),
@@ -1108,7 +1100,6 @@ static const JSCFunctionListEntry mik__wifi_proto_funcs[] = {
     MIK_CFUNC_DEF("getPowerSave", 0, mik__wifi_get_power_save),
     MIK_CFUNC_DEF("setPowerSave", 1, mik__wifi_set_power_save),
     MIK_CFUNC_DEF("getCountry", 0, mik__wifi_get_country),
-    MIK_CFUNC_DEF("setCountry", 1, mik__wifi_set_country),
     MIK_CFUNC_DEF("getTxPower", 0, mik__wifi_get_tx_power),
     MIK_CFUNC_DEF("setTxPower", 1, mik__wifi_set_tx_power),
     MIK_CFUNC_DEF("getRssiThreshold", 0, mik__wifi_get_rssi_threshold),

package/components/mikrojs/test/wifi_test.cpp

@@ -28,11 +28,15 @@ static void setup() {
     vTaskDelay(pdMS_TO_TICKS(100));
     rt = MIK_NewRuntime();
     ctx = MIK_GetJSContext(rt);
+    /* Country is config-only — populate it directly so wifi ops that gate on
+     * mik__wifi_try_auto_country can proceed. */
+    MIKConfig cfg;
+    MIK_DefaultConfig(&cfg);
+    snprintf(cfg.wifi_country, sizeof(cfg.wifi_country), "US");
+    MIK_SetConfig(rt, &cfg);
     /* WiFi module is self-registered and lazily initialized.
-     * The import below triggers init + loop consumer registration.
-     * Then drain any stale events from previous tests. */
-    const char* init_code =
-        "import { Wifi } from \"native:wifi\"; new Wifi().setCountry(\"US\");";
+     * The import below triggers init + loop consumer registration. */
+    const char* init_code = "import { Wifi } from \"native:wifi\"; new Wifi();";
     JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test-setup", init_code, strlen(init_code));
     if (!JS_IsException(ret)) {
         JS_FreeValue(ctx, ret);
@@ -332,14 +336,22 @@ TEST_CASE("Wifi mac returns a valid MAC address format", "[wifi]") {
     teardown();
 }
 
-TEST_CASE("Wifi hostname get/set round-trips", "[wifi]") {
-    setup();
+TEST_CASE("Wifi hostname reflects configured wifi.hostname", "[wifi]") {
+    /* Custom setup with wifi.hostname populated. Mirrors setup() but injects
+     * a hostname before the lazy netif init runs. */
+    esp_wifi_disconnect();
+    vTaskDelay(pdMS_TO_TICKS(100));
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+    MIKConfig cfg;
+    MIK_DefaultConfig(&cfg);
+    snprintf(cfg.wifi_country, sizeof(cfg.wifi_country), "US");
+    snprintf(cfg.wifi_hostname, sizeof(cfg.wifi_hostname), "test-device");
+    MIK_SetConfig(rt, &cfg);
 
     JSValue ret = eval_module(R"(
         import { Wifi } from "native:wifi";
-        const wifi = new Wifi();
-        wifi.setHostname("test-device");
-        globalThis.__hostname = wifi.getHostname();
+        globalThis.__hostname = new Wifi().getHostname();
     )");
     TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");
 
@@ -446,13 +458,15 @@ TEST_CASE("Wifi power save get/set round-trips", "[wifi]") {
     teardown();
 }
 
-TEST_CASE("Wifi country get/set round-trips", "[wifi]") {
+TEST_CASE("Wifi country reflects configured wifi.country", "[wifi]") {
     setup();
 
+    /* setup() populated wifi_country = "US"; trigger a wifi op so
+     * mik__wifi_try_auto_country applies it, then read back via getCountry. */
     JSValue ret = eval_module(R"(
         import { Wifi } from "native:wifi";
         const wifi = new Wifi();
-        wifi.setCountry("US");
+        wifi.scan();
         globalThis.__cc = wifi.getCountry();
     )");
     TEST_ASSERT_FALSE_MESSAGE(JS_IsException(ret), "Module eval should not throw");

package/package.json

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

package/prebuilds/esp32c5/flasher_args.json

@@ -0,0 +1,24 @@
+{
+    "write_flash_args" : [ "--flash-mode", "dio",
+                           "--flash-size", "4MB",
+                           "--flash-freq", "80m" ],
+    "flash_settings" : {
+        "flash_mode": "dio",
+        "flash_size": "4MB",
+        "flash_freq": "80m"
+    },
+    "flash_files" : {
+        "0x2000" : "bootloader/bootloader.bin",
+        "0x8000" : "partition_table/partition-table.bin",
+        "0x10000" : "mikrojs.bin"
+    },
+    "bootloader" : { "offset" : "0x2000", "file" : "bootloader/bootloader.bin", "encrypted" : "false" },
+    "partition-table" : { "offset" : "0x8000", "file" : "partition_table/partition-table.bin", "encrypted" : "false" },
+    "app" : { "offset" : "0x10000", "file" : "mikrojs.bin", "encrypted" : "false" },
+    "extra_esptool_args" : {
+        "after"  : "hard-reset",
+        "before" : "default-reset",
+        "stub"   : true,
+        "chip"   : "esp32c5"
+    }
+}

package/sdkconfig.defaults

@@ -93,7 +93,10 @@ CONFIG_VFS_SUPPORT_SELECT=n
 
 # --- Assertions & error strings ---
 CONFIG_COMPILER_OPTIMIZATION_CHECKS_SILENT=y
-CONFIG_ESP_ERR_TO_NAME_LOOKUP=n
+# Keep esp_err_to_name() readable. Costs ~2 KB flash; without this, runtime
+# errors surface as "UNKNOWN ERROR" instead of e.g. ESP_ERR_NO_MEM, which
+# makes diagnosing on-device failures unnecessarily painful.
+CONFIG_ESP_ERR_TO_NAME_LOOKUP=y
 CONFIG_HAL_DEFAULT_ASSERTION_LEVEL=0
 
 # --- lwIP ---

package/sdkconfig.defaults.esp32c5

@@ -0,0 +1,15 @@
+# ESP32-C5: same console story as C6 (UART primary, USB-Serial/JTAG
+# secondary). See sdkconfig.defaults.esp32c6 for the reasoning around
+# avoiding ESP-IDF's USB-JTAG VFS at boot. mikrojs installs the
+# USB-Serial/JTAG driver itself for REPL/TLV transport; auto-detection
+# latches to whichever interface receives the first byte.
+CONFIG_ESP_CONSOLE_UART_DEFAULT=y
+CONFIG_ESP_CONSOLE_USB_SERIAL_JTAG=n
+CONFIG_ESP_CONSOLE_SECONDARY_USB_SERIAL_JTAG=y
+
+# Enable PSRAM. Quad SPI is the only supported mode on ESP32-C5.
+# IGNORE_NOTFOUND so the same firmware boots on bare C5 modules too,
+# falling back to internal SRAM only.
+CONFIG_SPIRAM=y
+CONFIG_SPIRAM_USE_MALLOC=y
+CONFIG_SPIRAM_IGNORE_NOTFOUND=y