@mikrojs/quickjs 0.17.0 → 0.17.1-pr-300.20260731003316

package/apply-patches.js

@@ -14,7 +14,9 @@
  * @mikrojs/native (which calls the patched module-management symbols).
  */
 import {execFileSync} from 'node:child_process'
-import {existsSync, readdirSync} from 'node:fs'
+import {createHash} from 'node:crypto'
+import {existsSync, readdirSync, readFileSync, writeFileSync} from 'node:fs'
+import {tmpdir} from 'node:os'
 import {dirname, join} from 'node:path'
 import {fileURLToPath} from 'node:url'
 
@@ -22,31 +24,116 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const qjsDir = join(__dirname, 'deps', 'quickjs')
 const patchesDir = join(__dirname, 'patches')
 
+function seriesHash(files) {
+  const hash = createHash('sha256')
+  for (const f of files) hash.update(readFileSync(join(patchesDir, f)))
+  return hash.digest('hex')
+}
+
+function applyAll(files) {
+  for (const f of files) {
+    try {
+      execFileSync('git', ['apply', join(patchesDir, f)], {cwd: qjsDir, stdio: 'inherit'})
+      console.log(`@mikrojs/quickjs: applied patch ${f}`)
+    } catch (err) {
+      console.error(`@mikrojs/quickjs: failed to apply ${f}`, err.message)
+      process.exit(1)
+    }
+  }
+}
+
 export function applyPatches() {
+  // Published tarballs ship pre-patched sources and exclude patches/ from
+  // the package files, so consumers return here and never need git.
   if (!existsSync(patchesDir)) return
   const files = readdirSync(patchesDir)
     .filter((f) => f.endsWith('.patch'))
     .sort()
-  for (const f of files) {
-    const patch = join(patchesDir, f)
-    // Probe: is the patch already applied?
+  if (files.length === 0) return
+
+  // Patches may stack (a later patch can modify code an earlier one added),
+  // so they are only meaningful as a whole series applied in order to a
+  // pristine tree. A stamp records which series the tree currently carries.
+  const stampFile = join(qjsDir, '.patches-stamp')
+  const hash = seriesHash(files)
+  if (existsSync(stampFile) && readFileSync(stampFile, 'utf8').trim() === hash) {
+    // The stamp can outlive the tree it describes (e.g. `git submodule
+    // update` resets sources but leaves untracked files); trust it only if
+    // the series bounds are actually present. First and last together catch
+    // both a reset tree and a partially reverted one.
+    try {
+      for (const probe of [files[0], files[files.length - 1]]) {
+        execFileSync('git', ['apply', '--reverse', '--check', join(patchesDir, probe)], {
+          cwd: qjsDir,
+          stdio: 'pipe',
+        })
+      }
+      return // series already applied
+    } catch {
+      // stale stamp — fall through and re-apply
+    }
+  }
+
+  let inRepo = true
+  try {
+    execFileSync('git', ['-C', qjsDir, 'rev-parse', 'HEAD'], {stdio: 'pipe'})
+  } catch {
+    inRepo = false
+  }
+
+  if (!inRepo) {
+    // Sources without git metadata (should not happen: tarballs exclude
+    // patches/ and return above). Refuse rather than guess.
+    console.error('@mikrojs/quickjs: patches/ present but deps/quickjs is not a git checkout')
+    process.exit(1)
+  }
+
+  // In-repo: reset to the pinned commit, then apply the whole series.
+  // Only reset when the tree state is accounted for (a previous series
+  // stamp, a clean tree, or a tree matching the pre-stamp-era series);
+  // otherwise refuse rather than discard unknown local edits. Untracked
+  // files (editor droppings, agent scratch dirs) are ignored: they cannot
+  // conflict with `git apply` of tracked-file patches, and `checkout -- .`
+  // could not remove them anyway.
+  const dirty =
+    execFileSync('git', ['-C', qjsDir, 'status', '--porcelain', '--untracked-files=no'], {
+      encoding: 'utf8',
+    })
+      .split('\n')
+      .filter((l) => l.trim()).length > 0
+  if (dirty && !existsSync(stampFile)) {
+    // Pre-stamp checkouts have some prefix of the series applied; the
+    // first patch reverse-checking is strong evidence of that state.
     try {
-      execFileSync('git', ['apply', '--reverse', '--check', patch], {
+      execFileSync('git', ['apply', '--reverse', '--check', join(patchesDir, files[0])], {
         cwd: qjsDir,
         stdio: 'pipe',
       })
-      continue // already applied
     } catch {
-      // not applied — fall through
-    }
-    try {
-      execFileSync('git', ['apply', patch], {cwd: qjsDir, stdio: 'inherit'})
-      console.log(`@mikrojs/quickjs: applied patch ${f}`)
-    } catch (err) {
-      console.error(`@mikrojs/quickjs: failed to apply ${f}`, err.message)
+      console.error(
+        '@mikrojs/quickjs: submodule tree has local changes that do not match the patch series.\n' +
+          `Commit them as a patch or discard them: git -C ${qjsDir} checkout -- .`,
+      )
       process.exit(1)
     }
   }
+  if (dirty) {
+    // The tree is about to be discarded and re-derived from the patch
+    // series. This also runs from CMake configure, i.e. mid-development
+    // when someone is iterating on a patch — keep a backup of whatever
+    // tracked changes are thrown away so an unregenerated edit is
+    // recoverable instead of silently gone.
+    const diff = execFileSync('git', ['-C', qjsDir, 'diff'], {encoding: 'utf8'})
+    if (diff.length > 0) {
+      const backup = join(tmpdir(), `quickjs-discarded-${Date.now()}.patch`)
+      writeFileSync(backup, diff)
+      console.log(`@mikrojs/quickjs: re-deriving submodule tree from the patch series`)
+      console.log(`@mikrojs/quickjs: previous tracked changes saved to ${backup}`)
+    }
+    execFileSync('git', ['-C', qjsDir, 'checkout', '--', '.'], {stdio: 'inherit'})
+  }
+  applyAll(files)
+  writeFileSync(stampFile, hash + '\n')
 }
 
 // Run directly: sync the submodule, then apply patches.

package/deps/quickjs/qjsc.c

@@ -331,6 +331,65 @@ static const char main_c_template2[] =
 
 #define PROG_NAME "qjsc"
 
+/* mikrojs patch: load a frozen atom table (see JS_PreloadFrozenAtoms) from
+   a little-endian binary file: u32 count, then per atom u32 len + bytes. */
+static int load_frozen_atoms(JSRuntime *rt, const char *filename)
+{
+    FILE *f;
+    uint8_t hdr[4];
+    uint32_t count = 0, i, len;
+    char **names = NULL;
+    uint32_t *lens = NULL;
+    int ret = -1;
+
+    f = fopen(filename, "rb");
+    if (!f) {
+        fprintf(stderr, "qjsc: could not open atom table '%s'\n", filename);
+        return -1;
+    }
+    if (fread(hdr, 1, 4, f) != 4)
+        goto done;
+    count = hdr[0] | (hdr[1] << 8) | (hdr[2] << 16) | ((uint32_t)hdr[3] << 24);
+    names = calloc(count, sizeof(*names));
+    lens = calloc(count, sizeof(*lens));
+    if (!names || !lens)
+        goto done;
+    for (i = 0; i < count; i++) {
+        if (fread(hdr, 1, 4, f) != 4)
+            goto done;
+        len = hdr[0] | (hdr[1] << 8) | (hdr[2] << 16) | ((uint32_t)hdr[3] << 24);
+        if (len > (1u << 20))
+            goto done; /* corrupted table; also guards the len + 1 overflow */
+        names[i] = malloc(len + 1);
+        if (!names[i])
+            goto done;
+        if (len != 0 && fread(names[i], 1, len, f) != len)
+            goto done;
+        names[i][len] = '\0';
+        lens[i] = len;
+    }
+    if (JS_PreloadFrozenAtoms(rt, (const char *const *)names, lens, count)) {
+        fprintf(stderr, "qjsc: failed to preload frozen atom table\n");
+        ret = -2; /* already reported */
+        goto done;
+    }
+    /* The runtime keeps pointers into names/lens for lazy atom
+       materialization; leak them intentionally (process-lifetime tool). */
+    fclose(f);
+    return 0;
+ done:
+    if (ret == -1)
+        fprintf(stderr, "qjsc: bad atom table '%s'\n", filename);
+    if (names) {
+        for (i = 0; i < count; i++)
+            free(names[i]);
+        free(names);
+    }
+    free(lens);
+    fclose(f);
+    return ret;
+}
+
 void help(void)
 {
     printf("QuickJS-ng Compiler version %s\n"
@@ -349,6 +408,7 @@ void help(void)
            "-p prefix   set the prefix of the generated C names\n"
            "-P          do not add default system modules\n"
            "-s          strip the source code, specify twice to also strip debug info\n"
+           "-A file     preload a frozen atom table (binary: u32le count, then u32le len + bytes per atom)\n"
            "-S n        set the maximum stack size to 'n' bytes (default=%d)\n",
            JS_GetVersion(),
            JS_DEFAULT_STACK_SIZE);
@@ -407,6 +467,8 @@ int main(int argc, char **argv)
     namelist_t dynamic_module_list;
     bool load_system_modules = true;
 
+    const char *frozen_atoms_file = NULL;
+
     out_filename = NULL;
     script_name = NULL;
     output_type = OUTPUT_C;
@@ -462,6 +524,14 @@ int main(int argc, char **argv)
                 output_type = OUTPUT_C_MAIN;
                 continue;
             }
+            if (opt == 'A') {
+                if (!optarg) {
+                    check_hasarg(optind, argc, opt);
+                    optarg = argv[optind++];
+                }
+                frozen_atoms_file = optarg;
+                continue;
+            }
             if (opt == 'n') {
                 if (!optarg) {
                     check_hasarg(optind, argc, opt);
@@ -571,6 +641,8 @@ int main(int argc, char **argv)
     outfile = fo;
 
     rt = JS_NewRuntime();
+    if (frozen_atoms_file && load_frozen_atoms(rt, frozen_atoms_file))
+        exit(1);
     ctx = JS_NewContext(rt);
 
     /* loader for ES6 modules */

package/deps/quickjs/quickjs.c

@@ -279,6 +279,18 @@ struct JSRuntime {
     uint32_t *atom_hash;
     JSAtomStruct **atom_array;
     int atom_free_index; /* 0 = none */
+    /* mikrojs patch: frozen atom table (JS_PreloadFrozenAtoms). Atoms below
+       frozen_atom_end serialize as final ids; hash is nonzero once loaded.
+       Ids in [frozen_first, frozen_first + frozen_count) are reserved slots
+       whose JSString bodies materialize lazily from the (flash-resident)
+       frozen_names table on first string use. */
+    uint32_t frozen_atom_end;
+    uint32_t frozen_atom_hash;
+    const char *const *frozen_names;
+    const uint32_t *frozen_lens;
+    uint32_t *frozen_sorted; /* rt-owned indexes into frozen_names, sorted */
+    uint32_t frozen_count;
+    JSAtom frozen_first;
 
     JSClassID js_class_id_alloc; /* counter for user defined classes */
     int class_count;    /* size of class_array */
@@ -790,7 +802,13 @@ typedef struct JSFunctionBytecode {
     uint8_t super_allowed : 1;
     uint8_t arguments_allowed : 1;
     uint8_t backtrace_barrier : 1; /* stop backtrace on this function */
-    /* XXX: 5 bits available */
+    /* mikrojs patch: byte_code_buf points into the (ROM) input buffer of
+       JS_ReadObject and must not be freed or written */
+    uint8_t bc_in_rom : 1;
+    /* mikrojs patch: byte_code_buf is a separate heap allocation instead of
+       the tail of the function block (in-place read fallback) */
+    uint8_t bc_separate : 1;
+    /* XXX: 3 bits available */
     uint8_t *byte_code_buf; /* (self pointer) */
     int byte_code_len;
     JSAtom func_name;
@@ -1598,6 +1616,15 @@ static void js_trigger_gc(JSRuntime *rt, size_t size)
         JS_RunGC(rt);
         rt->malloc_gc_threshold = rt->malloc_state.malloc_size +
             (rt->malloc_state.malloc_size >> 1);
+        /* mikrojs patch: never re-arm the threshold above the memory limit,
+           else a single long job whose live size exceeds ~2/3 of the limit
+           accumulates collectible garbage straight into OOM. */
+        if (rt->malloc_state.malloc_limit &&
+            rt->malloc_gc_threshold >
+                rt->malloc_state.malloc_limit - (rt->malloc_state.malloc_limit >> 3)) {
+            rt->malloc_gc_threshold =
+                rt->malloc_state.malloc_limit - (rt->malloc_state.malloc_limit >> 3);
+        }
     }
 }
 
@@ -1991,6 +2018,7 @@ JSRuntime *JS_NewRuntime2(const JSMallocFunctions *mf, void *opaque)
 
     if (JS_InitAtoms(rt))
         goto fail;
+    rt->frozen_atom_end = JS_ATOM_END;
 
     /* create the object, array and function classes */
     if (init_class_range(rt, js_std_class_def, JS_CLASS_OBJECT,
@@ -2216,6 +2244,33 @@ static inline JSAtomStruct *atom_set_free(uint32_t v)
     return (JSAtomStruct *)(((uintptr_t)v << 1) | 1);
 }
 
+/* mikrojs patch: shared placeholder occupying reserved frozen-atom slots
+   until their string materializes. Deliberately a valid, readable JSString
+   (empty, narrow, type STRING) so walkers that only inspect atom_type/kind
+   need no guard; only string-producing paths and the free/teardown loops
+   check for it. Never hashed, never refcounted, never freed. */
+static JSAtomStruct js_lazy_atom_placeholder = {
+    .header = {.ref_count = 1},
+    .len = 0,
+    .is_wide_char = 0,
+    .hash = 0,
+    .kind = JS_STRING_KIND_NORMAL,
+    .atom_type = JS_ATOM_TYPE_STRING,
+    .hash_next = 0,
+};
+
+static inline bool js_atom_is_lazy(const JSAtomStruct *p)
+{
+    return p == &js_lazy_atom_placeholder;
+}
+
+/* mikrojs patch: frozen atoms are refcount-exempt like predefined atoms;
+   the runtime pins them for its whole lifetime. */
+static inline bool js_atom_is_frozen_id(const JSRuntime *rt, JSAtom v)
+{
+    return v - rt->frozen_first < rt->frozen_count;
+}
+
 /* Note: the string contents are uninitialized */
 static JSString *js_alloc_string_rt(JSRuntime *rt, int max_len, int is_wide_char)
 {
@@ -2363,7 +2418,7 @@ void JS_FreeRuntime(JSRuntime *rt)
 
         for(i = 0; i < rt->atom_size; i++) {
             JSAtomStruct *p = rt->atom_array[i];
-            if (!atom_is_free(p) /* && p->str*/) {
+            if (!atom_is_free(p) && !js_atom_is_lazy(p) /* && p->str*/) {
                 if (i >= JS_ATOM_END || p->header.ref_count != 1) {
                     if (!header_done) {
                         header_done = true;
@@ -2418,7 +2473,7 @@ void JS_FreeRuntime(JSRuntime *rt)
     /* free the atoms */
     for(i = 0; i < rt->atom_size; i++) {
         JSAtomStruct *p = rt->atom_array[i];
-        if (!atom_is_free(p)) {
+        if (!atom_is_free(p) && !js_atom_is_lazy(p)) {
 #ifdef ENABLE_DUMPS // JS_DUMP_LEAKS
             list_del(&p->link);
 #endif
@@ -2427,6 +2482,7 @@ void JS_FreeRuntime(JSRuntime *rt)
     }
     js_free_rt(rt, rt->atom_array);
     js_free_rt(rt, rt->atom_hash);
+    js_free_rt(rt, rt->frozen_sorted);
     js_free_rt(rt, rt->shape_hash);
 #ifdef ENABLE_DUMPS // JS_DUMP_LEAKS
     if (check_dump_flag(rt, JS_DUMP_LEAKS) && !list_empty(&rt->string_list)) {
@@ -2952,7 +3008,7 @@ static __maybe_unused void JS_DumpAtoms(JSRuntime *rt)
     printf("JSAtom table: {\n");
     for(i = 0; i < rt->atom_size; i++) {
         p = rt->atom_array[i];
-        if (!atom_is_free(p)) {
+        if (!atom_is_free(p) && !js_atom_is_lazy(p)) {
             printf("  %d: { %d %08x ", i, p->atom_type, p->hash);
             if (!(p->len == 0 && p->is_wide_char != 0))
                 JS_DumpString(rt, p);
@@ -3025,7 +3081,7 @@ JSAtom JS_DupAtomRT(JSRuntime *rt, JSAtom v)
 {
     JSAtomStruct *p;
 
-    if (!__JS_AtomIsConst(v)) {
+    if (!__JS_AtomIsConst(v) && !js_atom_is_frozen_id(rt, v)) {
         p = rt->atom_array[v];
         p->header.ref_count++;
     }
@@ -3037,8 +3093,8 @@ JSAtom JS_DupAtom(JSContext *ctx, JSAtom v)
     JSRuntime *rt;
     JSAtomStruct *p;
 
-    if (!__JS_AtomIsConst(v)) {
-        rt = ctx->rt;
+    rt = ctx->rt;
+    if (!__JS_AtomIsConst(v) && !js_atom_is_frozen_id(rt, v)) {
         p = rt->atom_array[v];
         p->header.ref_count++;
     }
@@ -3091,6 +3147,133 @@ static JSAtom js_get_atom_index(JSRuntime *rt, JSAtomStruct *p)
     return i;
 }
 
+/* mikrojs patch: compare a JSString against a frozen table entry with a
+   total order (length first, then charwise numeric) matching the order
+   frozen_sorted was built with. */
+static int js_frozen_cmp_str(JSString *str, const uint8_t *name,
+                             uint32_t nlen)
+{
+    uint32_t i, len = str->len;
+    if (len != nlen)
+        return len < nlen ? -1 : 1;
+    for (i = 0; i < len; i++) {
+        uint32_t c = str->is_wide_char ? str16(str)[i] : str8(str)[i];
+        if (c != name[i])
+            return c < name[i] ? -1 : 1;
+    }
+    return 0;
+}
+
+/* mikrojs patch: find a frozen atom id by content, or JS_ATOM_NULL. */
+static JSAtom js_frozen_lookup(JSRuntime *rt, JSString *str)
+{
+    uint32_t lo = 0, hi = rt->frozen_count;
+    while (lo < hi) {
+        uint32_t mid = (lo + hi) / 2;
+        uint32_t idx = rt->frozen_sorted[mid];
+        int cmp = js_frozen_cmp_str(str, (const uint8_t *)rt->frozen_names[idx],
+                                    rt->frozen_lens[idx]);
+        if (cmp == 0)
+            return rt->frozen_first + idx;
+        if (cmp < 0)
+            hi = mid;
+        else
+            lo = mid + 1;
+    }
+    return JS_ATOM_NULL;
+}
+
+/* mikrojs patch: materialize a reserved frozen atom's JSString from the
+   flash name table and insert it into the hash. Returns NULL on OOM. */
+static JSAtomStruct *js_frozen_materialize(JSRuntime *rt, JSAtom v)
+{
+    uint32_t idx = v - rt->frozen_first;
+    const char *name = rt->frozen_names[idx];
+    uint32_t len = rt->frozen_lens[idx];
+    uint32_t h, h1;
+    JSString *p;
+
+    p = js_alloc_string_rt(rt, len, 0);
+    if (!p)
+        return NULL;
+    memcpy(str8(p), name, len);
+    str8(p)[len] = '\0';
+    h = hash_string8((const uint8_t *)name, len, JS_ATOM_TYPE_STRING);
+    h &= JS_ATOM_HASH_MASK;
+    p->hash = h;
+    p->atom_type = JS_ATOM_TYPE_STRING;
+    p->first_weak_ref = NULL;
+    rt->atom_array[v] = p;
+    h1 = h & (rt->atom_hash_size - 1);
+    p->hash_next = rt->atom_hash[h1];
+    rt->atom_hash[h1] = v;
+    rt->atom_count++;
+    if (unlikely(rt->atom_count >= rt->atom_count_resize))
+        JS_ResizeAtomHash(rt, rt->atom_hash_size * 2);
+    return p;
+}
+
+/* mikrojs patch: atom_array access that materializes reserved frozen slots
+   on demand; NULL only on OOM. */
+static JSAtomStruct *js_atom_ensure_str(JSRuntime *rt, JSAtom v)
+{
+    JSAtomStruct *p = rt->atom_array[v];
+    if (unlikely(js_atom_is_lazy(p)))
+        p = js_frozen_materialize(rt, v);
+    return p;
+}
+
+/* mikrojs patch: grow the atom array so at least one free slot exists.
+   Extracted from __JS_NewAtom so frozen-slot reservation can share it. */
+static int js_atom_grow_free(JSRuntime *rt)
+{
+    uint32_t new_size, start, i;
+    JSAtomStruct **new_array;
+    JSAtomStruct *p;
+
+    /* alloc new with size progression 3/2:
+       4 6 9 13 19 28 42 63 94 141 211 316 474 711 1066 1599 2398 3597 5395 8092
+       preallocating space for predefined atoms (at least 504).
+     */
+    new_size = max_int(711, rt->atom_size * 3 / 2);
+    if (new_size > JS_ATOM_MAX)
+        return -1;
+    /* XXX: should use realloc2 to use slack space */
+    new_array = js_realloc_rt(rt, rt->atom_array, sizeof(*new_array) * new_size);
+    if (!new_array)
+        return -1;
+    /* Note: the atom 0 is not used */
+    start = rt->atom_size;
+    if (start == 0) {
+        /* JS_ATOM_NULL entry */
+        p = js_mallocz_rt(rt, sizeof(JSAtomStruct));
+        if (!p) {
+            js_free_rt(rt, new_array);
+            return -1;
+        }
+        p->header.ref_count = 1;  /* not refcounted */
+        p->atom_type = JS_ATOM_TYPE_SYMBOL;
+#ifdef ENABLE_DUMPS // JS_DUMP_LEAKS
+        list_add_tail(&p->link, &rt->string_list);
+#endif
+        new_array[0] = p;
+        rt->atom_count++;
+        start = 1;
+    }
+    rt->atom_size = new_size;
+    rt->atom_array = new_array;
+    rt->atom_free_index = start;
+    for(i = start; i < new_size; i++) {
+        uint32_t next;
+        if (i == (new_size - 1))
+            next = 0;
+        else
+            next = i + 1;
+        rt->atom_array[i] = atom_set_free(next);
+    }
+    return 0;
+}
+
 /* string case (internal). Return JS_ATOM_NULL if error. 'str' is
    freed. */
 static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
@@ -3105,7 +3288,7 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
             /* str is the atom, return its index */
             i = js_get_atom_index(rt, str);
             /* reduce string refcount and increase atom's unless constant */
-            if (__JS_AtomIsConst(i))
+            if (__JS_AtomIsConst(i) || js_atom_is_frozen_id(rt, i))
                 str->header.ref_count--;
             return i;
         }
@@ -3121,12 +3304,23 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
                 p->atom_type == atom_type &&
                 p->len == len &&
                 js_string_memcmp(p, str, len) == 0) {
-                if (!__JS_AtomIsConst(i))
+                if (!__JS_AtomIsConst(i) && !js_atom_is_frozen_id(rt, i))
                     p->header.ref_count++;
                 goto done;
             }
             i = p->hash_next;
         }
+        /* mikrojs patch: an equal string may exist as a reserved frozen
+           atom that is not in the hash yet; materialize it instead of
+           creating a second atom with a different id */
+        if (atom_type == JS_ATOM_TYPE_STRING && rt->frozen_count != 0) {
+            i = js_frozen_lookup(rt, str);
+            if (i != JS_ATOM_NULL && js_atom_is_lazy(rt->atom_array[i])) {
+                if (!js_frozen_materialize(rt, i))
+                    goto fail;
+                goto done; /* frozen: refcount-exempt, str freed at done */
+            }
+        }
     } else {
         h1 = 0; /* avoid warning */
         if (atom_type == JS_ATOM_TYPE_SYMBOL) {
@@ -3139,49 +3333,8 @@ static JSAtom __JS_NewAtom(JSRuntime *rt, JSString *str, int atom_type)
 
     if (rt->atom_free_index == 0) {
         /* allow new atom entries */
-        uint32_t new_size, start;
-        JSAtomStruct **new_array;
-
-        /* alloc new with size progression 3/2:
-           4 6 9 13 19 28 42 63 94 141 211 316 474 711 1066 1599 2398 3597 5395 8092
-           preallocating space for predefined atoms (at least 504).
-         */
-        new_size = max_int(711, rt->atom_size * 3 / 2);
-        if (new_size > JS_ATOM_MAX)
+        if (js_atom_grow_free(rt))
             goto fail;
-        /* XXX: should use realloc2 to use slack space */
-        new_array = js_realloc_rt(rt, rt->atom_array, sizeof(*new_array) * new_size);
-        if (!new_array)
-            goto fail;
-        /* Note: the atom 0 is not used */
-        start = rt->atom_size;
-        if (start == 0) {
-            /* JS_ATOM_NULL entry */
-            p = js_mallocz_rt(rt, sizeof(JSAtomStruct));
-            if (!p) {
-                js_free_rt(rt, new_array);
-                goto fail;
-            }
-            p->header.ref_count = 1;  /* not refcounted */
-            p->atom_type = JS_ATOM_TYPE_SYMBOL;
-#ifdef ENABLE_DUMPS // JS_DUMP_LEAKS
-            list_add_tail(&p->link, &rt->string_list);
-#endif
-            new_array[0] = p;
-            rt->atom_count++;
-            start = 1;
-        }
-        rt->atom_size = new_size;
-        rt->atom_array = new_array;
-        rt->atom_free_index = start;
-        for(i = start; i < new_size; i++) {
-            uint32_t next;
-            if (i == (new_size - 1))
-                next = 0;
-            else
-                next = i + 1;
-            rt->atom_array[i] = atom_set_free(next);
-        }
     }
 
     if (str) {
@@ -3262,6 +3415,132 @@ static JSAtom __JS_NewAtomInit(JSRuntime *rt, const char *str, int len,
     return __JS_NewAtom(rt, p, atom_type);
 }
 
+typedef struct JSFrozenSortCtx {
+    const char *const *names;
+    const uint32_t *lens;
+} JSFrozenSortCtx;
+
+static int js_frozen_sort_cmp(const void *a, const void *b, void *opaque)
+{
+    JSFrozenSortCtx *c = opaque;
+    uint32_t ia = *(const uint32_t *)a, ib = *(const uint32_t *)b;
+    uint32_t la = c->lens[ia], lb = c->lens[ib];
+    int cmp;
+    if (la != lb)
+        return la < lb ? -1 : 1;
+    cmp = memcmp(c->names[ia], c->names[ib], la);
+    return cmp < 0 ? -1 : cmp > 0 ? 1 : 0;
+}
+
+/* mikrojs patch: reserve a contiguous id range for a fixed atom table so
+ * blobs compiled against the same list (in a runtime that ran the same
+ * preload) reference them by final id with no relocation at load time.
+ * The JSString bodies are NOT allocated here: reserved slots hold a shared
+ * placeholder and materialize lazily from `names` on first string use, so
+ * the boot-time heap cost is one atom_array slot per name. `names`/`lens`
+ * must outlive the runtime (e.g. rodata). The writer/reader mapping is
+ * validated via a hash over the pre-preload dynamic atoms and the table,
+ * so any divergence rejects blobs instead of silently resolving atoms to
+ * the wrong strings. Names must be raw 8-bit, unique, non-numeric strings.
+ * Must run before any dynamic atom is freed. Returns 0 on success. */
+int JS_PreloadFrozenAtoms(JSRuntime *rt, const char *const *names,
+                          const uint32_t *lens, uint32_t count)
+{
+    uint32_t i, h, slot, reserved;
+    uint32_t *sorted;
+    JSAtom first = 0;
+    JSFrozenSortCtx sctx = {names, lens};
+
+    if (rt->frozen_atom_hash != 0 || rt->frozen_count != 0)
+        return -1; /* already preloaded */
+    if (count == 0)
+        return 0;
+
+    sorted = js_malloc_rt(rt, sizeof(*sorted) * count);
+    if (!sorted)
+        return -1;
+    for (i = 0; i < count; i++)
+        sorted[i] = i;
+    rqsort(sorted, count, sizeof(*sorted), js_frozen_sort_cmp, &sctx);
+    for (i = 1; i < count; i++) {
+        if (js_frozen_sort_cmp(&sorted[i - 1], &sorted[i], &sctx) == 0)
+            goto fail_sorted; /* duplicate names break the id mapping */
+    }
+
+    /* reserve contiguous ids; the free list is sequential on a fresh
+       runtime, so pops come out ascending */
+    reserved = 0;
+    for (i = 0; i < count; i++) {
+        if (rt->atom_free_index == 0 && js_atom_grow_free(rt))
+            goto fail_slots;
+        slot = rt->atom_free_index;
+        rt->atom_free_index = atom_get_free(rt->atom_array[slot]);
+        rt->atom_array[slot] = &js_lazy_atom_placeholder;
+        if (i == 0) {
+            first = slot;
+        } else if (slot != first + i) {
+            /* atoms were freed before preload; put this stray slot back
+               first, then unwind the sequential prefix */
+            rt->atom_array[slot] = atom_set_free(rt->atom_free_index);
+            rt->atom_free_index = slot;
+            goto fail_slots;
+        }
+        reserved++;
+    }
+
+    /* hash the pre-preload dynamic atoms (identical on writer and reader
+       by construction) plus the frozen names: any divergence changes the
+       mapping, so it must change the hash */
+    h = 5381;
+    for (i = JS_ATOM_END; i < (uint32_t)first; i++) {
+        JSAtomStruct *p = rt->atom_array[i];
+        if (atom_is_free(p)) {
+            h = h * 33 ^ 0xfe;
+            continue;
+        }
+        h = h * 33 ^ p->atom_type;
+        if (p->is_wide_char) {
+            uint32_t j;
+            for (j = 0; j < p->len; j++) {
+                h = h * 33 ^ (str16(p)[j] & 0xff);
+                h = h * 33 ^ (str16(p)[j] >> 8);
+            }
+        } else {
+            uint32_t j;
+            for (j = 0; j < p->len; j++)
+                h = h * 33 ^ str8(p)[j];
+        }
+        h = h * 33 ^ 0xff;
+    }
+    for (i = 0; i < count; i++) {
+        const uint8_t *nb = (const uint8_t *)names[i];
+        uint32_t j;
+        for (j = 0; j < lens[i]; j++)
+            h = h * 33 ^ nb[j];
+        h = h * 33 ^ 0xff;
+    }
+    h = h * 33 ^ first;
+
+    rt->frozen_names = names;
+    rt->frozen_lens = lens;
+    rt->frozen_sorted = sorted;
+    rt->frozen_count = count;
+    rt->frozen_first = first;
+    rt->frozen_atom_end = first + count;
+    rt->frozen_atom_hash = h | 1; /* nonzero marks "loaded" */
+    return 0;
+
+ fail_slots:
+    /* return reserved slots to the free list */
+    for (i = 0; i < reserved; i++) {
+        rt->atom_array[first + i] = atom_set_free(rt->atom_free_index);
+        rt->atom_free_index = first + i;
+    }
+ fail_sorted:
+    js_free_rt(rt, sorted);
+    return -1;
+}
+
 // XXX: `str` must be raw 8-bit contents. No UTF-8 encoded strings
 static JSAtom __JS_FindAtom(JSRuntime *rt, const char *str, size_t len,
                             int atom_type)
@@ -3280,12 +3559,42 @@ static JSAtom __JS_FindAtom(JSRuntime *rt, const char *str, size_t len,
             p->len == len &&
             p->is_wide_char == 0 &&
             memcmp(str8(p), str, len) == 0) {
-            if (!__JS_AtomIsConst(i))
+            if (!__JS_AtomIsConst(i) && !js_atom_is_frozen_id(rt, i))
                 p->header.ref_count++;
             return i;
         }
         i = p->hash_next;
     }
+    /* mikrojs patch: a reserved frozen atom exists even before it is in
+       the hash; report it (materialized) rather than "not found" */
+    if (atom_type == JS_ATOM_TYPE_STRING && rt->frozen_count != 0) {
+        uint32_t lo = 0, hi = rt->frozen_count;
+        while (lo < hi) {
+            uint32_t mid = (lo + hi) / 2;
+            uint32_t idx = rt->frozen_sorted[mid];
+            uint32_t nlen = rt->frozen_lens[idx];
+            const uint8_t *name = (const uint8_t *)rt->frozen_names[idx];
+            int cmp;
+            if (len != nlen) {
+                cmp = len < nlen ? -1 : 1;
+            } else {
+                cmp = memcmp(str, name, len);
+                if (cmp != 0)
+                    cmp = cmp < 0 ? -1 : 1;
+            }
+            if (cmp == 0) {
+                i = rt->frozen_first + idx;
+                if (js_atom_is_lazy(rt->atom_array[i]) &&
+                    !js_frozen_materialize(rt, i))
+                    return JS_ATOM_NULL;
+                return i;
+            }
+            if (cmp < 0)
+                hi = mid;
+            else
+                lo = mid + 1;
+        }
+    }
     return JS_ATOM_NULL;
 }
 
@@ -3428,7 +3737,13 @@ static JSValue JS_NewSymbolFromAtom(JSContext *ctx, JSAtom descr,
 
     assert(!__JS_AtomIsTaggedInt(descr));
     assert(descr < rt->atom_size);
-    p = rt->atom_array[descr];
+    /* mikrojs patch: the symbol takes ownership of the description string,
+       so a reserved frozen atom must materialize first — duping the shared
+       lazy placeholder would mutate and eventually free a static. Reachable
+       via OP_private_symbol when a #private field name is a frozen atom. */
+    p = js_atom_ensure_str(rt, descr);
+    if (unlikely(!p))
+        return JS_ThrowOutOfMemory(ctx);
     js_dup(JS_MKPTR(JS_TAG_STRING, p));
     return JS_NewSymbolInternal(ctx, p, atom_type);
 }
@@ -3470,6 +3785,15 @@ static const char *JS_AtomGetStrRT(JSRuntime *rt, char *buf, int buf_size,
     } else {
         JSAtomStruct *p = rt->atom_array[atom];
         *buf = '\0';
+        if (unlikely(js_atom_is_lazy(p))) {
+            /* mikrojs patch: read straight from the frozen table; this
+               path must not allocate (used while reporting errors) */
+            uint32_t idx = atom - rt->frozen_first;
+            utf8_encode_buf8(buf, buf_size,
+                             (const uint8_t *)rt->frozen_names[idx],
+                             rt->frozen_lens[idx]);
+            return buf;
+        }
         if (atom_is_free(p)) {
             snprintf(buf, buf_size, "<free %x>", atom);
         } else if (p != NULL) {
@@ -3501,7 +3825,9 @@ static JSValue __JS_AtomToValue(JSContext *ctx, JSAtom atom, bool force_string)
         JSRuntime *rt = ctx->rt;
         JSAtomStruct *p;
         assert(atom < rt->atom_size);
-        p = rt->atom_array[atom];
+        p = js_atom_ensure_str(rt, atom);
+        if (unlikely(!p))
+            return JS_ThrowOutOfMemory(ctx);
         if (p->atom_type == JS_ATOM_TYPE_STRING) {
             goto ret_string;
         } else if (force_string) {
@@ -3540,7 +3866,12 @@ static bool JS_AtomIsArrayIndex(JSContext *ctx, uint32_t *pval, JSAtom atom)
         uint32_t val;
 
         assert(atom < rt->atom_size);
-        p = rt->atom_array[atom];
+        p = js_atom_ensure_str(rt, atom);
+        if (unlikely(!p)) {
+            /* OOM while materializing; a frozen name is not an index */
+            *pval = 0;
+            return false;
+        }
         if (p->atom_type == JS_ATOM_TYPE_STRING &&
             is_num_string(&val, p) && val != -1) {
             *pval = val;
@@ -3566,7 +3897,9 @@ static JSValue JS_AtomIsNumericIndex1(JSContext *ctx, JSAtom atom)
     if (__JS_AtomIsTaggedInt(atom))
         return js_int32(__JS_AtomToUInt32(atom));
     assert(atom < rt->atom_size);
-    p1 = rt->atom_array[atom];
+    p1 = js_atom_ensure_str(rt, atom);
+    if (unlikely(!p1))
+        return JS_ThrowOutOfMemory(ctx);
     if (p1->atom_type != JS_ATOM_TYPE_STRING)
         return JS_UNDEFINED;
     p = p1;
@@ -3649,13 +3982,13 @@ static int JS_AtomIsNumericIndex(JSContext *ctx, JSAtom atom)
 
 void JS_FreeAtom(JSContext *ctx, JSAtom v)
 {
-    if (!__JS_AtomIsConst(v))
+    if (!__JS_AtomIsConst(v) && !js_atom_is_frozen_id(ctx->rt, v))
         __JS_FreeAtom(ctx->rt, v);
 }
 
 void JS_FreeAtomRT(JSRuntime *rt, JSAtom v)
 {
-    if (!__JS_AtomIsConst(v))
+    if (!__JS_AtomIsConst(v) && !js_atom_is_frozen_id(rt, v))
         __JS_FreeAtom(rt, v);
 }
 
@@ -7144,7 +7477,7 @@ static void compute_bytecode_size(JSFunctionBytecode *b, JSMemoryUsage_helper *h
     if (b->closure_var) {
         js_func_size += b->closure_var_count * sizeof(*b->closure_var);
     }
-    if (b->byte_code_buf) {
+    if (b->byte_code_buf && !b->bc_in_rom) {
         hp->js_func_code_size += b->byte_code_len;
     }
     memory_used_count++;
@@ -7441,7 +7774,7 @@ void JS_ComputeMemoryUsage(JSRuntime *rt, JSMemoryUsage *s)
         sizeof(rt->atom_hash[0]) * rt->atom_hash_size;
     for(i = 0; i < rt->atom_size; i++) {
         JSAtomStruct *p = rt->atom_array[i];
-        if (!atom_is_free(p)) {
+        if (!atom_is_free(p) && !js_atom_is_lazy(p)) {
             s->atom_size += (sizeof(*p) + (p->len << p->is_wide_char) +
                              1 - p->is_wide_char);
         }
@@ -31238,9 +31571,19 @@ done:
     goto done;
 }
 
+/* mikrojs patch: once a module reaches EVALUATED its init function can
+   never run again; drop the bytecode so top-level-only code is reclaimed.
+   Live closures and export binding var_refs hold their own references. */
+static void js_module_release_func(JSContext *ctx, JSModuleDef *m)
+{
+    JS_FreeValue(ctx, m->func_obj);
+    m->func_obj = JS_UNDEFINED;
+}
+
 static void js_set_module_evaluated(JSContext *ctx, JSModuleDef *m)
 {
     m->status = JS_MODULE_STATUS_EVALUATED;
+    js_module_release_func(ctx, m);
     if (!JS_IsUndefined(m->promise)) {
         JSValue ret_val;
         assert(m->cycle_root == m);
@@ -31335,6 +31678,7 @@ static JSValue js_async_module_execution_rejected(JSContext *ctx, JSValueConst t
     module->eval_has_exception = true;
     module->eval_exception = js_dup(error);
     module->status = JS_MODULE_STATUS_EVALUATED;
+    js_module_release_func(ctx, module);
 
     for(i = 0; i < module->async_parent_modules_count; i++) {
         JSModuleDef *m = module->async_parent_modules[i];
@@ -31564,6 +31908,7 @@ static int js_inner_module_evaluation(JSContext *ctx, JSModuleDef *m,
             *pstack_top = m1->stack_prev;
             if (!m1->async_evaluation) {
                 m1->status = JS_MODULE_STATUS_EVALUATED;
+                js_module_release_func(ctx, m1);
             } else {
                 m1->status = JS_MODULE_STATUS_EVALUATING_ASYNC;
             }
@@ -31604,6 +31949,7 @@ static JSValue js_evaluate_module(JSContext *ctx, JSModuleDef *m)
             m1 = stack_top;
             assert(m1->status == JS_MODULE_STATUS_EVALUATING);
             m1->status = JS_MODULE_STATUS_EVALUATED;
+            js_module_release_func(ctx, m1);
             m1->eval_has_exception = true;
             m1->eval_exception = js_dup(result);
             m1->cycle_root = m; /* spec bug: should be present */
@@ -36360,6 +36706,8 @@ static void free_function_bytecode(JSRuntime *rt, JSFunctionBytecode *b)
 
     if (b->byte_code_buf)
         free_bytecode_atoms(rt, b->byte_code_buf, b->byte_code_len, true);
+    if (b->bc_separate)
+        js_free_rt(rt, b->byte_code_buf);
 
     if (b->vardefs) {
         for(i = 0; i < b->arg_count + b->var_count; i++) {
@@ -37696,6 +38044,11 @@ typedef enum BCTagEnum {
 } BCTagEnum;
 
 #define BC_VERSION 26
+/* mikrojs patch: variant of BC_VERSION for blobs whose atom references
+   below the frozen boundary are final runtime atom ids (see
+   JS_PreloadFrozenAtoms). The header carries the boundary and the frozen
+   table hash so a mismatched runtime rejects the blob at load. */
+#define BC_VERSION_FROZEN (BC_VERSION | 0x40)
 
 typedef struct BCWriterState {
     JSContext *ctx;
@@ -38432,8 +38785,16 @@ static int JS_WriteObjectAtoms(BCWriterState *s)
 
     dbuf1 = s->dbuf;
     js_dbuf_init(s->ctx, &s->dbuf);
-    bc_put_u8(s, BC_VERSION);
-    bc_put_u32(s, 0); // checksum, filled in after serialization
+    if (s->allow_bytecode && s->first_atom > JS_ATOM_END) {
+        /* mikrojs patch: frozen-atom blob; record boundary + table hash */
+        bc_put_u8(s, BC_VERSION_FROZEN);
+        bc_put_u32(s, 0); // checksum, filled in after serialization
+        bc_put_leb128(s, s->first_atom);
+        bc_put_u32(s, rt->frozen_atom_hash);
+    } else {
+        bc_put_u8(s, BC_VERSION);
+        bc_put_u32(s, 0); // checksum, filled in after serialization
+    }
 
     bc_put_leb128(s, s->idx_to_atom_count);
     for(i = 0; i < s->idx_to_atom_count; i++) {
@@ -38444,8 +38805,11 @@ static int JS_WriteObjectAtoms(BCWriterState *s)
                more efficient. */
             bc_put_u32(s, atom);
         } else {
-            JSAtomStruct *p = rt->atom_array[atom];
-            uint8_t type = p->atom_type;
+            JSAtomStruct *p = js_atom_ensure_str(rt, atom);
+            uint8_t type;
+            if (!p)
+                goto fail;
+            type = p->atom_type;
             assert(type != JS_ATOM_TYPE_PRIVATE);
             bc_put_u8(s, type);
             JS_WriteString(s, p);
@@ -38486,7 +38850,9 @@ uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst obj,
     s->allow_debug = ((flags & JS_WRITE_OBJ_STRIP_DEBUG) == 0);
     /* XXX: could use a different version when bytecode is included */
     if (s->allow_bytecode)
-        s->first_atom = JS_ATOM_END;
+        /* mikrojs patch: frozen atoms (< frozen_atom_end) serialize as
+           final ids; JS_ATOM_END when no frozen table is loaded */
+        s->first_atom = ctx->rt->frozen_atom_end;
     else
         s->first_atom = 1;
     js_dbuf_init(ctx, &s->dbuf);
@@ -38540,6 +38906,9 @@ typedef struct BCReaderState {
     bool allow_sab;
     bool allow_bytecode;
     bool allow_reference;
+    /* mikrojs patch: keep qualifying bytecode in the input buffer (which
+       must then outlive the runtime, e.g. flash rodata) */
+    bool inplace_bytecode;
     /* object references */
     JSObject **objects;
     int objects_count;
@@ -38780,6 +39149,37 @@ static uint32_t bc_get_flags(uint32_t flags, int *pidx, int n)
     return val;
 }
 
+/* mikrojs patch: true if every atom operand is already a final atom id
+   (tagged int or below first_atom), i.e. loading needs no relocation
+   writes and the instruction stream can stay in the (ROM) input buffer */
+static bool bc_bytecode_is_final(BCReaderState *s, const uint8_t *bc_buf,
+                                 uint32_t bc_len)
+{
+    uint32_t pos = 0;
+    int op, len;
+    uint32_t idx;
+
+    while (pos < bc_len) {
+        op = bc_buf[pos];
+        len = short_opcode_info(op).size;
+        switch(short_opcode_info(op).fmt) {
+        case OP_FMT_atom:
+        case OP_FMT_atom_u8:
+        case OP_FMT_atom_u16:
+        case OP_FMT_atom_label_u8:
+        case OP_FMT_atom_label_u16:
+            idx = get_u32(bc_buf + pos + 1);
+            if (!__JS_AtomIsTaggedInt(idx) && idx >= s->first_atom)
+                return false;
+            break;
+        default:
+            break;
+        }
+        pos += len;
+    }
+    return true;
+}
+
 static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
                                    int byte_code_offset, uint32_t bc_len)
 {
@@ -38788,7 +39188,50 @@ static int JS_ReadFunctionBytecode(BCReaderState *s, JSFunctionBytecode *b,
     JSAtom atom;
     uint32_t idx;
 
-    bc_buf = (uint8_t*)b + byte_code_offset;
+    if (s->inplace_bytecode) {
+        /* mikrojs patch: zero-copy when possible, else a separate heap
+           copy (the function block was allocated without a bytecode tail) */
+        if (bc_len != 0 && (uint32_t)(s->buf_end - s->ptr) >= bc_len &&
+            bc_bytecode_is_final(s, s->ptr, bc_len)) {
+            const uint8_t *rom = s->ptr;
+            /* take a reference on each atom operand so the free path
+               (free_bytecode_atoms) stays symmetric with the copy path */
+            pos = 0;
+            while (pos < (int)bc_len) {
+                op = rom[pos];
+                len = short_opcode_info(op).size;
+                switch(short_opcode_info(op).fmt) {
+                case OP_FMT_atom:
+                case OP_FMT_atom_u8:
+                case OP_FMT_atom_u16:
+                case OP_FMT_atom_label_u8:
+                case OP_FMT_atom_label_u16:
+                    idx = get_u32(rom + pos + 1);
+                    if (!__JS_AtomIsTaggedInt(idx))
+                        JS_DupAtom(s->ctx, idx);
+                    break;
+                default:
+                    break;
+                }
+                pos += len;
+            }
+            b->byte_code_buf = (uint8_t *)rom;
+            b->bc_in_rom = 1;
+            s->ptr += bc_len;
+            return 0;
+        }
+        if (bc_len == 0) {
+            b->byte_code_buf = NULL;
+            return 0;
+        }
+        bc_buf = js_mallocz(s->ctx, bc_len);
+        if (!bc_buf)
+            return s->error_state = -1;
+        b->bc_separate = 1;
+        b->byte_code_buf = bc_buf; /* owned now; freed on error paths too */
+    } else {
+        bc_buf = (uint8_t*)b + byte_code_offset;
+    }
     if (bc_get_buf(s, bc_buf, bc_len))
         return -1;
     b->byte_code_buf = bc_buf;
@@ -38958,7 +39401,10 @@ static JSValue JS_ReadFunctionTag(BCReaderState *s)
     closure_var_offset = function_size;
     function_size += bc.closure_var_count * sizeof(*bc.closure_var);
     byte_code_offset = function_size;
-    function_size += bc.byte_code_len;
+    /* mikrojs patch: in-place reads keep the bytecode out of the function
+       block (ROM pointer, or a separate heap copy on fallback) */
+    if (!s->inplace_bytecode)
+        function_size += bc.byte_code_len;
 
     b = js_mallocz(ctx, function_size);
     if (!b)
@@ -39698,7 +40144,8 @@ static int JS_ReadObjectAtoms(BCReaderState *s)
 
     if (bc_get_u8(s, &v8))
         return -1;
-    if (v8 != BC_VERSION) {
+    if (v8 != BC_VERSION &&
+        !(v8 == BC_VERSION_FROZEN && s->allow_bytecode)) {
         JS_ThrowSyntaxError(s->ctx, "invalid version (%d expected=%d)",
                             v8, BC_VERSION);
         return -1;
@@ -39711,6 +40158,22 @@ static int JS_ReadObjectAtoms(BCReaderState *s)
         JS_ThrowSyntaxError(s->ctx, "checksum error");
         return -1;
     }
+    if (v8 == BC_VERSION_FROZEN) {
+        /* mikrojs patch: atom ids below the boundary are final; require the
+           exact same frozen table the blob was compiled against */
+        uint32_t boundary, fhash;
+        JSRuntime *rt = s->ctx->rt;
+        if (bc_get_leb128(s, &boundary))
+            return -1;
+        if (bc_get_u32(s, &fhash))
+            return -1;
+        if (boundary != rt->frozen_atom_end ||
+            fhash != rt->frozen_atom_hash) {
+            JS_ThrowSyntaxError(s->ctx, "frozen atom table mismatch");
+            return -1;
+        }
+        s->first_atom = boundary;
+    }
     if (bc_get_leb128(s, &s->idx_to_atom_count))
         return -1;
     if (s->idx_to_atom_count > 1000*1000) {
@@ -39785,6 +40248,8 @@ JSValue JS_ReadObject2(JSContext *ctx, const uint8_t *buf, size_t buf_len,
     s->allow_bytecode = ((flags & JS_READ_OBJ_BYTECODE) != 0);
     s->allow_sab = ((flags & JS_READ_OBJ_SAB) != 0);
     s->allow_reference = ((flags & JS_READ_OBJ_REFERENCE) != 0);
+    s->inplace_bytecode = s->allow_bytecode &&
+        ((flags & JS_READ_OBJ_INPLACE) != 0);
     if (s->allow_bytecode)
         s->first_atom = JS_ATOM_END;
     else

package/deps/quickjs/quickjs.h

@@ -1251,6 +1251,20 @@ JS_EXTERN uint8_t *JS_WriteObject2(JSContext *ctx, size_t *psize, JSValueConst o
    writer in the same process (e.g. another Worker on the same runtime). */
 #define JS_READ_OBJ_SAB       (1 << 2) /* allow SharedArrayBuffer */
 #define JS_READ_OBJ_REFERENCE (1 << 3) /* allow object references */
+/* mikrojs patch: keep bytecode whose atom operands are all final ids
+   (predefined or frozen, see JS_PreloadFrozenAtoms) in the input buffer
+   instead of copying it to the heap. The buffer must then outlive every
+   function read from it (e.g. flash rodata / static const data). */
+#define JS_READ_OBJ_INPLACE   (1 << 4)
+
+/* mikrojs patch: reserve ids for `count` atoms right after JS_NewRuntime so
+   blobs compiled by a writer runtime with the same preload reference them
+   as final ids (enables JS_READ_OBJ_INPLACE zero-copy). Atom strings
+   materialize lazily from `names` on first string use, so `names` and
+   `lens` must outlive the runtime (e.g. rodata). Must be called before any
+   dynamic atom is freed; returns 0 on success. */
+JS_EXTERN int JS_PreloadFrozenAtoms(JSRuntime *rt, const char *const *names,
+                                    const uint32_t *lens, uint32_t count);
 JS_EXTERN JSValue JS_ReadObject(JSContext *ctx, const uint8_t *buf, size_t buf_len, int flags);
 JS_EXTERN JSValue JS_ReadObject2(JSContext *ctx, const uint8_t *buf, size_t buf_len,
                                  int flags, JSSABTab *psab_tab);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/quickjs",
-  "version": "0.17.0",
+  "version": "0.17.1-pr-300.20260731003316",
   "description": "QuickJS-NG engine source, shared CMake module, and qjsc bytecode compiler",
   "keywords": [
     "bytecode",

package/postinstall.js

@@ -8,7 +8,8 @@
  * Skips gracefully if cc or the submodule is not available.
  */
 import {execFileSync} from 'node:child_process'
-import {existsSync, mkdirSync, readFileSync, writeFileSync} from 'node:fs'
+import {createHash} from 'node:crypto'
+import {existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'node:fs'
 import {dirname, join} from 'node:path'
 import {fileURLToPath} from 'node:url'
 
@@ -51,6 +52,21 @@ try {
   // Not a git repo (e.g. published package), skip commit tracking
 }
 
+// Patches change qjsc behavior without moving the submodule commit, so the
+// rebuild stamp must cover them too or bin/qjsc goes stale silently.
+if (currentCommit) {
+  const patchesDir = join(__dirname, 'patches')
+  if (existsSync(patchesDir)) {
+    const hash = createHash('sha256')
+    for (const f of readdirSync(patchesDir)
+      .filter((f) => f.endsWith('.patch'))
+      .sort()) {
+      hash.update(readFileSync(join(patchesDir, f)))
+    }
+    currentCommit += `+${hash.digest('hex').slice(0, 16)}`
+  }
+}
+
 // On Windows the C compiler appends .exe automatically.
 const exeSuffix = process.platform === 'win32' ? '.exe' : ''
 const qjscPath = join(binDir, `qjsc${exeSuffix}`)

package/quickjs.cmake

@@ -28,6 +28,35 @@ endif()
 get_filename_component(_QUICKJS_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
 set(QUICKJS_INCLUDE_DIR "${_QUICKJS_CMAKE_DIR}/deps/quickjs")
 
+# Sync the patched QuickJS tree AND the qjsc compiler before anything
+# compiles or generates bytecode. postinstall covers `pnpm install`, but a
+# patch file added or edited after install was previously a silent no-op:
+# the tree built unpatched and the full test suite ran against code the
+# patch never touched. Running postinstall (not just apply-patches) matters
+# because qjsc is compiled FROM the patched sources: a stale qjsc paired
+# with a fresh runtime emits bytecode the runtime rejects at import time
+# (frozen atom table mismatch) — a runtime failure born from a green build.
+# Both steps are stamp-guarded, so the no-change case is cheap; the GLOB's
+# CONFIGURE_DEPENDS reruns configure when the patch set changes, and
+# CMAKE_CONFIGURE_DEPENDS reruns it when patch contents change.
+#
+# Guarded for CMake script mode: ESP-IDF's early component-requirements
+# pass includes component CMakeLists (and through them this file) via
+# script-mode CMake, where CONFIGURE_DEPENDS globs and directory
+# properties are hard errors. The real project-mode configure that
+# follows runs the sync; the requirements pass only needs the variables.
+if(NOT CMAKE_SCRIPT_MODE_FILE)
+    file(GLOB _QUICKJS_PATCHES CONFIGURE_DEPENDS "${_QUICKJS_CMAKE_DIR}/patches/*.patch")
+    set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${_QUICKJS_PATCHES})
+    execute_process(
+        COMMAND node "${_QUICKJS_CMAKE_DIR}/postinstall.js"
+        RESULT_VARIABLE _QUICKJS_PATCH_RC
+    )
+    if(NOT _QUICKJS_PATCH_RC EQUAL 0)
+        message(FATAL_ERROR "quickjs.cmake: syncing QuickJS patches/qjsc failed (see output above)")
+    endif()
+endif()
+
 # Source files
 set(QUICKJS_SOURCES
     "${QUICKJS_INCLUDE_DIR}/quickjs.c"