@mikrojs/quickjs 0.14.0 → 0.15.0-next.20260614113448

package/apply-patches.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+/**
+ * Apply mikrojs-local QuickJS patches to the submodule working tree.
+ *
+ * Patches live in patches/*.patch and are applied idempotently: if
+ * `git apply --reverse --check` succeeds the patch is already present.
+ *
+ * Importable (`applyPatches()`) and runnable (`node apply-patches.js`).
+ * The release publish job runs it explicitly: that job installs with
+ * --ignore-scripts, so the postinstall that normally applies the patch
+ * never runs. Without this the packed @mikrojs/quickjs tarball ships
+ * unpatched QuickJS source and every consumer fails to compile
+ * @mikrojs/native (which calls the patched module-management symbols).
+ */
+import {execFileSync} from 'node:child_process'
+import {existsSync, readdirSync} from 'node:fs'
+import {dirname, join} from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const qjsDir = join(__dirname, 'deps', 'quickjs')
+const patchesDir = join(__dirname, 'patches')
+
+export function applyPatches() {
+  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?
+    try {
+      execFileSync('git', ['apply', '--reverse', '--check', patch], {
+        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)
+      process.exit(1)
+    }
+  }
+}
+
+// Run directly: sync the submodule, then apply patches.
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  const repoRoot = join(__dirname, '..', '..', '..')
+  try {
+    execFileSync(
+      'git',
+      ['submodule', 'update', '--init', 'packages/@mikrojs/quickjs/deps/quickjs'],
+      {
+        cwd: repoRoot,
+        stdio: 'inherit',
+      },
+    )
+  } catch {
+    if (!existsSync(join(qjsDir, 'quickjs.c'))) {
+      console.error(
+        '@mikrojs/quickjs: Failed to initialize QuickJS submodule.\n' +
+          'Run manually: git submodule update --init packages/@mikrojs/quickjs/deps/quickjs',
+      )
+      process.exit(1)
+    }
+  }
+  applyPatches()
+}

package/deps/quickjs/quickjs.c

@@ -29724,6 +29724,48 @@ static void js_free_module_def(JSContext *ctx, JSModuleDef *m)
     js_free(ctx, m);
 }
 
+/* mikrojs patch: public wrapper to free a single module (remove it from
+ * the context's loaded-modules cache and release all its resources).
+ * Callers must ensure the module is not mid-linking or mid-evaluating and
+ * that no other modules hold live import bindings to its exports (or accept
+ * that such bindings remain valid via refcounted JSVarRefs). */
+void JS_FreeModule(JSContext *ctx, JSModuleDef *m)
+{
+    js_free_module_def(ctx, m);
+}
+
+static JSModuleDef *js_find_loaded_module(JSContext *ctx, JSAtom name);
+
+/* mikrojs patch: lookup a module in the context cache by name atom.
+ * Returns NULL if no module with that name is loaded. */
+JSModuleDef *JS_FindLoadedModule(JSContext *ctx, JSAtom name)
+{
+    return js_find_loaded_module(ctx, name);
+}
+
+/* mikrojs patch: return the module's current status as an integer.
+ * 0=UNLINKED, 1=LINKING, 2=LINKED, 3=EVALUATING, 4=EVALUATING_ASYNC, 5=EVALUATED. */
+int JS_GetModuleStatus(JSContext *ctx, JSModuleDef *m)
+{
+    (void)ctx;
+    return (int)m->status;
+}
+
+/* mikrojs patch: find the loaded module whose namespace object is `ns`.
+ * Reverse of JS_GetModuleNamespace. Returns NULL if `ns` is not the
+ * namespace of any loaded module (or its namespace has not been built). */
+JSModuleDef *JS_FindModuleByNamespace(JSContext *ctx, JSValueConst ns)
+{
+    struct list_head *el;
+    list_for_each(el, &ctx->loaded_modules) {
+        JSModuleDef *m = list_entry(el, JSModuleDef, link);
+        if (!JS_IsUndefined(m->module_ns) &&
+            JS_VALUE_GET_PTR(m->module_ns) == JS_VALUE_GET_PTR(ns))
+            return m;
+    }
+    return NULL;
+}
+
 #ifndef QJS_DISABLE_PARSER
 
 static int add_req_module_entry(JSContext *ctx, JSModuleDef *m,

package/deps/quickjs/quickjs.h

@@ -1190,6 +1190,26 @@ JS_EXTERN JSValue JS_GetImportMeta(JSContext *ctx, JSModuleDef *m);
 JS_EXTERN JSAtom JS_GetModuleName(JSContext *ctx, JSModuleDef *m);
 JS_EXTERN JSValue JS_GetModuleNamespace(JSContext *ctx, JSModuleDef *m);
 
+/* mikrojs patch: evict a module from the context, releasing all its
+ * resources. Caller is responsible for ensuring the module is in a safe
+ * state (not linking, not evaluating). */
+JS_EXTERN void JS_FreeModule(JSContext *ctx, JSModuleDef *m);
+
+/* mikrojs patch: lookup a module in the context cache by name atom.
+ * Returns NULL if no module with that name is loaded. */
+JS_EXTERN JSModuleDef *JS_FindLoadedModule(JSContext *ctx, JSAtom name);
+
+/* mikrojs patch: return the module's current status.
+ * 0=UNLINKED, 1=LINKING, 2=LINKED, 3=EVALUATING, 4=EVALUATING_ASYNC, 5=EVALUATED.
+ * Constants deliberately omitted here because the internal QuickJS enum
+ * reuses the same symbol names; callers define their own mirrored names. */
+JS_EXTERN int JS_GetModuleStatus(JSContext *ctx, JSModuleDef *m);
+
+/* mikrojs patch: find the loaded module whose namespace object is `ns`
+ * (reverse of JS_GetModuleNamespace). Returns NULL if `ns` is not a loaded
+ * module's namespace. */
+JS_EXTERN JSModuleDef *JS_FindModuleByNamespace(JSContext *ctx, JSValueConst ns);
+
 /* associate a JSValue to a C module */
 JS_EXTERN int JS_SetModulePrivateValue(JSContext *ctx, JSModuleDef *m, JSValue val);
 JS_EXTERN JSValue JS_GetModulePrivateValue(JSContext *ctx, JSModuleDef *m);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikrojs/quickjs",
-  "version": "0.14.0",
+  "version": "0.15.0-next.20260614113448",
   "description": "QuickJS-NG engine source, shared CMake module, and qjsc bytecode compiler",
   "keywords": [
     "bytecode",
@@ -19,6 +19,7 @@
     "url": "git+https://github.com/mikrojs/mikro.git"
   },
   "files": [
+    "apply-patches.js",
     "deps/quickjs/*.c",
     "deps/quickjs/*.h",
     "deps/quickjs/LICENSE",
@@ -36,6 +37,8 @@
     "node": ">=24.0.0"
   },
   "scripts": {
-    "postinstall": "node postinstall.js"
+    "apply-patches": "node apply-patches.js",
+    "postinstall": "node postinstall.js",
+    "verify-patches": "node verify-patches.js"
   }
 }

package/postinstall.js

@@ -8,14 +8,15 @@
  * Skips gracefully if cc or the submodule is not available.
  */
 import {execFileSync} from 'node:child_process'
-import {existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'node:fs'
+import {existsSync, mkdirSync, readFileSync, writeFileSync} from 'node:fs'
 import {dirname, join} from 'node:path'
 import {fileURLToPath} from 'node:url'
 
+import {applyPatches} from './apply-patches.js'
+
 const __dirname = dirname(fileURLToPath(import.meta.url))
 const binDir = join(__dirname, 'bin')
 const qjsDir = join(__dirname, 'deps', 'quickjs')
-const patchesDir = join(__dirname, 'patches')
 const repoRoot = join(__dirname, '..', '..', '..')
 
 // Always sync submodule to the pinned commit
@@ -40,33 +41,6 @@ try {
 // patch is already present, skip it.
 applyPatches()
 
-function applyPatches() {
-  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?
-    try {
-      execFileSync('git', ['apply', '--reverse', '--check', patch], {
-        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)
-      process.exit(1)
-    }
-  }
-}
-
 // Determine the current submodule commit to detect changes
 let currentCommit = ''
 try {