@mikrojs/native 0.17.1-pr-300.20260731010039 → 0.18.0

package/CMakeLists.txt

@@ -86,7 +86,6 @@ mikrojs_generate_bytecode(
     MODULE_PREFIX "mikro"
     SYMBOL_PREFIX "mikro"
     TARGET gen_bytecode
-    FREEZE_ATOMS
 )
 add_dependencies(mikrojs gen_bytecode)
 target_include_directories(mikrojs PRIVATE "${gen_bytecode_INCLUDE_DIR}")

package/cmake/mikrojs_bytecode.cmake

@@ -25,11 +25,7 @@ get_filename_component(_MIK_BC_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
 set(_MIK_BC_SCRIPTS_DIR "${_MIK_BC_CMAKE_DIR}/../scripts" CACHE INTERNAL "")
 
 function(mikrojs_generate_bytecode)
-    # FREEZE_ATOMS: compile blobs against a generated frozen atom table so
-    # they load zero-copy (JS_READ_OBJ_INPLACE). Core runtime only: the
-    # device preloads exactly one table, so board/driver packages must
-    # stay classic (they load via the copy-and-relocate fallback).
-    cmake_parse_arguments(ARG "FREEZE_ATOMS" "RUNTIME_DIR;MODULE_PREFIX;SYMBOL_PREFIX;TARGET;WORKING_DIRECTORY" "MODULES" ${ARGN})
+    cmake_parse_arguments(ARG "" "RUNTIME_DIR;MODULE_PREFIX;SYMBOL_PREFIX;TARGET;WORKING_DIRECTORY" "MODULES" ${ARGN})
 
     # Defaults
     if(NOT ARG_TARGET)
@@ -90,46 +86,7 @@ function(mikrojs_generate_bytecode)
         WORKING_DIRECTORY ${ARG_WORKING_DIRECTORY}
     )
 
-    # Steps 2a/2b (FREEZE_ATOMS only): pass-1 raw bytecode per module, then
-    # union the atom sections into the frozen atom table (frozen_atoms.bin
-    # for qjsc -A, <prefix>_frozen_atoms.h for the runtime preload).
-    # Module order fixes the table order.
-    set(_ATOMS_BIN "")
-    set(_ATOMS_HEADER "")
-    if(ARG_FREEZE_ATOMS)
-        set(_EXTRACT_SCRIPT "${_MIK_BC_SCRIPTS_DIR}/extract-atoms.js")
-        set(_PASS1_BLOBS "")
-        foreach(mod ${ARG_MODULES})
-            string(REGEX REPLACE "[^a-zA-Z0-9]" "_" _mod_safe "${mod}")
-            set(_blob "${_GEN_DIR}/pass1/${_mod_safe}.bjs")
-            add_custom_command(
-                OUTPUT ${_blob}
-                COMMAND ${CMAKE_COMMAND} -E make_directory ${_GEN_DIR}/pass1
-                COMMAND sh ${_COMPILE_SCRIPT}
-                    ${QJSC_EXECUTABLE}
-                    ${_BUNDLE_DIR}/${mod}.js
-                    ${_blob}
-                    "${ARG_MODULE_PREFIX}/${mod}"
-                    "unused"
-                DEPENDS ${_BUNDLE_DIR}/bundle.stamp ${_COMPILE_SCRIPT} ${QJSC_EXECUTABLE}
-                COMMENT "Bytecode pass 1: ${ARG_MODULE_PREFIX}/${mod}"
-            )
-            list(APPEND _PASS1_BLOBS ${_blob})
-        endforeach()
-
-        set(_ATOMS_BIN "${_GEN_DIR}/frozen_atoms.bin")
-        set(_ATOMS_HEADER "${_GEN_DIR}/${ARG_SYMBOL_PREFIX}_frozen_atoms.h")
-        add_custom_command(
-            OUTPUT ${_ATOMS_BIN} ${_ATOMS_HEADER}
-            COMMAND node ${_EXTRACT_SCRIPT} ${_GEN_DIR} ${ARG_SYMBOL_PREFIX} ${_PASS1_BLOBS}
-            DEPENDS ${_PASS1_BLOBS} ${_EXTRACT_SCRIPT}
-            COMMENT "Extracting frozen atom table"
-        )
-    endif()
-
-    # Step 2c: Compile each bundled JS file to a bytecode header with qjsc,
-    # against the frozen atom table so atom references are final ids
-    # (enables zero-copy loading via JS_READ_OBJ_INPLACE).
+    # Step 2: Compile each bundled JS file to a bytecode header with qjsc
     set(_HEADERS "")
     foreach(mod ${ARG_MODULES})
         # Sanitize module name for C identifiers (replace non-alphanumeric with _)
@@ -144,15 +101,11 @@ function(mikrojs_generate_bytecode)
                 ${_header}
                 "${ARG_MODULE_PREFIX}/${mod}"
                 "${ARG_SYMBOL_PREFIX}_${_mod_safe}_bytecode"
-                ${_ATOMS_BIN}
-            DEPENDS ${_BUNDLE_DIR}/bundle.stamp ${_COMPILE_SCRIPT} ${QJSC_EXECUTABLE} ${_ATOMS_BIN}
+            DEPENDS ${_BUNDLE_DIR}/bundle.stamp ${_COMPILE_SCRIPT} ${QJSC_EXECUTABLE}
             COMMENT "Compiling bytecode: ${ARG_MODULE_PREFIX}/${mod}"
         )
         list(APPEND _HEADERS ${_header})
     endforeach()
-    if(_ATOMS_HEADER)
-        list(APPEND _HEADERS ${_ATOMS_HEADER})
-    endif()
 
     # Step 3: Generate builtins table header (includes + lookup table)
     set(_TABLE_HEADER "${_GEN_DIR}/${ARG_SYMBOL_PREFIX}_builtins_table.h")

package/include/mikrojs/mikrojs.h

@@ -288,12 +288,8 @@ extern mik_module_desc_t* mik__module_registry_head;
  * Driver packages use MIK_REGISTER_BUILTIN() to embed their JS wrappers as
  * firmware builtins, resolved by the real npm package name (e.g. "@mikrojs/your-driver"). */
 typedef struct mik_ext_builtin_t {
-    const char* name; /* module name, e.g. "@mikrojs/your-driver" */
-    /* Compiled bytecode. Must outlive every runtime that imports the
-     * module: the loader may keep instruction streams pointing into this
-     * buffer instead of copying them to the heap (JS_READ_OBJ_INPLACE).
-     * Use a static const array (flash/rodata), never a heap buffer. */
-    const uint8_t* data;
+    const char* name;         /* module name, e.g. "@mikrojs/your-driver" */
+    const uint8_t* data;      /* compiled bytecode */
     uint32_t data_size;
     struct mik_ext_builtin_t* next;
 } mik_ext_builtin_t;

package/include/mikrojs/private.h

@@ -57,6 +57,9 @@ struct MIKRejectedPromise {
     JSValue reason;
 };
 
+/* Observable dispatch queue (defined in mik_observable.cpp). */
+struct MIKObservableDispatch;
+
 struct MIKRuntime {
     MIKRunOptions options;
     MIKConfig config;
@@ -97,10 +100,10 @@ struct MIKRuntime {
      * here on `reject` and removes it on `handle`; whatever remains after a
      * microtask drain (mik__execute_jobs) is a genuine unhandled rejection
      * and gets reported. This deferral mirrors the HTML/WinterCG algorithm
-     * and is what prevents a transiently-unhandled promise (e.g. a module's
-     * evaluation promise, rejected before the import loader attaches its
-     * .then) from being reported. Entries hold dup'd references owned by this
-     * vector and freed when removed or flushed. */
+     * and is what prevents a transiently-unhandled promise (e.g. an async
+     * function's result promise, rejected synchronously before `await`
+     * attaches its handler) from being reported. Entries hold dup'd
+     * references owned by this vector and freed when removed or flushed. */
     std::vector<MIKRejectedPromise> pending_rejections;
     /* Shared prototype for Result objects ({ok, value} / {ok, error}) created
      * by mik__result_ok/mik__result_err and the native:mikro/result ok()/err()
@@ -170,6 +173,10 @@ struct MIKRuntime {
      * through the wire protocol. NULL means __testEmit is a no-op. */
     void (*test_emit_fn)(const char* json, size_t len, void* opaque) = nullptr;
     void* test_emit_opaque = nullptr;
+    /* Observable dispatch trampoline state (FIFO + active flag). Allocated by
+     * mik__observable_init, freed via mik__observable_dispatch_free. Empty
+     * outside an active dispatch, so teardown never sees live JSValues. */
+    struct MIKObservableDispatch* observable_dispatch = nullptr;
 };
 
 void mik__pub_fs_register(JSContext* ctx);
@@ -184,12 +191,7 @@ JSValue mik_throw_errno(JSContext* ctx, int err);
 void mik__execute_jobs(JSContext* ctx);
 /* End-of-turn unhandled-rejection check; called after each microtask drain. */
 void mik__flush_unhandled_rejections(JSContext* ctx);
-/* Drop a promise from the pending-rejection queue without reporting it. */
-void mik__forget_rejection(JSContext* ctx, JSValue promise);
 JSModuleDef* mik__load_builtin(JSContext* ctx, const char* name);
-/* Preload the generated frozen atom table (must run right after
- * JS_NewRuntime2, before any context/intrinsic creates atoms). */
-int mik__preload_frozen_atoms(JSRuntime* rt);
 int mik__load_file(JSContext* ctx, DynBuf* dbuf, const char* filename);
 void mik__resolve_fs_path(JSContext* ctx, const char* module_name, char* out, size_t out_size);
 int mik__resolve_fs_root(JSContext* ctx, const char* path, char* out, size_t out_size);
@@ -264,6 +266,7 @@ JSModuleDef* mik__udp_init(JSContext* ctx);
 
 /* Observable module (mik_observable.cpp) */
 JSModuleDef* mik__observable_init(JSContext* ctx);
+void mik__observable_dispatch_free(struct MIKRuntime* mik_rt);
 
 bool mik__repl_is_evaluating(void);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/native",
-  "version": "0.17.1-pr-300.20260731010039",
+  "version": "0.18.0",
   "description": "Mikro.js C++ runtime library and Node.js native addon",
   "keywords": [
     "esp32",
@@ -86,14 +86,14 @@
     "cmake-js": "^8.0.0",
     "node-addon-api": "^8.7.0",
     "node-gyp-build": "^4.8.4",
-    "@mikrojs/quickjs": "0.17.1-pr-300.20260731010039+a6350ad"
+    "@mikrojs/quickjs": "0.18.0"
   },
   "devDependencies": {
     "@swc/core": "^1.15.30",
     "@types/node": "^24.12.2",
     "esbuild": "^0.28.0",
     "terser": "^5.46.2",
-    "@mikrojs/registry": "0.17.1-pr-300.20260731010039+a6350ad"
+    "@mikrojs/registry": "0.18.0"
   },
   "engines": {
     "node": ">=24.0.0"

package/runtime/observable/native-observable.node-shim.ts

@@ -5,24 +5,48 @@
 // - subscribe() returns a Subscription with unsubscribe() (no AbortSignal)
 // - no error channel — throws inside dispatch or teardown are caught at the
 //   boundary, isolated to the offending subscriber, and re-thrown
-//   asynchronously via setTimeout(0) so the synchronous producer keeps
-//   running but the bug eventually surfaces (and on device, halts the
-//   runtime via the existing unhandled-rejection path)
+//   asynchronously via setTimeout(0) so the synchronous producer finishes
+//   the dispatch; on device the deferred throw then panics
 // - sync emission allowed
 // - pipe-only composition (operators live in operators.ts)
 // - withEmitters() factory: {observable, next, complete}
 
-/* Catch a thrown error and re-throw it on the next tick. The synchronous
- * caller keeps going (other subscribers receive the value, remaining
- * teardowns run); the error eventually surfaces as an uncaught exception. */
-function panicAsync(err: unknown): void {
+/* A throw in a subscriber, operator, or teardown callback is an application
+ * crash. On device it stops the runtime per onPanic, so nothing further is
+ * delivered. There is no runtime to stop here, so the host sees an uncaught
+ * error on the next tick and `panicked` suppresses further delivery, which is
+ * the part a unit test can observe. It clears on the next fresh subscribe, so
+ * one test's crash cannot poison the next; on device the runtime is gone. */
+let panicked = false
+
+function panic(err: unknown): void {
+  panicked = true
   setTimeout(() => {
     throw err
   }, 0)
 }
 
+/* Dispatch trampoline, mirroring mik_observable.cpp: next/complete called
+ * while a dispatch is active enqueue instead of recursing; the outermost
+ * dispatch drains in FIFO order. Handler code after sub.next() therefore
+ * runs before downstream delivery. */
+type QueueEntry = {sub: Subscriber<unknown>; value: unknown; isComplete: boolean}
+const queue: QueueEntry[] = []
+let queueHead = 0
+let dispatchActive = false
+
+function drainQueue(): void {
+  while (queueHead < queue.length) {
+    const e = queue[queueHead++]!
+    if (!panicked) e.sub.deliverQueued(e)
+  }
+  queue.length = 0
+  queueHead = 0
+}
+
 class Subscriber<T> {
-  closed = false
+  private _closed = false
+  private completePending = false
   private next_fn: ((v: T) => void) | undefined
   private complete_fn: (() => void) | undefined
   private teardowns: Array<() => void> = []
@@ -40,25 +64,61 @@ class Subscriber<T> {
     }
   }
 
+  get closed(): boolean {
+    return this._closed || this.completePending
+  }
+
   next(value: T): void {
-    if (this.closed) return
+    if (this.closed || panicked) return
+    if (dispatchActive) {
+      queue.push({sub: this as Subscriber<unknown>, value, isComplete: false})
+      return
+    }
+    dispatchActive = true
+    this.deliverNext(value)
+    drainQueue()
+    dispatchActive = false
+  }
+
+  complete(): void {
+    if (this.closed || panicked) return
+    if (dispatchActive) {
+      this.completePending = true
+      queue.push({sub: this as Subscriber<unknown>, value: undefined, isComplete: true})
+      return
+    }
+    dispatchActive = true
+    this.deliverComplete()
+    drainQueue()
+    dispatchActive = false
+  }
+
+  /* Deliver a queued entry; entries whose subscriber closed (unsubscribed)
+   * between enqueue and drain are dropped. */
+  deliverQueued(e: QueueEntry): void {
+    if (this._closed) return
+    if (e.isComplete) this.deliverComplete()
+    else this.deliverNext(e.value as T)
+  }
+
+  private deliverNext(value: T): void {
     if (this.next_fn) {
       try {
         this.next_fn(value)
       } catch (err) {
-        panicAsync(err)
+        panic(err)
       }
     }
   }
 
-  complete(): void {
-    if (this.closed) return
-    this.closed = true
+  private deliverComplete(): void {
+    this.completePending = false
+    this._closed = true
     if (this.complete_fn) {
       try {
         this.complete_fn()
       } catch (err) {
-        panicAsync(err)
+        panic(err)
       }
     }
     this.runTeardowns()
@@ -68,11 +128,11 @@ class Subscriber<T> {
     if (typeof fn !== 'function') {
       throw new TypeError('addTeardown: argument must be a function')
     }
-    if (this.closed) {
+    if (this._closed) {
       try {
         fn()
       } catch (err) {
-        panicAsync(err)
+        panic(err)
       }
       return
     }
@@ -80,9 +140,10 @@ class Subscriber<T> {
   }
 
   // Used by Subscription.unsubscribe — silent (no observer.complete call).
+  // A pending complete owns the close; its queued entry still delivers.
   closeSilently(): void {
     if (this.closed) return
-    this.closed = true
+    this._closed = true
     this.runTeardowns()
   }
 
@@ -93,7 +154,7 @@ class Subscriber<T> {
       try {
         list[i]!()
       } catch (err) {
-        panicAsync(err)
+        panic(err)
       }
     }
   }
@@ -122,6 +183,7 @@ export class Observable<Ok, Err = never> {
   }
 
   subscribe(observer?: unknown): Subscription {
+    if (!dispatchActive) panicked = false
     const sub = new Subscriber<unknown>(observer)
     try {
       this.#cb(sub)
@@ -167,7 +229,7 @@ export class Observable<Ok, Err = never> {
     ) {
       return new Observable<unknown>((sub) => {
         for (const value of src as Iterable<unknown>) {
-          if (sub.closed) return
+          if (sub.closed || panicked) return
           sub.next(value)
         }
         if (!sub.closed) sub.complete()
@@ -201,6 +263,7 @@ export class Observable<Ok, Err = never> {
       // Snapshot to be resilient against mid-dispatch unsubscribes.
       const snapshot = subs.slice()
       for (const s of snapshot) {
+        if (panicked) break
         if (!s.closed) s.next(value)
       }
     }
@@ -211,6 +274,7 @@ export class Observable<Ok, Err = never> {
       const snapshot = subs.slice()
       subs.length = 0
       for (const s of snapshot) {
+        if (panicked) break
         if (!s.closed) s.complete()
       }
     }

package/runtime/observable/operators.ts

@@ -7,12 +7,9 @@
  * Result-aware operators (`mapOk`, `filterOk`, ...) ship when a concrete
  * consumer asks. Today no module produces fallible event streams.
  *
- * Errors: throws inside operator transforms or finalize callbacks are caught
- * at the dispatch boundary, isolated to that subscriber, and re-thrown
- * asynchronously via setTimeout(0). The synchronous producer keeps going
- * (the bad value is dropped, sibling subscribers untouched), and on device
- * the eventual uncaught throw halts the runtime via the existing
- * unhandled-rejection path. Stream errors are panics.
+ * Errors: a throw inside a transform or a finalize callback propagates to the
+ * dispatch boundary, which reports it and panics. Operators do not catch:
+ * an application crash is an application crash.
  *
  * See `.claude/plans/observable.md` for the full design.
  */
@@ -28,69 +25,42 @@ import type {Observable as ObservableT} from './types.js'
 const Observable = NativeObservable as unknown as typeof ObservableT
 type Observable<Ok, Err = never> = ObservableT<Ok, Err>
 
-/* Catch a thrown error and re-throw it on the next tick. The synchronous
- * caller keeps going; the error eventually surfaces as an uncaught
- * exception. */
-function panicAsync(err: unknown): void {
-  setTimeout(() => {
-    throw err
-  }, 0)
-}
-
-/* Map values through a transform. Throws inside `fn` are caught and
- * scheduled to re-throw on the next tick (panic). The bad value is dropped
- * for that subscription; sibling subscriptions are unaffected. */
+/* Map values through a transform. A throw inside `fn` panics. */
 export const map =
   <A, B>(fn: (value: A) => B) =>
   (source: Observable<A>): Observable<B> =>
     new Observable<B>((sub) => {
       const upstream = source.subscribe({
-        next: (value) => {
-          let next: B
-          try {
-            next = fn(value)
-          } catch (err) {
-            panicAsync(err)
-            return
-          }
-          sub.next(next)
-        },
+        next: (value) => sub.next(fn(value)),
         complete: () => sub.complete(),
       })
       sub.addTeardown(() => upstream.unsubscribe())
     })
 
-/* Pass through values matching `pred`. `pred` errors panic asynchronously. */
+/* Pass through values matching `predicate`. A throw inside it panics. */
 export const filter =
-  <A>(pred: (value: A) => boolean) =>
+  <A>(predicate: (value: A) => boolean) =>
   (source: Observable<A>): Observable<A> =>
     new Observable<A>((sub) => {
       const upstream = source.subscribe({
         next: (value) => {
-          let keep: boolean
-          try {
-            keep = pred(value)
-          } catch (err) {
-            panicAsync(err)
-            return
-          }
-          if (keep) sub.next(value)
+          if (predicate(value)) sub.next(value)
         },
         complete: () => sub.complete(),
       })
       sub.addTeardown(() => upstream.unsubscribe())
     })
 
-/* Take at most n values, then complete. n <= 0 completes immediately. */
+/* Take at most `count` values, then complete. count <= 0 completes immediately. */
 export const take =
-  (n: number) =>
+  (count: number) =>
   <A>(source: Observable<A>): Observable<A> =>
     new Observable<A>((sub) => {
-      if (n <= 0) {
+      if (count <= 0) {
         sub.complete()
         return
       }
-      let remaining = n
+      let remaining = count
       const upstream = source.subscribe({
         next: (value) => {
           if (remaining <= 0) return
@@ -123,8 +93,8 @@ export const takeUntil =
     })
 
 /* Run `fn` when the subscription ends for any reason (unsubscribe or
- * natural completion). Throws inside `fn` are caught and panic
- * asynchronously, so subsequent teardowns still run. RxJS naming. */
+ * natural completion). A throw inside `fn` panics; the remaining teardowns
+ * still run. RxJS naming. */
 export const finalize =
   (fn: () => void) =>
   <A>(source: Observable<A>): Observable<A> =>
@@ -135,10 +105,6 @@ export const finalize =
       })
       sub.addTeardown(() => {
         upstream.unsubscribe()
-        try {
-          fn()
-        } catch (err) {
-          panicAsync(err)
-        }
+        fn()
       })
     })

package/scripts/compile-bytecode.sh

@@ -1,12 +1,9 @@
 #!/bin/sh
 # Compile a bundled JS module to a C bytecode header using qjsc.
 #
-# Usage: compile-bytecode.sh <qjsc> <input.js> <output.h> <module_name> <symbol_name> [atoms.bin]
+# Usage: compile-bytecode.sh <qjsc> <input.js> <output.h> <module_name> <symbol_name>
 #
 # Reads <input>.externals for external module declarations.
-# If <output> ends in .bjs, emits raw bytecode instead of a C header
-# (pass 1 of the frozen-atom pipeline; see extract-atoms.js).
-# If [atoms.bin] is given, compiles against that frozen atom table (-A).
 
 set -e
 
@@ -15,7 +12,6 @@ INPUT="$2"
 OUTPUT="$3"
 MODULE_NAME="$4"
 SYMBOL_NAME="$5"
-ATOMS_BIN="$6"
 
 EXTERNALS_FILE="${INPUT%.js}.externals"
 
@@ -38,20 +34,5 @@ fi
 # so any runtime module that reads `import.meta.*` (e.g. mikrojs/env
 # accessing import.meta.env) breaks at runtime. The ~1 KB heap saving
 # from stripping debug isn't worth crippling a spec-standard module API.
-A_FLAGS=""
-if [ -n "$ATOMS_BIN" ]; then
-    A_FLAGS="-A $ATOMS_BIN"
-fi
-
-case "$OUTPUT" in
-*.bjs)
-    # Raw bytecode (frozen-atom pass 1). Must use the same flags as the
-    # header pass so the atom set matches, minus -N (no C symbol).
-    # shellcheck disable=SC2086
-    "$QJSC" -b -m -s -n "$MODULE_NAME" $M_FLAGS $A_FLAGS -o "$OUTPUT" "$INPUT"
-    ;;
-*)
-    # shellcheck disable=SC2086
-    "$QJSC" -m -s -N "$SYMBOL_NAME" -n "$MODULE_NAME" $M_FLAGS $A_FLAGS -o "$OUTPUT" "$INPUT"
-    ;;
-esac
+# shellcheck disable=SC2086
+"$QJSC" -m -s -N "$SYMBOL_NAME" -n "$MODULE_NAME" $M_FLAGS -o "$OUTPUT" "$INPUT"

package/scripts/copy-prebuild.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import {copyFileSync, existsSync, mkdirSync} from 'node:fs'
+import {copyFileSync, existsSync, mkdirSync, rmSync} from 'node:fs'
 import {dirname, resolve} from 'node:path'
 import {fileURLToPath} from 'node:url'
 
@@ -15,6 +15,10 @@ if (!existsSync(source)) {
 const targetDir = resolve(pkgRoot, 'prebuilds', `${process.platform}-${process.arch}`)
 mkdirSync(targetDir, {recursive: true})
 const target = resolve(targetDir, 'mikrojs.napi.node')
+// Remove before copying so the target gets a fresh inode. Overwriting in
+// place invalidates the macOS code-signature cache and any process that
+// dlopens the library afterwards is killed with SIGKILL.
+rmSync(target, {force: true})
 copyFileSync(source, target)
 // eslint-disable-next-line no-console
 console.log(`Copied → ${target}`)

package/src/builtins.cpp

@@ -17,19 +17,6 @@ typedef struct {
 #include "gen/mikro_builtins_table.h"
 #define builtins mikro_builtins
 
-/* Frozen atom table generated alongside the builtin bytecode: preloading it
- * right after runtime creation gives builtin blobs final atom ids, letting
- * their instruction streams load zero-copy from flash/rodata. */
-#include "gen/mikro_frozen_atoms.h"
-
-int mik__preload_frozen_atoms(JSRuntime* rt) {
-    if (mikro_frozen_atom_count == 0) {
-        return 0;
-    }
-    return JS_PreloadFrozenAtoms(rt, mikro_frozen_atom_names, mikro_frozen_atom_lens,
-                                 mikro_frozen_atom_count);
-}
-
 /* External builtins registered by board/driver packages via MIK_REGISTER_BUILTIN() */
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
 mik_ext_builtin_t* mik__ext_builtin_head = nullptr;
@@ -42,10 +29,7 @@ static JSModuleDef* mik__deserialize_builtin(JSContext* ctx, const char* name,
     platform->log(MIK_LOG_DEBUG, "mikrojs", "Loading builtin '%s' (%u bytes, bc_version=%u, data_ptr=%p)", name,
              data_size, data_size > 0 ? data[0] : 0, (void*)data);
 
-    /* Builtin bytecode lives in flash/rodata for the runtime's lifetime, so
-     * qualifying instruction streams stay in place instead of being copied
-     * to the JS heap (falls back per function for non-final atom refs). */
-    JSValue obj = JS_ReadObject(ctx, data, data_size, JS_READ_OBJ_BYTECODE | JS_READ_OBJ_INPLACE);
+    JSValue obj = JS_ReadObject(ctx, data, data_size, JS_READ_OBJ_BYTECODE);
 
     if (JS_IsException(obj)) {
         /* Peek the exception for the log, then re-throw it so the caller

package/src/mik_abort.cpp

@@ -65,6 +65,9 @@ static JSValue mik__abort_lazy_get(JSContext* ctx, JSValue this_val, int magic)
     }
     if (JS_PromiseState(ctx, ret) == JS_PROMISE_REJECTED) {
         JSValue err = JS_PromiseResult(ctx, ret);
+        /* The rejection is re-thrown below; mark the promise handled so the
+         * unhandled-rejection flush doesn't report the same error again. */
+        JS_PromiseMarkAsHandled(ctx, ret);
         JS_FreeValue(ctx, ret);
         JS_FreeValue(ctx, global_obj);
         return JS_Throw(ctx, err);

package/src/mik_console.cpp

@@ -237,11 +237,10 @@ static JSValue mik__console_error_warn(JSContext* ctx, JSValue this_val, int arg
 /* ── Uncaught error reporting ─────────────────────────────────────── */
 
 /* Dedup across report paths: one error can reach this function more than
- * once for a single failure. A failed dynamic import leaves two never-handled
- * promises with the SAME reason (QuickJS runs a module body as an async
- * function and reads its rejected result by value, plus the rejection
- * propagated up the await chain), and at the REPL the throw path reports an
- * error the deferred flush then sees again. Mark the error object the first
+ * once for a single failure. The sync throw path (mik_dump_error) can report
+ * an error whose promise still sits in the deferred flush queue, e.g. an
+ * entry module whose rejected eval promise is read by value while the host
+ * dumps the pending exception. Mark the error object the first
  * time it is reported and skip it afterwards. Keying on object identity is
  * exact and time-independent; a recycled address belongs to a fresh object
  * with no marker, so distinct errors are never suppressed. Primitive