@mikrojs/firmware 0.11.0 → 0.12.0-next.9.g2e06437

package/components/mikrojs/CMakeLists.txt

@@ -43,7 +43,7 @@ endif()
 
 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_ledc esp_driver_rmt esp_driver_spi esp_psram esp_timer esp_http_client 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_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
     SRCS
     # QuickJS engine
     ${QUICKJS_SOURCES}
@@ -82,6 +82,7 @@ idf_component_register(
     "mik_config.cpp"
     "mik_deploy.cpp"
     "mik_http.cpp"
+    "mik_http_server.cpp"
     "mik_i2c.cpp"
     "mik_logfile.cpp"
     "mik_neopixel.cpp"
@@ -132,8 +133,8 @@ endif()
 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 module neopixel observable observable/lazy observable/operators pin pwm reader sleep spi sntp stdio stream sys test uart udp wifi)
+set(_MIK_MODULES cbor pin i2c spi http http_server wifi rtc nvs_kv sntp sleep neopixel pwm uart)
+set(_MIK_BYTECODE_MODULES cbor env result schema fs http/helpers http/request http/server i2c kv/nvs kv/rtc kv/shared module 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/include/mik_http_server_internal.h

@@ -0,0 +1,90 @@
+/* Internal HTTP-server module layout shared with on-device tests.
+ * Included by mik_http_server.cpp and test/http_server_test.cpp so struct
+ * changes can't drift silently between the implementation and its mirror. */
+#pragma once
+
+#include <cstdint>
+#include <cstdlib>
+
+#include "esp_http_server.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "utils.h"
+
+struct MIKHsHeader {
+    char* key;
+    char* value;
+};
+
+enum MIKHsCmd : uint8_t {
+    MIK_HS_RESPOND,  // one-shot: status + headers + full body
+    MIK_HS_START,    // begin chunked: status + headers
+    MIK_HS_CHUNK,    // one body chunk
+    MIK_HS_END,      // finish chunked
+};
+
+/* Per-request command channel, shared between the httpd task and the JS task.
+ * Allocated by the httpd task; freed by it once the response is finished. */
+struct MIKHsExchange {
+    SemaphoreHandle_t cmd_ready;  // given by a respond* call, taken by the httpd task
+    httpd_req_t* req;             // live request; valid while the httpd task is parked
+    MIKHsCmd cmd;
+    int status;
+    char status_line[40];  // must outlive the (possibly deferred) header flush
+    MIKHsHeader* headers;
+    size_t header_count;
+    uint8_t* body;  // RESPOND: owned full body
+    size_t body_len;
+    uint8_t* chunk;  // CHUNK: owned chunk buffer
+    size_t chunk_len;
+    bool aborted;  // server stopping: handler closes the response and returns
+};
+
+/* Acknowledgement posted by the httpd task after processing START/CHUNK, so the
+ * JS side can resolve the matching respondStart/respondChunk promise. */
+struct MIKHsAck {
+    MIKHsExchange* ex;
+    bool ok;  // false if the chunk send failed (client gone)
+};
+
+/* A live request tracked on the JS side. `method`/`uri`/`body` are freed once
+ * the request is delivered to JS; `exchange` lives until the response finishes.
+ * `chunk_promise` holds the in-flight respondStart/respondChunk promise. */
+struct MIKHsReq {
+    uint32_t id;
+    MIKHsExchange* exchange;
+    char* method;
+    char* uri;
+    uint8_t* body;
+    size_t body_len;
+    size_t content_length;
+    bool body_too_large;
+    bool delivered;
+    MIKPromise chunk_promise;
+    bool chunk_promise_active;
+    MIKHsReq* next;
+};
+
+/* Message posted from the httpd task to the JS task on request arrival. */
+struct MIKHsMsg {
+    MIKHsExchange* exchange;
+    char* method;
+    char* uri;
+    uint8_t* body;
+    size_t body_len;
+    size_t content_length;
+    bool body_too_large;
+};
+
+struct MIKHttpServerState {
+    httpd_handle_t server;
+    QueueHandle_t request_queue;  // httpd -> JS: request arrivals
+    QueueHandle_t ack_queue;      // httpd -> JS: START/CHUNK acks (backpressure)
+    size_t max_body_size;
+    volatile bool stopping;
+    uint32_t next_id;
+    MIKHsReq* reqs;  // linked list of live requests
+    MIKPromise next_promise;
+    bool next_promise_active;
+};

package/components/mikrojs/mik_http_server.cpp

@@ -0,0 +1,790 @@
+#include <cstring>
+
+#include "esp_http_server.h"
+#include "esp_log.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "mik_http_server_internal.h"
+#include "private.h"
+#include "utils.h"
+
+/* native:http_server — an HTTP server backed by ESP-IDF's esp_http_server.
+ *
+ * esp_http_server runs request handlers on its own (single) task; QuickJS is
+ * single-threaded, so the JS handler must run on the event-loop task. This is
+ * mik_http.cpp reversed: the httpd task parses the request, posts it to a
+ * queue, and BLOCKS on a per-request command channel until the JS side drives
+ * the response. Because the httpd task is single-threaded and blocks per
+ * request, at most one request is in flight at a time — strictly serial.
+ *
+ * Response protocol (JS -> httpd, via the exchange's cmd_ready semaphore):
+ *   - RESPOND: one-shot. status + headers + full body, sent with Content-Length.
+ *   - START / CHUNK / END: a chunked (streamed) response. START and CHUNK are
+ *     acked back through ack_queue so the JS side gets backpressure (it awaits
+ *     each ack before sending the next command); END needs no ack.
+ * The cmd_ready semaphore is binary, so the JS side must wait for the previous
+ * command's ack before posting the next — which the await-per-command flow on
+ * the JS side guarantees.
+ *
+ * Header limitation: esp_http_server cannot enumerate a request's headers (the
+ * only API fetches a header by name), so the JS side exposes lazy by-name
+ * lookups via getHeader(), reading the parked request directly. The httpd task
+ * is blocked waiting for the response, so there is no concurrent writer. */
+
+#define MIK_HS_TAG "native:http_server"
+#define MIK_HS_DEFAULT_MAX_BODY 16384
+/* How often the parked handler wakes to check for server shutdown. */
+#define MIK_HS_ABORT_POLL_MS 250
+
+/* Dynamic module data slot, allocated on first import. The module's data
+ * structures live in mik_http_server_internal.h so on-device tests can drive
+ * the queues and inspect the exchange directly. */
+int mik__http_server_slot = -1;
+
+static inline MIKHttpServerState*& mik__hs_st(MIKRuntime* rt) {
+    return reinterpret_cast<MIKHttpServerState*&>(rt->module_data[mik__http_server_slot]);
+}
+
+/* ── Small helpers ─────────────────────────────────────────────────── */
+
+static const char* mik__hs_reason(int status) {
+    switch (status) {
+        case 200: return "OK";
+        case 201: return "Created";
+        case 202: return "Accepted";
+        case 204: return "No Content";
+        case 301: return "Moved Permanently";
+        case 302: return "Found";
+        case 303: return "See Other";
+        case 304: return "Not Modified";
+        case 307: return "Temporary Redirect";
+        case 308: return "Permanent Redirect";
+        case 400: return "Bad Request";
+        case 401: return "Unauthorized";
+        case 403: return "Forbidden";
+        case 404: return "Not Found";
+        case 405: return "Method Not Allowed";
+        case 409: return "Conflict";
+        case 413: return "Payload Too Large";
+        case 415: return "Unsupported Media Type";
+        case 422: return "Unprocessable Entity";
+        case 429: return "Too Many Requests";
+        case 500: return "Internal Server Error";
+        case 501: return "Not Implemented";
+        case 503: return "Service Unavailable";
+        default: return "Status";
+    }
+}
+
+static const char* mik__hs_method_str(int m) {
+    switch (m) {
+        case HTTP_GET: return "GET";
+        case HTTP_POST: return "POST";
+        case HTTP_PUT: return "PUT";
+        case HTTP_PATCH: return "PATCH";
+        case HTTP_DELETE: return "DELETE";
+        case HTTP_HEAD: return "HEAD";
+        case HTTP_OPTIONS: return "OPTIONS";
+        default: return "GET";
+    }
+}
+
+static void mik__hs_free_headers(MIKHsHeader* h, size_t n) {
+    for (size_t i = 0; i < n; i++) {
+        free(h[i].key);
+        free(h[i].value);
+    }
+    free(h);
+}
+
+static void mik__hs_free_exchange(MIKHsExchange* ex) {
+    if (!ex) return;
+    if (ex->cmd_ready) vSemaphoreDelete(ex->cmd_ready);
+    mik__hs_free_headers(ex->headers, ex->header_count);
+    free(ex->body);
+    free(ex->chunk);
+    delete ex;
+}
+
+static void mik__hs_post_ack(QueueHandle_t q, MIKHsExchange* ex, bool ok) {
+    MIKHsAck a = {ex, ok};
+    xQueueSend(q, &a, portMAX_DELAY);
+}
+
+static void mik__hs_set_head(httpd_req_t* req, MIKHsExchange* ex) {
+    snprintf(ex->status_line, sizeof(ex->status_line), "%d %s", ex->status,
+             mik__hs_reason(ex->status));
+    httpd_resp_set_status(req, ex->status_line);
+    for (size_t i = 0; i < ex->header_count; i++) {
+        httpd_resp_set_hdr(req, ex->headers[i].key, ex->headers[i].value);
+    }
+}
+
+/* ── httpd task: request handler ───────────────────────────────────── */
+
+static esp_err_t mik__hs_handler(httpd_req_t* req) {
+    auto* state = static_cast<MIKHttpServerState*>(req->user_ctx);
+
+    /* Read the request body up to the cap, before handing the request to JS. */
+    uint8_t* body = nullptr;
+    size_t body_len = 0;
+    bool too_large = false;
+    size_t clen = req->content_len;
+    if (clen > 0) {
+        if (clen > state->max_body_size) {
+            too_large = true;
+        } else {
+            body = static_cast<uint8_t*>(malloc(clen));
+            if (!body) {
+                httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "out of memory");
+                return ESP_OK;
+            }
+            size_t off = 0;
+            while (off < clen) {
+                int r = httpd_req_recv(req, reinterpret_cast<char*>(body) + off, clen - off);
+                if (r <= 0) {
+                    free(body);
+                    if (r == HTTPD_SOCK_ERR_TIMEOUT) {
+                        httpd_resp_send_err(req, HTTPD_408_REQ_TIMEOUT, nullptr);
+                    }
+                    return ESP_OK;
+                }
+                off += static_cast<size_t>(r);
+            }
+            body_len = off;
+        }
+    }
+
+    auto* ex = new MIKHsExchange();
+    ex->cmd_ready = xSemaphoreCreateBinary();
+    if (!ex->cmd_ready) {
+        delete ex;
+        free(body);
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, "out of memory");
+        return ESP_OK;
+    }
+    ex->req = req;
+
+    MIKHsMsg msg = {};
+    msg.exchange = ex;
+    msg.method = strdup(mik__hs_method_str(req->method));
+    msg.uri = strdup(req->uri);
+    msg.body = body;
+    msg.body_len = body_len;
+    msg.content_length = clen;
+    msg.body_too_large = too_large;
+
+    if (xQueueSend(state->request_queue, &msg, portMAX_DELAY) != pdTRUE) {
+        free(msg.method);
+        free(msg.uri);
+        free(body);
+        mik__hs_free_exchange(ex);
+        httpd_resp_send_err(req, HTTPD_500_INTERNAL_SERVER_ERROR, nullptr);
+        return ESP_OK;
+    }
+
+    /* Drive the response from JS commands. httpd_stop() can't complete until
+     * this handler returns, so stop() sets `stopping` before calling it. */
+    bool response_started = false;
+    bool aborted = false;
+    bool done = false;
+    while (!done) {
+        bool got = false;
+        while (!got) {
+            if (xSemaphoreTake(ex->cmd_ready, pdMS_TO_TICKS(MIK_HS_ABORT_POLL_MS)) == pdTRUE) {
+                got = true;
+            } else if (state->stopping) {
+                aborted = true;
+                break;
+            }
+        }
+        if (aborted) break;
+
+        switch (ex->cmd) {
+            case MIK_HS_RESPOND:
+                mik__hs_set_head(req, ex);
+                httpd_resp_send(req, reinterpret_cast<const char*>(ex->body),
+                                ex->body ? ex->body_len : 0);
+                response_started = true;
+                done = true;  // JS already removed the req
+                break;
+            case MIK_HS_START:
+                mik__hs_set_head(req, ex);  // flushed on the first send_chunk
+                response_started = true;
+                mik__hs_post_ack(state->ack_queue, ex, true);
+                break;
+            case MIK_HS_CHUNK: {
+                esp_err_t e = httpd_resp_send_chunk(req, reinterpret_cast<const char*>(ex->chunk),
+                                                    ex->chunk_len);
+                free(ex->chunk);
+                ex->chunk = nullptr;
+                ex->chunk_len = 0;
+                mik__hs_post_ack(state->ack_queue, ex, e == ESP_OK);
+                break;
+            }
+            case MIK_HS_END:
+                httpd_resp_send_chunk(req, nullptr, 0);  // terminate the chunked response
+                done = true;  // JS already removed the req
+                break;
+        }
+    }
+
+    if (aborted) {
+        if (response_started) {
+            httpd_resp_send_chunk(req, nullptr, 0);  // close a stream already in progress
+        } else {
+            httpd_resp_set_status(req, "503 Service Unavailable");
+            httpd_resp_send(req, nullptr, 0);
+        }
+    }
+
+    mik__hs_free_exchange(ex);
+    return ESP_OK;
+}
+
+/* ── JS bindings ───────────────────────────────────────────────────── */
+
+/* The request list is a plain singly-linked list with O(n) find/append. Because
+ * the httpd task is single and blocks per request, at most one request is in
+ * flight (plus, briefly, ones the serve loop has yet to drain), so n stays tiny. */
+static MIKHsReq* mik__hs_find_req(MIKHttpServerState* state, uint32_t id) {
+    for (MIKHsReq* r = state->reqs; r; r = r->next) {
+        if (r->id == id) return r;
+    }
+    return nullptr;
+}
+
+static MIKHsReq* mik__hs_find_undelivered(MIKHttpServerState* state) {
+    for (MIKHsReq* r = state->reqs; r; r = r->next) {
+        if (!r->delivered) return r;
+    }
+    return nullptr;
+}
+
+static void mik__hs_remove_req(MIKHttpServerState* state, MIKHsReq* target) {
+    MIKHsReq** pp = &state->reqs;
+    while (*pp) {
+        if (*pp == target) {
+            *pp = target->next;
+            delete target;
+            return;
+        }
+        pp = &(*pp)->next;
+    }
+}
+
+static JSValue mik__hs_build_descriptor(JSContext* ctx, MIKHsReq* r) {
+    JSValue obj = JS_NewObject(ctx);
+    JS_SetPropertyStr(ctx, obj, "id", JS_NewUint32(ctx, r->id));
+    JS_SetPropertyStr(ctx, obj, "method", JS_NewString(ctx, r->method ? r->method : "GET"));
+    JS_SetPropertyStr(ctx, obj, "url", JS_NewString(ctx, r->uri ? r->uri : "/"));
+    JS_SetPropertyStr(ctx, obj, "body",
+                      r->body ? JS_NewUint8ArrayCopy(ctx, r->body, r->body_len)
+                              : JS_NewUint8ArrayCopy(ctx, nullptr, 0));
+    JS_SetPropertyStr(ctx, obj, "bodyTooLarge", JS_NewBool(ctx, r->body_too_large));
+    JS_SetPropertyStr(ctx, obj, "contentLength",
+                      JS_NewInt64(ctx, static_cast<int64_t>(r->content_length)));
+    return obj;
+}
+
+/* Mark a request as delivered to JS and release its request-side buffers (the
+ * descriptor already copied them). `exchange` stays until the response finishes. */
+static void mik__hs_mark_delivered(MIKHsReq* r) {
+    r->delivered = true;
+    free(r->method);
+    r->method = nullptr;
+    free(r->uri);
+    r->uri = nullptr;
+    free(r->body);
+    r->body = nullptr;
+    r->body_len = 0;
+}
+
+static JSValue mik__hs_start(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    CHECK_NOT_NULL(state);
+
+    if (state->server) return mik__result_err_tag(ctx, "AlreadyListening");
+
+    uint32_t port = 80;
+    if (argc > 0) JS_ToUint32(ctx, &port, argv[0]);
+    uint32_t max_body = MIK_HS_DEFAULT_MAX_BODY;
+    if (argc > 1 && JS_IsNumber(argv[1])) JS_ToUint32(ctx, &max_body, argv[1]);
+    state->max_body_size = max_body;
+    state->stopping = false;
+
+    httpd_config_t config = HTTPD_DEFAULT_CONFIG();
+    config.server_port = static_cast<uint16_t>(port);
+    config.uri_match_fn = httpd_uri_match_wildcard;
+
+    httpd_handle_t server = nullptr;
+    esp_err_t err = httpd_start(&server, &config);
+    if (err != ESP_OK) {
+        const char* tag = (err == ESP_ERR_HTTPD_ALLOC_MEM) ? "OutOfMemory" : "StartFailed";
+        return mik__result_err_named(ctx, tag, "failed to start HTTP server: %s",
+                                     esp_err_to_name(err));
+    }
+    state->server = server;
+
+    /* Register one wildcard handler per method; all routing is done in JS. */
+    static const int methods[] = {HTTP_GET,    HTTP_POST, HTTP_PUT,     HTTP_PATCH,
+                                  HTTP_DELETE, HTTP_HEAD, HTTP_OPTIONS};
+    for (int m : methods) {
+        httpd_uri_t uri = {};
+        uri.uri = "/*";
+        uri.method = static_cast<httpd_method_t>(m);
+        uri.handler = mik__hs_handler;
+        uri.user_ctx = state;
+        httpd_register_uri_handler(server, &uri);
+    }
+    return mik__result_ok_void(ctx);
+}
+
+static JSValue mik__hs_stop(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state || !state->server) return JS_UNDEFINED;
+
+    /* Set `stopping` first so any parked handler aborts; httpd_stop() then
+     * blocks until the (single) httpd task returns from the handler. */
+    state->stopping = true;
+    httpd_stop(state->server);
+    state->server = nullptr;
+
+    /* Handlers have all returned and freed their exchanges. Free only the
+     * request-side data; never touch exchange pointers (already freed). Resolve
+     * any in-flight chunk promise with false so a streaming loop ends. */
+    MIKHsMsg msg;
+    while (xQueueReceive(state->request_queue, &msg, 0) == pdTRUE) {
+        free(msg.method);
+        free(msg.uri);
+        free(msg.body);
+    }
+    MIKHsAck ack;
+    while (xQueueReceive(state->ack_queue, &ack, 0) == pdTRUE) { /* discard */ }
+
+    MIKHsReq* r = state->reqs;
+    while (r) {
+        MIKHsReq* next = r->next;
+        if (!r->delivered) {
+            free(r->method);
+            free(r->uri);
+            free(r->body);
+        }
+        if (r->chunk_promise_active) {
+            JSValue v = JS_FALSE;
+            MIK_ResolvePromise(ctx, &r->chunk_promise, 1, &v);
+            r->chunk_promise_active = false;
+        }
+        delete r;
+        r = next;
+    }
+    state->reqs = nullptr;
+
+    /* Wake a pending nextRequest() with a close sentinel so the serve loop ends. */
+    if (state->next_promise_active) {
+        JSValue closed = JS_NewObject(ctx);
+        JS_SetPropertyStr(ctx, closed, "closed", JS_TRUE);
+        MIK_ResolvePromise(ctx, &state->next_promise, 1, &closed);
+        state->next_promise_active = false;
+    }
+    return JS_UNDEFINED;
+}
+
+static JSValue mik__hs_next_request(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state || !state->server) {
+        JSValue closed = JS_NewObject(ctx);
+        JS_SetPropertyStr(ctx, closed, "closed", JS_TRUE);
+        return MIK_NewResolvedPromise(ctx, 1, &closed);
+    }
+    if (state->next_promise_active) {
+        return JS_ThrowTypeError(ctx, "nextRequest already pending");
+    }
+
+    MIKHsReq* r = mik__hs_find_undelivered(state);
+    if (r) {
+        JSValue desc = mik__hs_build_descriptor(ctx, r);
+        mik__hs_mark_delivered(r);
+        return MIK_NewResolvedPromise(ctx, 1, &desc);
+    }
+
+    JSValue promise = MIK_InitPromise(ctx, &state->next_promise);
+    state->next_promise_active = true;
+    return promise;
+}
+
+/* Parse a [[key, value], ...] array into a heap MIKHsHeader array. On any
+ * allocation failure, frees what it built and yields an empty set — a response
+ * with fewer headers is preferable to failing the whole request. */
+static void mik__hs_parse_headers(JSContext* ctx, JSValue arr, MIKHsHeader** out,
+                                  size_t* out_count) {
+    *out = nullptr;
+    *out_count = 0;
+    JSValue len_val = JS_GetPropertyStr(ctx, arr, "length");
+    int64_t len = 0;
+    JS_ToInt64(ctx, &len, len_val);
+    JS_FreeValue(ctx, len_val);
+    if (len <= 0) return;
+
+    auto* headers = static_cast<MIKHsHeader*>(calloc(len, sizeof(MIKHsHeader)));
+    if (!headers) return;
+    size_t count = 0;
+    for (int64_t i = 0; i < len; i++) {
+        JSValue pair = JS_GetPropertyUint32(ctx, arr, i);
+        if (JS_IsArray(pair)) {
+            JSValue k = JS_GetPropertyUint32(ctx, pair, 0);
+            JSValue v = JS_GetPropertyUint32(ctx, pair, 1);
+            const char* ks = JS_ToCString(ctx, k);
+            const char* vs = JS_ToCString(ctx, v);
+            if (ks && vs) {
+                char* kd = strdup(ks);
+                char* vd = strdup(vs);
+                if (kd && vd) {
+                    headers[count].key = kd;
+                    headers[count].value = vd;
+                    count++;
+                } else {
+                    free(kd);
+                    free(vd);
+                }
+            }
+            if (ks) JS_FreeCString(ctx, ks);
+            if (vs) JS_FreeCString(ctx, vs);
+            JS_FreeValue(ctx, k);
+            JS_FreeValue(ctx, v);
+        }
+        JS_FreeValue(ctx, pair);
+    }
+    *out = headers;
+    *out_count = count;
+}
+
+/* respond(id, status, headers, body) — one-shot response. No-op if the request
+ * is unknown (already responded). */
+static JSValue mik__hs_respond(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state) return JS_UNDEFINED;
+
+    uint32_t id;
+    if (JS_ToUint32(ctx, &id, argv[0])) return JS_EXCEPTION;
+    MIKHsReq* r = mik__hs_find_req(state, id);
+    if (!r || !r->delivered || !r->exchange) return JS_UNDEFINED;
+    MIKHsExchange* ex = r->exchange;
+
+    ex->cmd = MIK_HS_RESPOND;
+    int32_t status = 200;
+    JS_ToInt32(ctx, &status, argv[1]);
+    ex->status = status;
+    if (argc > 2 && JS_IsArray(argv[2])) {
+        mik__hs_parse_headers(ctx, argv[2], &ex->headers, &ex->header_count);
+    }
+    if (argc > 3 && !JS_IsUndefined(argv[3]) && !JS_IsNull(argv[3])) {
+        size_t blen;
+        const uint8_t* bptr = JS_GetUint8Array(ctx, &blen, argv[3]);
+        if (bptr && blen > 0) {
+            ex->body = static_cast<uint8_t*>(malloc(blen));
+            if (ex->body) {
+                memcpy(ex->body, bptr, blen);
+                ex->body_len = blen;
+            }
+        }
+    }
+
+    /* Hand ownership to the httpd task and drop our bookkeeping. Do not touch
+     * `ex` after giving cmd_ready — the httpd task may free it immediately. */
+    r->exchange = nullptr;
+    xSemaphoreGive(ex->cmd_ready);
+    mik__hs_remove_req(state, r);
+    return JS_UNDEFINED;
+}
+
+/* respondStart(id, status, headers) — begin a chunked response. Returns a
+ * promise that resolves once status + headers are queued. */
+static JSValue mik__hs_respond_start(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    JSValue undef = JS_UNDEFINED;
+    if (!state) return MIK_NewResolvedPromise(ctx, 1, &undef);
+
+    uint32_t id;
+    if (JS_ToUint32(ctx, &id, argv[0])) return JS_EXCEPTION;
+    MIKHsReq* r = mik__hs_find_req(state, id);
+    if (!r || !r->delivered || !r->exchange || r->chunk_promise_active) {
+        return MIK_NewResolvedPromise(ctx, 1, &undef);
+    }
+    MIKHsExchange* ex = r->exchange;
+
+    ex->cmd = MIK_HS_START;
+    int32_t status = 200;
+    JS_ToInt32(ctx, &status, argv[1]);
+    ex->status = status;
+    if (argc > 2 && JS_IsArray(argv[2])) {
+        mik__hs_parse_headers(ctx, argv[2], &ex->headers, &ex->header_count);
+    }
+
+    JSValue promise = MIK_InitPromise(ctx, &r->chunk_promise);
+    r->chunk_promise_active = true;
+    xSemaphoreGive(ex->cmd_ready);
+    return promise;
+}
+
+/* respondChunk(id, data) — send one body chunk. Returns a promise resolving to
+ * false if the client has gone (caller should stop sending). */
+static JSValue mik__hs_respond_chunk(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    JSValue f = JS_FALSE;
+    if (!state) return MIK_NewResolvedPromise(ctx, 1, &f);
+
+    uint32_t id;
+    if (JS_ToUint32(ctx, &id, argv[0])) return JS_EXCEPTION;
+    MIKHsReq* r = mik__hs_find_req(state, id);
+    if (!r || !r->delivered || !r->exchange || r->chunk_promise_active) {
+        return MIK_NewResolvedPromise(ctx, 1, &f);
+    }
+    MIKHsExchange* ex = r->exchange;
+
+    ex->cmd = MIK_HS_CHUNK;
+    if (argc > 1 && !JS_IsUndefined(argv[1]) && !JS_IsNull(argv[1])) {
+        size_t len;
+        const uint8_t* p = JS_GetUint8Array(ctx, &len, argv[1]);
+        if (p && len > 0) {
+            ex->chunk = static_cast<uint8_t*>(malloc(len));
+            if (ex->chunk) {
+                memcpy(ex->chunk, p, len);
+                ex->chunk_len = len;
+            }
+        }
+    }
+
+    JSValue promise = MIK_InitPromise(ctx, &r->chunk_promise);
+    r->chunk_promise_active = true;
+    xSemaphoreGive(ex->cmd_ready);
+    return promise;
+}
+
+/* respondEnd(id) — finish a chunked response. */
+static JSValue mik__hs_respond_end(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state) return JS_UNDEFINED;
+
+    uint32_t id;
+    if (JS_ToUint32(ctx, &id, argv[0])) return JS_EXCEPTION;
+    MIKHsReq* r = mik__hs_find_req(state, id);
+    if (!r || !r->delivered || !r->exchange) return JS_UNDEFINED;
+    MIKHsExchange* ex = r->exchange;
+
+    if (r->chunk_promise_active) {
+        MIK_FreePromise(ctx, &r->chunk_promise);
+        r->chunk_promise_active = false;
+    }
+    ex->cmd = MIK_HS_END;
+    r->exchange = nullptr;
+    xSemaphoreGive(ex->cmd_ready);
+    mik__hs_remove_req(state, r);
+    return JS_UNDEFINED;
+}
+
+/* getHeader(id, name) — fetch a single request header by name, or undefined.
+ * Reads the parked request directly; the httpd task is blocked in the handler
+ * waiting for the response, so there is no concurrent writer. */
+static JSValue mik__hs_get_header(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state) return JS_UNDEFINED;
+
+    uint32_t id;
+    if (JS_ToUint32(ctx, &id, argv[0])) return JS_EXCEPTION;
+    const char* name = JS_ToCString(ctx, argv[1]);
+    if (!name) return JS_EXCEPTION;
+
+    JSValue result = JS_UNDEFINED;
+    MIKHsReq* r = mik__hs_find_req(state, id);
+    if (r && r->delivered && r->exchange && r->exchange->req) {
+        httpd_req_t* req = r->exchange->req;
+        size_t len = httpd_req_get_hdr_value_len(req, name);
+        if (len > 0) {
+            char* buf = static_cast<char*>(malloc(len + 1));
+            if (buf) {
+                if (httpd_req_get_hdr_value_str(req, name, buf, len + 1) == ESP_OK) {
+                    result = JS_NewStringLen(ctx, buf, len);
+                }
+                free(buf);
+            }
+        }
+    }
+    JS_FreeCString(ctx, name);
+    return result;
+}
+
+/* ── Module init ───────────────────────────────────────────────────── */
+
+static void mik__hs_ensure_initialized(JSContext* ctx) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    if (mik__hs_st(rt)) return;
+
+    auto* state = new MIKHttpServerState();
+    state->server = nullptr;
+    state->request_queue = xQueueCreate(8, sizeof(MIKHsMsg));
+    state->ack_queue = xQueueCreate(8, sizeof(MIKHsAck));
+    CHECK_NOT_NULL(state->request_queue);
+    CHECK_NOT_NULL(state->ack_queue);
+    state->max_body_size = MIK_HS_DEFAULT_MAX_BODY;
+    state->stopping = false;
+    state->next_id = 1;
+    state->reqs = nullptr;
+    state->next_promise_active = false;
+    mik__hs_st(rt) = state;
+}
+
+static int mik__hs_module_init(JSContext* ctx, JSModuleDef* m) {
+    mik__hs_ensure_initialized(ctx);
+    JS_SetModuleExport(ctx, m, "start", JS_NewCFunction(ctx, mik__hs_start, "start", 2));
+    JS_SetModuleExport(ctx, m, "stop", JS_NewCFunction(ctx, mik__hs_stop, "stop", 0));
+    JS_SetModuleExport(ctx, m, "nextRequest",
+                       JS_NewCFunction(ctx, mik__hs_next_request, "nextRequest", 0));
+    JS_SetModuleExport(ctx, m, "respond", JS_NewCFunction(ctx, mik__hs_respond, "respond", 4));
+    JS_SetModuleExport(ctx, m, "respondStart",
+                       JS_NewCFunction(ctx, mik__hs_respond_start, "respondStart", 3));
+    JS_SetModuleExport(ctx, m, "respondChunk",
+                       JS_NewCFunction(ctx, mik__hs_respond_chunk, "respondChunk", 2));
+    JS_SetModuleExport(ctx, m, "respondEnd",
+                       JS_NewCFunction(ctx, mik__hs_respond_end, "respondEnd", 1));
+    JS_SetModuleExport(ctx, m, "getHeader",
+                       JS_NewCFunction(ctx, mik__hs_get_header, "getHeader", 2));
+    return 0;
+}
+
+static JSModuleDef* mik__http_server_init(JSContext* ctx) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    mik__http_server_slot = MIK_AllocModuleSlot(rt);
+
+    JSModuleDef* m = JS_NewCModule(ctx, "native:http_server", mik__hs_module_init);
+    if (!m) return nullptr;
+    JS_AddModuleExport(ctx, m, "start");
+    JS_AddModuleExport(ctx, m, "stop");
+    JS_AddModuleExport(ctx, m, "nextRequest");
+    JS_AddModuleExport(ctx, m, "respond");
+    JS_AddModuleExport(ctx, m, "respondStart");
+    JS_AddModuleExport(ctx, m, "respondChunk");
+    JS_AddModuleExport(ctx, m, "respondEnd");
+    JS_AddModuleExport(ctx, m, "getHeader");
+    return m;
+}
+
+/* ── Event loop consumption ────────────────────────────────────────── */
+
+void mik__http_server_consume(JSContext* ctx) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state) return;
+
+    /* Resolve START/CHUNK acks (backpressure) before delivering new requests. */
+    MIKHsAck ack;
+    while (xQueueReceive(state->ack_queue, &ack, 0) == pdTRUE) {
+        for (MIKHsReq* r = state->reqs; r; r = r->next) {
+            if (r->exchange == ack.ex && r->chunk_promise_active) {
+                JSValue v = JS_NewBool(ctx, ack.ok);
+                MIK_ResolvePromise(ctx, &r->chunk_promise, 1, &v);
+                r->chunk_promise_active = false;
+                break;
+            }
+        }
+    }
+
+    MIKHsMsg msg;
+    while (xQueueReceive(state->request_queue, &msg, 0) == pdTRUE) {
+        auto* r = new MIKHsReq();
+        r->id = state->next_id++;
+        r->exchange = msg.exchange;
+        r->method = msg.method;
+        r->uri = msg.uri;
+        r->body = msg.body;
+        r->body_len = msg.body_len;
+        r->content_length = msg.content_length;
+        r->body_too_large = msg.body_too_large;
+        r->delivered = false;
+        r->chunk_promise_active = false;
+        r->next = nullptr;
+
+        if (!state->reqs) {
+            state->reqs = r;
+        } else {
+            MIKHsReq* t = state->reqs;
+            while (t->next) t = t->next;
+            t->next = r;
+        }
+
+        if (state->next_promise_active) {
+            JSValue desc = mik__hs_build_descriptor(ctx, r);
+            mik__hs_mark_delivered(r);
+            MIK_ResolvePromise(ctx, &state->next_promise, 1, &desc);
+            state->next_promise_active = false;
+        }
+    }
+}
+
+void mik__http_server_destroy(JSContext* ctx) {
+    MIKRuntime* rt = MIK_GetRuntime(ctx);
+    CHECK_NOT_NULL(rt);
+    MIKHttpServerState* state = mik__hs_st(rt);
+    if (!state) return;
+
+    if (state->server) {
+        state->stopping = true;
+        httpd_stop(state->server);
+        state->server = nullptr;
+    }
+
+    MIKHsMsg msg;
+    while (xQueueReceive(state->request_queue, &msg, 0) == pdTRUE) {
+        free(msg.method);
+        free(msg.uri);
+        free(msg.body);
+    }
+    MIKHsAck ack;
+    while (xQueueReceive(state->ack_queue, &ack, 0) == pdTRUE) { /* discard */ }
+
+    MIKHsReq* r = state->reqs;
+    while (r) {
+        MIKHsReq* next = r->next;
+        if (!r->delivered) {
+            free(r->method);
+            free(r->uri);
+            free(r->body);
+        }
+        if (r->chunk_promise_active) MIK_FreePromise(ctx, &r->chunk_promise);
+        delete r;
+        r = next;
+    }
+    state->reqs = nullptr;
+
+    if (state->next_promise_active) {
+        MIK_FreePromise(ctx, &state->next_promise);
+        state->next_promise_active = false;
+    }
+
+    vQueueDelete(state->request_queue);
+    vQueueDelete(state->ack_queue);
+    delete state;
+    mik__hs_st(rt) = nullptr;
+}
+
+MIK_REGISTER_MODULE(http_server, "native:http_server", mik__http_server_init,
+                    mik__http_server_consume, mik__http_server_destroy)

package/components/mikrojs/mik_main.cpp

@@ -347,15 +347,21 @@ void MIK_Main(void) {
          * (USB-Serial/JTAG). `printf` goes to newlib stdio, which
          * ESP-IDF routes to UART0 and is invisible over USB. */
         const char* core_word = chip_info.cores == 1 ? "core" : "cores";
+        const MIKPlatform* plat = MIK_GetPlatform();
+        const char* dev_id = plat->get_device_id ? plat->get_device_id() : nullptr;
         char banner[160];
         int off = 0;
 #ifdef MIK_FW_VERSION
-        off += snprintf(banner + off, sizeof(banner) - off, "Mikro.js v%s on %s, %d %s",
-                        MIK_FW_VERSION, CONFIG_IDF_TARGET, chip_info.cores, core_word);
+        off += snprintf(banner + off, sizeof(banner) - off, "Mikro.js v%s on %s", MIK_FW_VERSION,
+                        CONFIG_IDF_TARGET);
 #else
-        off += snprintf(banner + off, sizeof(banner) - off, "Mikro.js on %s, %d %s",
-                        CONFIG_IDF_TARGET, chip_info.cores, core_word);
+        off += snprintf(banner + off, sizeof(banner) - off, "Mikro.js on %s", CONFIG_IDF_TARGET);
 #endif
+        /* Stable per-board device id (chip MAC as Crockford Base32). */
+        if (dev_id && dev_id[0]) {
+            off += snprintf(banner + off, sizeof(banner) - off, " (%s)", dev_id);
+        }
+        off += snprintf(banner + off, sizeof(banner) - off, ", %d %s", chip_info.cores, core_word);
         if (has_wifi || has_bt || has_ble) {
             off += snprintf(banner + off, sizeof(banner) - off, ", ");
             bool first = true;

package/components/mikrojs/platform_esp32.cpp

@@ -148,7 +148,12 @@ static const char* esp32_get_device_id(void) {
     static char id[11] = {0};  /* 6 bytes (48 bits) -> 10 x 5-bit chars + NUL */
     if (id[0] == '\0') {
         uint8_t m[6];
-        esp_efuse_mac_get_default(m);
+        /* Use the 48-bit base MAC, NOT esp_efuse_mac_get_default(): on 802.15.4
+         * chips (C6/H2) the factory MAC is an 8-byte EUI-64, so that call writes
+         * 8 bytes (overflowing this 6-byte buffer) and a 6-byte read yields the
+         * OUI+FF:FE prefix rather than a unique chip id. esp_read_mac(ESP_MAC_BASE)
+         * returns the proper 48-bit base MAC on every target. */
+        esp_read_mac(m, ESP_MAC_BASE);
         /* Pack 6 bytes into a 48-bit value, then extract 5 bits at a time
          * from the most significant end. */
         uint64_t v = ((uint64_t)m[0] << 40) | ((uint64_t)m[1] << 32) |

package/components/mikrojs/test/CMakeLists.txt

@@ -5,6 +5,7 @@ set(_MIK_TEST_SRCS
     fs_js_test.cpp
     fs_pub_test.cpp
     http_test.cpp
+    http_server_test.cpp
     i2c_test.cpp
     modules_extended_test.cpp
     modules_test.cpp

package/components/mikrojs/test/http_server_test.cpp

@@ -0,0 +1,216 @@
+#include <cstring>
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "mik_http_server_internal.h"
+#include "mikrojs.h"
+#include "private.h"
+#include "quickjs.h"
+#include "unity.h"
+#include "utils.h"
+
+/* Access the http_server module slot and consume function from
+ * mik_http_server.cpp. These tests drive the module's queues directly — no
+ * real esp_http_server / network — the same approach as http_test.cpp. */
+extern int mik__http_server_slot;
+extern void mik__http_server_consume(JSContext* ctx);
+
+static inline MIKHttpServerState*& mik__hs(MIKRuntime* r) {
+    return reinterpret_cast<MIKHttpServerState*&>(r->module_data[mik__http_server_slot]);
+}
+
+/* ── Test scaffolding (same teardown-before-assert convention as http_test) ── */
+
+static MIKRuntime* rt;
+static JSContext* ctx;
+
+static void setup() {
+    rt = MIK_NewRuntime();
+    ctx = MIK_GetJSContext(rt);
+}
+
+static void teardown() { MIK_FreeRuntime(rt); }
+
+static JSValue eval_module(const char* code) {
+    JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test", code, strlen(code));
+    if (!JS_IsException(ret)) {
+        JS_FreeValue(ctx, ret);
+        mik__execute_jobs(ctx);
+    }
+    return ret;
+}
+
+static void ensure_initialized() {
+    const char* code = "import { nextRequest } from 'native:http_server';";
+    JSValue ret = MIK_EvalModuleContent(ctx, "mikrojs/test", code, strlen(code));
+    if (!JS_IsException(ret)) {
+        JS_FreeValue(ctx, ret);
+        mik__execute_jobs(ctx);
+    }
+}
+
+static void read_global_string(const char* key, char* out, size_t out_len) {
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue v = JS_GetPropertyStr(ctx, global, key);
+    const char* s = JS_ToCString(ctx, v);
+    if (s) {
+        strncpy(out, s, out_len - 1);
+        out[out_len - 1] = '\0';
+        JS_FreeCString(ctx, s);
+    } else {
+        out[0] = '\0';
+    }
+    JS_FreeValue(ctx, v);
+    JS_FreeValue(ctx, global);
+}
+
+static bool read_global_bool(const char* key) {
+    JSValue global = JS_GetGlobalObject(ctx);
+    JSValue v = JS_GetPropertyStr(ctx, global, key);
+    bool b = JS_ToBool(ctx, v);
+    JS_FreeValue(ctx, v);
+    JS_FreeValue(ctx, global);
+    return b;
+}
+
+/* Push a request the way the httpd handler would: allocate an exchange with a
+ * command semaphore, hand method/uri ownership to the module via the queue. The
+ * exchange is returned so the test can inspect what respond() wrote and free it
+ * (no real httpd task exists to consume cmd_ready and free it). */
+static MIKHsExchange* push_request(const char* method, const char* uri) {
+    auto* ex = new MIKHsExchange();  // value-initialized: all fields zero/null
+    ex->cmd_ready = xSemaphoreCreateBinary();
+    ex->req = nullptr;
+
+    MIKHsMsg msg = {};
+    msg.exchange = ex;
+    msg.method = strdup(method);
+    msg.uri = strdup(uri);
+    xQueueSend(mik__hs(rt)->request_queue, &msg, 0);
+    return ex;
+}
+
+static void free_exchange(MIKHsExchange* ex) {
+    if (ex->cmd_ready) {
+        xSemaphoreTake(ex->cmd_ready, 0);  // drain the give from respond()
+        vSemaphoreDelete(ex->cmd_ready);
+    }
+    for (size_t i = 0; i < ex->header_count; i++) {
+        free(ex->headers[i].key);
+        free(ex->headers[i].value);
+    }
+    free(ex->headers);
+    free(ex->body);
+    free(ex->chunk);
+    delete ex;
+}
+
+/* ── Tests ─────────────────────────────────────────────────────────── */
+
+TEST_CASE("native:http_server exports the expected functions", "[httpd]") {
+    setup();
+    JSValue ret = eval_module(R"(
+        import { start, stop, nextRequest, respond,
+                 respondStart, respondChunk, respondEnd, getHeader } from "native:http_server";
+        globalThis.__t = [start, stop, nextRequest, respond,
+                          respondStart, respondChunk, respondEnd, getHeader]
+                          .every((f) => typeof f === "function") ? "ok" : "bad";
+    )");
+    bool evalOk = !JS_IsException(ret);
+    char t[8];
+    read_global_string("__t", t, sizeof(t));
+    teardown();
+
+    TEST_ASSERT_TRUE_MESSAGE(evalOk, "module eval should not throw");
+    TEST_ASSERT_EQUAL_STRING("ok", t);
+}
+
+TEST_CASE("http_server consume with no messages is a no-op", "[httpd]") {
+    setup();
+    ensure_initialized();
+    mik__http_server_consume(ctx);
+    bool reqsEmpty = (mik__hs(rt)->reqs == nullptr);
+    teardown();
+
+    TEST_ASSERT_TRUE(reqsEmpty);
+}
+
+TEST_CASE("nextRequest delivers method/url and respond fills the exchange", "[httpd]") {
+    setup();
+    ensure_initialized();
+
+    MIKHsExchange* ex = push_request("GET", "/hello?x=1");
+
+    eval_module(R"(
+        import { nextRequest, respond } from 'native:http_server';
+        globalThis.__method = '';
+        globalThis.__url = '';
+        (async () => {
+            const r = await nextRequest();
+            globalThis.__method = r.method;
+            globalThis.__url = r.url;
+            respond(r.id, 200, [['X-Test', 'yes']], new Uint8Array([65, 66, 67]));
+        })();
+    )");
+
+    mik__http_server_consume(ctx);
+    mik__execute_jobs(ctx);
+
+    char method[16], url[32];
+    read_global_string("__method", method, sizeof(method));
+    read_global_string("__url", url, sizeof(url));
+
+    int status = ex->status;
+    size_t bodyLen = ex->body_len;
+    char body[8] = {};
+    if (ex->body && bodyLen < sizeof(body)) memcpy(body, ex->body, bodyLen);
+    size_t headerCount = ex->header_count;
+
+    free_exchange(ex);
+    teardown();
+
+    TEST_ASSERT_EQUAL_STRING("GET", method);
+    TEST_ASSERT_EQUAL_STRING("/hello?x=1", url);
+    TEST_ASSERT_EQUAL_INT(200, status);
+    TEST_ASSERT_EQUAL_UINT(3, bodyLen);
+    TEST_ASSERT_EQUAL_STRING("ABC", body);
+    TEST_ASSERT_EQUAL_UINT(1, headerCount);
+}
+
+/* Regression: a response with no body (e.g. a 303 redirect) must not throw in
+ * native respond(). Before the fix, respond() called JS_GetUint8Array on an
+ * undefined body and left a pending TypeError. */
+TEST_CASE("respond tolerates a bodyless response", "[httpd]") {
+    setup();
+    ensure_initialized();
+
+    MIKHsExchange* ex = push_request("POST", "/save");
+
+    eval_module(R"(
+        import { nextRequest, respond } from 'native:http_server';
+        globalThis.__threw = false;
+        (async () => {
+            const r = await nextRequest();
+            try {
+                respond(r.id, 303, [['location', '/']], undefined);
+            } catch (e) {
+                globalThis.__threw = true;
+            }
+        })();
+    )");
+
+    mik__http_server_consume(ctx);
+    mik__execute_jobs(ctx);
+
+    bool threw = read_global_bool("__threw");
+    int status = ex->status;
+    bool bodyNull = (ex->body == nullptr);
+
+    free_exchange(ex);
+    teardown();
+
+    TEST_ASSERT_FALSE_MESSAGE(threw, "bodyless respond must not throw");
+    TEST_ASSERT_EQUAL_INT(303, status);
+    TEST_ASSERT_TRUE_MESSAGE(bodyNull, "bodyless respond leaves the body unset");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/firmware",
-  "version": "0.11.0",
+  "version": "0.12.0-next.9.g2e06437",
   "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.11.0",
-    "@mikrojs/quickjs": "0.11.0"
+    "@mikrojs/native": "0.12.0-next.9.g2e06437",
+    "@mikrojs/quickjs": "0.12.0-next.9.g2e06437"
   },
   "engines": {
     "node": ">=24.0.0"