@mikrojs/native 0.20.1 → 0.21.0-next.20260913195055

package/src/mik_ota_client.cpp

@@ -354,10 +354,13 @@ bool MIKOtaClient::Enrollment(std::string* out_url, std::string* out_bearer) con
     char url[256] = {};
     char bearer[128] = {};
     if (!env_ || !env_->kv_get_str) return false;
-    if (!env_->kv_get_str(env_->opaque, "ota.registry", url, sizeof(url)) || url[0] == '\0') {
+    /* A read that failed reads as "not enrolled", which only makes the client
+     * skip the round. Erring the other way would send a half-read update key. */
+    if (env_->kv_get_str(env_->opaque, "ota.registry", url, sizeof(url)) != MIK_OTA_KV_OK ||
+        url[0] == '\0') {
         return false;
     }
-    if (!env_->kv_get_str(env_->opaque, "ota.updateKey", bearer, sizeof(bearer)) ||
+    if (env_->kv_get_str(env_->opaque, "ota.updateKey", bearer, sizeof(bearer)) != MIK_OTA_KV_OK ||
         bearer[0] == '\0') {
         return false;
     }

package/src/mik_ota_policy.cpp

@@ -13,6 +13,11 @@ namespace mikrojs {
 /* Staging attempts for one url before a checksum is abandoned. */
 constexpr int32_t MIK__OTA_MAX_TRIES = 3;
 
+/* The contract is 64 lowercase hex (see decline(), which enforces the format).
+ * Only the length is checked here, because a shorter checksum round-trips
+ * fine and the registry is free to use one. */
+constexpr size_t MIK__OTA_CHECKSUM_MAX = 64;
+
 const char* mik__ota_outcome_to_str(MIKOtaApplyOutcome outcome) {
     switch (outcome) {
         case MIKOtaApplyOutcome::kStaged:
@@ -48,10 +53,23 @@ std::string url_digest(const std::string& url) {
 
 }  // namespace
 
+MIKOtaKvStatus MIKOtaStore::ReadStr(const char* key, char* out, size_t max_len) const {
+    if (!env_ || !env_->kv_get_str) return MIK_OTA_KV_ABSENT;
+    MIKOtaKvStatus status = env_->kv_get_str(env_->opaque, key, out, max_len);
+    if (status == MIK_OTA_KV_ERROR) read_failed_ = true;
+    return status;
+}
+
+MIKOtaKvStatus MIKOtaStore::ReadI32(const char* key, int32_t* out) const {
+    if (!env_ || !env_->kv_get_i32) return MIK_OTA_KV_ABSENT;
+    MIKOtaKvStatus status = env_->kv_get_i32(env_->opaque, key, out);
+    if (status == MIK_OTA_KV_ERROR) read_failed_ = true;
+    return status;
+}
+
 bool MIKOtaStore::UrlMatches(const std::string& url) const {
-    if (!env_ || !env_->kv_get_str) return false;
     char buf[17] = {};
-    if (!env_->kv_get_str(env_->opaque, "ota.url", buf, sizeof(buf))) return false;
+    if (ReadStr("ota.url", buf, sizeof(buf)) != MIK_OTA_KV_OK) return false;
     return url_digest(url) == buf;
 }
 
@@ -61,9 +79,8 @@ void MIKOtaStore::SetUrl(const std::string& url) {
 }
 
 std::string MIKOtaStore::GetAttempt() const {
-    if (!env_ || !env_->kv_get_str) return "";
     char buf[128] = {};
-    if (env_->kv_get_str(env_->opaque, "ota.att", buf, sizeof(buf))) {
+    if (ReadStr("ota.att", buf, sizeof(buf)) == MIK_OTA_KV_OK) {
         return buf;
     }
     return "";
@@ -75,12 +92,14 @@ void MIKOtaStore::SetAttempt(const std::string& checksum) {
 }
 
 int32_t MIKOtaStore::GetTries() const {
-    if (!env_ || !env_->kv_get_i32) return 0;
     int32_t val = 0;
-    if (env_->kv_get_i32(env_->opaque, "ota.tries", &val)) {
+    if (ReadI32("ota.tries", &val) == MIK_OTA_KV_OK) {
         return val;
     }
-    return 0;
+    /* An unreadable budget counts as spent, which is what stops the attempt in
+     * apply_begin. Defaulting to "fully available" is the one mistake here that
+     * ends in a build reinstalling itself forever. */
+    return read_failed_ ? MIK__OTA_MAX_TRIES : 0;
 }
 
 void MIKOtaStore::SetTries(int32_t n) {
@@ -89,9 +108,8 @@ void MIKOtaStore::SetTries(int32_t n) {
 }
 
 std::string MIKOtaStore::GetBad() const {
-    if (!env_ || !env_->kv_get_str) return "";
     char buf[128] = {};
-    if (env_->kv_get_str(env_->opaque, "ota.bad", buf, sizeof(buf))) {
+    if (ReadStr("ota.bad", buf, sizeof(buf)) == MIK_OTA_KV_OK) {
         return buf;
     }
     return "";
@@ -103,9 +121,8 @@ void MIKOtaStore::SetBad(const std::string& checksum) {
 }
 
 bool MIKOtaStore::GetInFlight() const {
-    if (!env_ || !env_->kv_get_i32) return false;
     int32_t val = 0;
-    if (env_->kv_get_i32(env_->opaque, "ota.inflight", &val)) {
+    if (ReadI32("ota.inflight", &val) == MIK_OTA_KV_OK) {
         return val == 1;
     }
     return false;
@@ -117,16 +134,15 @@ void MIKOtaStore::SetInFlight(bool in_flight) {
 }
 
 bool MIKOtaStore::GetDecline(MIKOtaDeclineRecord* out) const {
-    if (!env_ || !env_->kv_get_str) return false;
-    if (!env_->kv_get_str(env_->opaque, "ota.declined", out->checksum, sizeof(out->checksum)) ||
+    if (ReadStr("ota.declined", out->checksum, sizeof(out->checksum)) != MIK_OTA_KV_OK ||
         out->checksum[0] == '\0') {
         return false;
     }
-    if (!env_->kv_get_str(env_->opaque, "ota.declReason", out->reason, sizeof(out->reason)) ||
+    if (ReadStr("ota.declReason", out->reason, sizeof(out->reason)) != MIK_OTA_KV_OK ||
         out->reason[0] == '\0') {
         return false;
     }
-    if (!env_->kv_get_str(env_->opaque, "ota.declDetail", out->detail, sizeof(out->detail))) {
+    if (ReadStr("ota.declDetail", out->detail, sizeof(out->detail)) != MIK_OTA_KV_OK) {
         out->detail[0] = '\0';
     }
     return true;
@@ -181,6 +197,18 @@ bool mik__ota_parse_offer(const char* url, const char* checksum, int64_t size, b
         return false;
     }
 
+    /* ota.att and ota.bad read back through a 128-byte buffer, and a stored
+     * value too long to decode reports a failed read, not an absent one. That
+     * stops every later offer, including a good one, and nothing rewrites the
+     * key. Bound it here, at the one place untrusted registry fields become an
+     * offer, rather than letting an unreadable value into the store. */
+    if (strlen(checksum) > MIK__OTA_CHECKSUM_MAX) {
+        if (out_warn_reason) {
+            *out_warn_reason = "checksum too long";
+        }
+        return false;
+    }
+
     if (size <= 0) {
         if (out_warn_reason) {
             *out_warn_reason = "invalid size";
@@ -202,7 +230,10 @@ MIKOtaReconcileOutcome mik__ota_policy_reconcile(const MIKOtaEnv* env) {
     MIKOtaStore store(env);
     if (store.GetInFlight()) {
         store.SetInFlight(false);
-    } else {
+    } else if (!store.ReadFailed()) {
+        /* Only a boot we can prove was clean hands the budget back. An
+         * unreadable flag reads as "not in flight", and the attempt it would
+         * forget is the one that just took the device down. */
         store.SetTries(0);
     }
     MIKOtaReconcileOutcome outcome = {};
@@ -345,7 +376,23 @@ bool mik__ota_policy_apply_begin(const MIKOtaEnv* env, const MIKOtaOffer& offer,
 
     // (d) device has given up on this build
     MIKOtaStore store(env);
-    if (!offer.checksum.empty() && offer.checksum == store.GetBad()) {
+    std::string bad = store.GetBad();
+    bool url_matches = store.UrlMatches(offer.url);
+    std::string attempt = store.GetAttempt();
+
+    // Read first, then decide: every value above reads as absent when the store
+    // could not answer, and each of those defaults grants the attempt
+    // something: no abandoned build, a url that never matched (a fresh
+    // budget). A store this device cannot read is one it has no business
+    // re-keying, and the heap pressure behind the failure is no state to start
+    // a download in anyway. Nothing is written here, so the next boot decides
+    // on the real values.
+    if (store.ReadFailed()) {
+        if (out_outcome) *out_outcome = MIKOtaApplyOutcome::kExhausted;
+        return true;
+    }
+
+    if (!offer.checksum.empty() && offer.checksum == bad) {
         if (out_outcome) *out_outcome = MIKOtaApplyOutcome::kAbandoned;
         return true;
     }
@@ -354,7 +401,7 @@ bool mik__ota_policy_apply_begin(const MIKOtaEnv* env, const MIKOtaOffer& offer,
     // attempts against this exact build at this exact url; the checksum is not
     // abandoned, because everything counted here is transient by construction
     // (a corrupt build is abandoned in apply_end instead).
-    if (!store.UrlMatches(offer.url) || offer.checksum != store.GetAttempt()) {
+    if (!url_matches || offer.checksum != attempt) {
         store.SetUrl(offer.url);
         store.SetAttempt(offer.checksum);
         store.SetTries(0);

package/src/mik_result.cpp

@@ -16,7 +16,7 @@
  *
  * Motivation: the previous TS implementation (runtime/result/result.ts)
  * compiled to ~7 KB of per-runtime JS heap because every public runtime
- * module (mikrojs/pin, mikrojs/wifi, …) top-level-imported it, so both
+ * module (mikrojs/wifi, mikrojs/fs, …) top-level-imported it, so both
  * OkImpl/ErrImpl class bodies and their ~16 method closures were paid once
  * per runtime whether the app used them or not.  Moving the prototype to C
  * keeps the fluent API while collapsing that to a single shared proto +
@@ -230,20 +230,21 @@ static JSValue js_result_or_default(JSContext* ctx, JSValue this_val, int argc,
     return argc > 0 ? JS_DupValue(ctx, argv[0]) : JS_UNDEFINED;
 }
 
-/* .orPanic(msg) — value if ok, else throw an Error(name=PanicError, cause=error) */
+/* .orPanic(msg?) — value if ok, else throw an Error(name=PanicError, cause=error).
+ * With no message the report reads "PanicError" followed by the cause. */
 static JSValue js_result_or_panic(JSContext* ctx, JSValue this_val, int argc, JSValue* argv) {
     if (result_is_ok(ctx, this_val)) {
         return result_get_value(ctx, this_val);
     }
-    JSValue panic = JS_NewError(ctx);
-    const char* msg = NULL;
-    if (argc > 0) {
+    const char* msg = "";
+    bool has_msg = argc > 0 && !JS_IsUndefined(argv[0]);
+    if (has_msg) {
         msg = JS_ToCString(ctx, argv[0]);
+        if (!msg) return JS_EXCEPTION;
     }
-    JS_DefinePropertyValueStr(ctx, panic, "message",
-                              JS_NewString(ctx, msg ? msg : "panic"),
-                              JS_PROP_C_W_E);
-    if (msg) JS_FreeCString(ctx, msg);
+    JSValue panic = JS_NewError(ctx);
+    JS_DefinePropertyValueStr(ctx, panic, "message", JS_NewString(ctx, msg), JS_PROP_C_W_E);
+    if (has_msg) JS_FreeCString(ctx, msg);
     JS_DefinePropertyValueStr(ctx, panic, "name", JS_NewString(ctx, "PanicError"),
                               JS_PROP_C_W_E);
     JSValue cause = result_get_error(ctx, this_val);

package/src/mikrojs.cpp

@@ -1211,20 +1211,33 @@ int MIK_RunEntryErr(MIKRuntime* mik_rt, const char* entry, char* err_buf, size_t
             rejected = true;
         }
     }
-    if (failed && err_buf && err_buf_size > 0) {
-        /* Capture the failure's string form for the caller. Without an
-         * err_buf the pending exception is intentionally left on ctx,
-         * matching MIK_RunEntry's historical behavior. */
+    if (failed) {
         JSValue exc = rejected ? JS_PromiseResult(ctx, result) : JS_GetException(ctx);
-        const char* msg = JS_ToCString(ctx, exc);
-        if (msg) {
-            snprintf(err_buf, err_buf_size, "%s", msg);
-            JS_FreeCString(ctx, msg);
-        } else {
-            /* Stringifying the exception itself threw (e.g. OOM) — drop
-             * the secondary exception so it can't leak into later evals. */
-            JSValue stray = JS_GetException(ctx);
-            JS_FreeValue(ctx, stray);
+        if (err_buf && err_buf_size > 0) {
+            /* Capture the failure's string form for the caller. */
+            const char* msg = JS_ToCString(ctx, exc);
+            if (msg) {
+                snprintf(err_buf, err_buf_size, "%s", msg);
+                JS_FreeCString(ctx, msg);
+            } else {
+                /* Stringifying the exception itself threw (e.g. OOM) — drop
+                 * the secondary exception so it can't leak into later evals. */
+                JSValue stray = JS_GetException(ctx);
+                JS_FreeValue(ctx, stray);
+            }
+        }
+        /* A synchronous throw (a missing import, a syntax error) exists only
+         * as the pending exception consumed above, so report it here the way
+         * MIK_Loop reports one it finds pending: handler, dump, stop. Left
+         * unreported, the device idles in silence. A rejected eval promise is
+         * still queued for the loop's rejection flush, which reports it the
+         * same way. */
+        if (!rejected) {
+            if (mik_rt->error_handler_fn) {
+                mik_rt->error_handler_fn(ctx, exc, mik_rt->error_handler_opaque);
+            }
+            mik_dump_error1(ctx, exc);
+            MIK_Stop(mik_rt);
         }
         JS_FreeValue(ctx, exc);
     }

package/src/modules.cpp

@@ -234,8 +234,9 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
             }
         }
         /* Native module not found — this is a device-only module that isn't
-         * available in the current build (e.g. running on desktop). */
-        JS_ThrowReferenceError(ctx, "Native module '%s' is not available", module_name);
+         * available in the current build (e.g. running on desktop). Same
+         * wording as every other unresolvable specifier (and browsers). */
+        JS_ThrowTypeError(ctx, "Failed to resolve module specifier '%s'", module_name);
         return nullptr;
     }
 
@@ -250,11 +251,22 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
         } c_modules[] = {
             {"mikro/http/helpers", mik__http_helpers_load},
             {"mikro/http/request", mik__http_request_load},
+            {"mikro/observable/operators", mik__observable_operators_load},
             {"mikro/wifi", mik__wifi_client_load},
         };
         for (const auto& cm : c_modules) {
             if (strcmp(cm.name, module_name) == 0) return cm.load(ctx);
         }
+        /* Platform C modules registered under their public name (mikro/gpio on ESP-IDF). */
+        for (mik_module_desc_t* d = mik__module_registry_head; d != nullptr; d = d->next) {
+            if (strcmp(d->name, module_name) == 0) {
+                JSModuleDef* reg_m = d->init(ctx);
+                if (reg_m && mik_rt && d->consume) {
+                    MIK_RegisterLoopConsumer(mik_rt, d->consume, d->destroy);
+                }
+                return reg_m;
+            }
+        }
         JSModuleDef* builtin_m = mik__load_builtin(ctx, module_name);
         if (builtin_m) return builtin_m;
         /* mik__load_builtin returns NULL either because the module isn't in
@@ -265,8 +277,7 @@ static JSModuleDef* mik_module_loader_inner(JSContext* ctx, const char* module_n
          * returns JS_UNINITIALIZED from an empty exception slot, and
          * re-throwing that surfaced as a bare "[uninitialized]" error. */
         if (!JS_HasException(ctx)) {
-            JS_ThrowReferenceError(ctx, "Builtin module '%s' is not available in this build",
-                                   module_name);
+            JS_ThrowTypeError(ctx, "Failed to resolve module specifier '%s'", module_name);
         }
         return NULL;
     }
@@ -996,7 +1007,7 @@ JSValue mik__load_module_ns(JSContext* ctx, const char* importer, const char* sp
         JSValue p = JS_LoadModule(ctx, importer, specifier);
         if (JS_IsException(p)) {
             /* Propagate the loader's real error (e.g. a syntax error in a
-             * virtual stub), not a generic not-available message. */
+             * virtual stub), not a generic resolution failure. */
             JS_FreeAtom(ctx, name);
             return p;
         }
@@ -1016,7 +1027,7 @@ JSValue mik__load_module_ns(JSContext* ctx, const char* importer, const char* sp
     }
     JS_FreeAtom(ctx, name);
     if (!m) {
-        return JS_ThrowReferenceError(ctx, "Native module '%s' is not available", specifier);
+        return JS_ThrowTypeError(ctx, "Failed to resolve module specifier '%s'", specifier);
     }
     /* 5 == EVALUATED; quickjs.h documents the numbering but exports no enum. */
     if (require_evaluated && JS_GetModuleStatus(ctx, m) != 5) {

package/src/timers.cpp

@@ -155,9 +155,13 @@ void mik__timers_consume(JSContext* ctx) {
             if (due_count < MIK_MAX_DUE_TIMERS) {
                 due_ids[due_count++] = entry.id;
             }
-            // Update interval deadlines before executing callbacks
+            // Drift-free: advance from the previous deadline, not from now, so the rate
+            // stays exact. After a stall of a whole period, resume from now; never burst.
             if (entry.is_interval) {
-                entry.next_deadline = entry.timeout + platform->get_boot_us();
+                entry.next_deadline += entry.timeout;
+                if (entry.next_deadline <= now) {
+                    entry.next_deadline = now + entry.timeout;
+                }
             }
         }
     }

package/src/utils.cpp

@@ -1,6 +1,7 @@
 #include "mikrojs/utils.h"
 
 #include <errno.h>
+#include <math.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -58,6 +59,111 @@ void mik__print_error_line(const char* fmt, ...) {
     MIK_GetPlatform()->stderr_write(buf, len);
 }
 
+JSAtom mik__async_iterator_atom(JSContext* ctx) {
+    JSValue g = JS_GetGlobalObject(ctx);
+    JSValue sym_ctor = JS_GetPropertyStr(ctx, g, "Symbol");
+    JSValue sym = JS_GetPropertyStr(ctx, sym_ctor, "asyncIterator");
+    JSAtom atom = JS_ValueToAtom(ctx, sym);
+    JS_FreeValue(ctx, sym);
+    JS_FreeValue(ctx, sym_ctor);
+    JS_FreeValue(ctx, g);
+    return atom;
+}
+
+void mik__warn_after_end(bool* warned, const char* owner, int id, const char* call,
+                         const char* resource) {
+    if (*warned) return;
+    *warned = true;
+    mik__print_error_line("%s %d: %s after end(); the handle no longer owns the %s", owner, id,
+                          call, resource);
+}
+
+int mik__to_int_arg(JSContext* ctx, JSValueConst v, const char* name, int32_t* out) {
+    double d = 0;
+    if (!JS_IsNumber(v) || JS_ToFloat64(ctx, &d, v) || trunc(d) != d || fabs(d) > INT32_MAX) {
+        /* Reject NaN and fractions instead of truncating them. */
+        JS_ThrowTypeError(ctx, "%s must be an integer", name);
+        return -1;
+    }
+    *out = (int32_t)d;
+    return 0;
+}
+
+int mik__to_number_arg(JSContext* ctx, JSValueConst v, const char* name, double* out) {
+    if (!JS_IsNumber(v) || JS_ToFloat64(ctx, out, v)) {
+        JS_ThrowTypeError(ctx, "%s must be a number", name);
+        return -1;
+    }
+    return 0;
+}
+
+uint8_t* mik__bytes_arg(JSContext* ctx, JSValueConst v, const char* name, size_t* len) {
+    size_t offset, elem_size, buf_len;
+    JSValue ab = JS_GetTypedArrayBuffer(ctx, v, &offset, len, &elem_size);
+    uint8_t* data;
+    if (!JS_IsException(ab)) {
+        /* len keeps the view length; the full backing buffer goes to a
+         * throwaway so a subarray view isn't over-read. */
+        data = JS_GetArrayBuffer(ctx, &buf_len, ab);
+        JS_FreeValue(ctx, ab);
+        if (data) data += offset;
+    } else {
+        JSValue exc = JS_GetException(ctx);
+        JS_FreeValue(ctx, exc);
+        data = JS_GetArrayBuffer(ctx, len, v);
+    }
+    if (!data) JS_ThrowTypeError(ctx, "%s must be a Uint8Array", name);
+    return data;
+}
+
+int mik__options_arg(JSContext* ctx, int argc, JSValueConst* argv, int index, bool required,
+                     JSValueConst* out) {
+    JSValueConst v = index < argc ? argv[index] : JS_UNDEFINED;
+    if (JS_IsObject(v) || (!required && JS_IsUndefined(v))) {
+        *out = v;
+        return 0;
+    }
+    JS_ThrowTypeError(ctx, "options must be an object");
+    return -1;
+}
+
+int mik__int_option(JSContext* ctx, JSValueConst options, const char* name, bool required,
+                    int32_t* out) {
+    if (JS_IsUndefined(options)) return required ? mik__to_int_arg(ctx, options, name, out) : 0;
+    JSValue v = JS_GetPropertyStr(ctx, options, name);
+    if (JS_IsException(v)) return -1;
+    int rc = 0;
+    if (required || !JS_IsUndefined(v)) rc = mik__to_int_arg(ctx, v, name, out);
+    JS_FreeValue(ctx, v);
+    return rc;
+}
+
+int mik__number_option(JSContext* ctx, JSValueConst options, const char* name, bool required,
+                       double* out) {
+    if (JS_IsUndefined(options)) return required ? mik__to_number_arg(ctx, options, name, out) : 0;
+    JSValue v = JS_GetPropertyStr(ctx, options, name);
+    if (JS_IsException(v)) return -1;
+    int rc = 0;
+    if (required || !JS_IsUndefined(v)) rc = mik__to_number_arg(ctx, v, name, out);
+    JS_FreeValue(ctx, v);
+    return rc;
+}
+
+int mik__bool_option(JSContext* ctx, JSValueConst options, const char* name, bool* out) {
+    if (JS_IsUndefined(options)) return 0;
+    JSValue v = JS_GetPropertyStr(ctx, options, name);
+    if (JS_IsException(v)) return -1;
+    int rc = 0;
+    if (JS_IsBool(v)) {
+        *out = JS_ToBool(ctx, v);
+    } else if (!JS_IsUndefined(v)) {
+        JS_ThrowTypeError(ctx, "%s must be a boolean", name);
+        rc = -1;
+    }
+    JS_FreeValue(ctx, v);
+    return rc;
+}
+
 void mik_dump_error(JSContext* ctx) {
     mik__watchdog_report_blocking(MIK_GetRuntime(ctx));
     JSValue exception_val = JS_GetException(ctx);

package/runtime/i2c/i2c.ts

@@ -1,35 +0,0 @@
-import * as native from 'native:mikro/i2c'
-
-import type {Result} from '../result/types.js'
-import type {I2c as PlatformI2c, I2cError, I2cOptions} from './types.js'
-
-/**
- * @public
- */
-export class I2c implements PlatformI2c {
-  #native: native.I2c
-
-  constructor(busNo: 0 | 1, options?: I2cOptions) {
-    this.#native = new native.I2c(busNo, options)
-  }
-
-  begin(): Result<void, I2cError> {
-    return this.#native.begin()
-  }
-
-  end(): Result<void, I2cError> {
-    return this.#native.end()
-  }
-
-  scan(): Result<Uint8Array, I2cError> {
-    return this.#native.scan()
-  }
-
-  write(address: number, data: Uint8Array, stop?: boolean): Result<void, I2cError> {
-    return this.#native.write(address, data, stop)
-  }
-
-  read(address: number, bytes: number): Result<Uint8Array, I2cError> {
-    return this.#native.read(address, bytes)
-  }
-}

package/runtime/i2s/i2s.ts

@@ -1,46 +0,0 @@
-import * as native from 'native:mikro/i2s'
-
-import type {Result} from '../result/types.js'
-import type {
-  I2sBase,
-  I2sError,
-  I2sPdmRxOptions,
-  I2sSamples,
-  I2sStdRxOptions,
-  I2sStdTxOptions,
-  I2sStdTxRxOptions,
-} from './types.js'
-
-/**
- * @public
- */
-export class I2s implements I2sBase {
-  #native: native.I2s
-
-  constructor(port: number, options: I2sStdTxRxOptions)
-  constructor(port: number, options: I2sStdTxOptions)
-  constructor(port: number, options: I2sStdRxOptions)
-  constructor(port: number, options: I2sPdmRxOptions)
-  constructor(
-    port: number,
-    options: I2sStdTxRxOptions | I2sStdTxOptions | I2sStdRxOptions | I2sPdmRxOptions,
-  ) {
-    this.#native = new native.I2s(port, options)
-  }
-
-  begin(): Result<void, I2sError> {
-    return this.#native.begin()
-  }
-
-  end(): Result<void, I2sError> {
-    return this.#native.end()
-  }
-
-  write(data: I2sSamples | Uint8Array): Promise<Result<void, I2sError>> {
-    return this.#native.write(data)
-  }
-
-  capture(frames: number, options?: {gainBits?: number}): Result<Int16Array, I2sError> {
-    return this.#native.capture(frames, options)
-  }
-}

package/runtime/neopixel/neopixel.ts

@@ -1,38 +0,0 @@
-import {NeoPixel as NativeNeoPixel} from 'native:mikro/neopixel'
-
-import type {Result} from '../result/types.js'
-import type {NeoPixelError, NeoPixelOptions} from './types.js'
-
-export class NeoPixel {
-  #native: InstanceType<typeof NativeNeoPixel>
-
-  constructor(pin: number, options: NeoPixelOptions) {
-    this.#native = new NativeNeoPixel(pin, options.count, options.rgbw ? 4 : 3)
-  }
-
-  setPixel(
-    index: number,
-    r: number,
-    g: number,
-    b: number,
-    w?: number,
-  ): Result<void, NeoPixelError> {
-    return this.#native.setPixel(index, r, g, b, w ?? 0)
-  }
-
-  fill(r: number, g: number, b: number, w?: number): Result<void, NeoPixelError> {
-    return this.#native.fill(r, g, b, w ?? 0)
-  }
-
-  show(): Result<void, NeoPixelError> {
-    return this.#native.show()
-  }
-
-  clear(): Result<void, NeoPixelError> {
-    return this.#native.clear()
-  }
-
-  end(): Result<void, NeoPixelError> {
-    return this.#native.end()
-  }
-}

package/runtime/pin/pin.ts

@@ -1,51 +0,0 @@
-import * as native from 'native:mikro/pin'
-
-import type {Result} from '../result/types.js'
-import type {AnalogReadOptions, Attenuation, PinError, PinMode} from './types.js'
-
-// Public mode lookup. Kept as a runtime value (rather than inlined) because
-// user code occasionally reads it to build a mode-picker UI on host-side
-// tooling; the native:mikro/pin layer uses the numeric constants directly.
-const PIN_MODE_INPUT = 0x01
-const PIN_MODE_OUTPUT = 0x03
-const PIN_MODE_INPUT_PULLUP = 0x05
-
-export const NativePinModes = {
-  INPUT: PIN_MODE_INPUT,
-  OUTPUT: PIN_MODE_OUTPUT,
-  INPUT_PULLUP: PIN_MODE_INPUT_PULLUP,
-} as const
-
-const NativeAttenuation: Record<Attenuation, number> = {
-  '0db': 0,
-  '2.5db': 1,
-  '6db': 2,
-  '11db': 3,
-} as const
-
-// Wrappers translate the string/enum JS-idiom args to the numeric codes the
-// native layer expects. Errors flow through unchanged: native:mikro/pin returns
-// {ok, error:{name,message}} directly (see mik_pin.cpp), so no remapping.
-
-export function pinMode(pin: number, mode: PinMode): Result<void, PinError> {
-  return native.pinMode(pin, NativePinModes[mode])
-}
-
-export function digitalWrite(pin: number, value: 0 | 1): Result<void, PinError> {
-  return native.digitalWrite(pin, value)
-}
-
-export function digitalRead(pin: number): 0 | 1 {
-  return native.digitalRead(pin) as 0 | 1
-}
-
-export function analogRead(pin: number, options?: AnalogReadOptions): Result<number, PinError> {
-  return native.analogRead(pin, NativeAttenuation[options?.attenuation ?? '11db'])
-}
-
-export function analogReadMillivolts(
-  pin: number,
-  options?: AnalogReadOptions,
-): Result<number, PinError> {
-  return native.analogReadMillivolts(pin, NativeAttenuation[options?.attenuation ?? '11db'])
-}