quickjs-zig 1.0.0

package/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "quickjs"]
+	path = quickjs
+	url = https://github.com/bellard/quickjs

package/README.md

@@ -0,0 +1,147 @@
+# QuickJS-Zig ⚡
+
+A high-performance build system for **QuickJS**, powered by the **Zig** compiler. This project allows you to compile JavaScript applications into standalone native binaries for Windows, Linux, and macOS with zero system dependencies.
+
+## Features
+
+* **Zero Config Cross-Compilation**: Build for Windows, Linux, and macOS from any host (Intel or Apple Silicon).
+* **Zig-Powered**: Uses **Zig 0.15.2** as a C compiler for modern, safe, and highly optimized binaries.
+* **Custom C Modules**: Easily inject and register your own C modules into the QuickJS engine.
+* **Native Windows Support**: Includes a custom `exec` implementation for Windows, bypassing typical QuickJS POSIX limitations.
+* **Clean Source Management**: Automatically patches and restores QuickJS source files to keep the core library pristine.
+
+---
+
+## Installation
+
+Add `quickjs-zig` as a development dependency in your project:
+
+```bash
+npm install --save-dev quickjs-zig
+
+```
+
+> **Note**: During installation, the `postinstall` script will automatically download the appropriate Zig 0.15.2 binary for your platform and initialize the QuickJS submodules.
+
+### Development / Local setup
+
+If you want to contribute or test the latest version from source:
+
+```bash
+git clone https://github.com/eid-app/quickjs-zig.git
+cd quickjs-zig
+npm install
+npm link
+
+```
+
+---
+
+## Configuration
+
+Configure your entry point and custom C modules in your project's `package.json`:
+
+```json
+{
+  "name": "my-app",
+  "quickJs": {
+    "input": "app/index.mjs",
+    "modules": {
+      "my_module": "src/my_module.c"
+    }
+  }
+}
+
+```
+
+* **`input`**: The entry point of your JavaScript application (defaults to `app/index.mjs`).
+* **`modules`**: A key-value map of custom C modules (Module Name -> C Source Path).
+
+---
+
+## Example Usage
+
+### 1. Create a C Module (`src/my_module.c`)
+
+This module will be automatically compiled and linked into your final binary.
+
+```c
+#include "quickjs-libc.h"
+
+// A simple native function
+static JSValue js_hello(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv) {
+    return JS_NewString(ctx, "Hello from the native side!");
+}
+
+// Module initialization
+JSModuleDef *js_init_module_my_module(JSContext *ctx, const char *module_name) {
+    JSModuleDef *m = JS_NewCModule(ctx, module_name, NULL);
+    if (!m) return NULL;
+    JS_AddModuleExport(ctx, m, "hello");
+    JS_SetModuleExport(ctx, m, "hello", JS_NewCFunction(ctx, js_hello, "hello", 0));
+    return m;
+}
+
+```
+
+### 2. Create your JavaScript (`app/index.mjs`)
+
+Import your custom module just like any other ES module.
+
+```javascript
+import { hello } from 'my_module';
+import * as os from 'os';
+
+// Use the native function
+const message = hello();
+console.log(message);
+
+// Standard QuickJS modules are also fully supported
+console.log(`Platform: ${os.platform}`);
+
+```
+
+### 3. Build your binaries
+
+Run the build command to generate tools and standalone binaries for all targets:
+
+```bash
+npx quickjs-zig build
+
+```
+
+---
+
+## Supported Targets
+
+The build system generates binaries for the following platforms in the `dist/` folder:
+
+| Platform | Architecture | Target ID | Binary Name |
+| --- | --- | --- | --- |
+| **Windows** | x64 / x86 | `x86_64-windows-gnu` / `x86-windows-gnu` | `app_win64.exe` / `app_win32.exe` |
+| **Linux** | x64 / x86 / ARM64 | `x86_64-linux-gnu` / `x86-linux-gnu` / `aarch64-linux-gnu` | `app_linux64` / `app_linux32` / `app_linux_arm64` |
+| **macOS** | Apple / Intel | `aarch64-macos` / `x86_64-macos` | `app_mac_arm` / `app_mac_intel` |
+
+---
+
+## Technical Details
+
+### Why Zig?
+
+Zig is not just a language; it's a powerful C/C++ toolchain. It allows `quickjs-zig` to:
+
+* Cross-compile to Windows (MinGW) from macOS/Linux without installing complex toolchains.
+* Provide a consistent `libc` environment across different platforms.
+* Produce small, fast, and statically linked binaries.
+
+### Windows Patching
+
+QuickJS is designed for POSIX systems. This tool automatically patches `quickjs-libc.c` during the build process to provide a working `os.exec` on Windows using a native `_spawnvp` implementation.
+
+---
+
+## License
+
+MIT - Created by **eid-app**.
+
+---

package/build.mjs

@@ -0,0 +1,175 @@
+import { execSync } from 'child_process';
+import { writeFileSync, mkdirSync, unlinkSync, existsSync, readdirSync, cpSync, readFileSync, renameSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+
+// --- PATH CONFIGURATION ---
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const USER_CWD = process.cwd();
+
+// Load the user project's package.json
+const USER_PKG_PATH = path.join(USER_CWD, 'package.json');
+if (!existsSync(USER_PKG_PATH)) {
+    console.error("❌ Error: package.json not found in current directory.");
+    process.exit(1);
+}
+
+const userPackageJson = JSON.parse(readFileSync(USER_PKG_PATH, 'utf8'));
+const customModules = userPackageJson.quickJs?.modules || {};
+const APP_NAME = userPackageJson.name || 'app';
+
+// Input file from package.json or default to app/index.mjs
+const INPUT_FILE_RELATIVE = userPackageJson.quickJs?.input || 'app/index.mjs';
+const INPUT_FILE_ABS = path.resolve(USER_CWD, INPUT_FILE_RELATIVE);
+
+if (!existsSync(INPUT_FILE_ABS)) {
+    console.error(`❌ Error: Input file not found at ${INPUT_FILE_ABS}`);
+    process.exit(1);
+}
+
+const QUICKJS_DIR = path.resolve(__dirname, 'quickjs');
+const ZIG_PATH = path.resolve(__dirname, 'bin', 'zig', os.platform() === 'win32' ? 'zig.exe' : 'zig');
+const VERSION = '2024-01-13';
+const BIN_DIR = path.join(USER_CWD, 'bin');
+const DIST_DIR = path.join(USER_CWD, 'dist');
+
+const LIBC_PATH = path.join(QUICKJS_DIR, 'quickjs-libc.c');
+const LIBC_BAK = path.join(QUICKJS_DIR, 'quickjs-libc.c.bak');
+const QJS_C_PATH = path.join(QUICKJS_DIR, 'qjs.c');
+const QJS_C_BAK = path.join(QUICKJS_DIR, 'qjs.c.bak');
+const QJSC_C_PATH = path.join(QUICKJS_DIR, 'qjsc.c');
+const QJSC_C_BAK = path.join(QUICKJS_DIR, 'qjsc.c.bak');
+const EXEC_SRC_PATH = path.resolve(__dirname, 'src', 'exec.c');
+
+if (!existsSync(BIN_DIR)) mkdirSync(BIN_DIR, { recursive: true });
+if (!existsSync(DIST_DIR)) mkdirSync(DIST_DIR, { recursive: true });
+
+// Detect the host architecture to find the correct qjsc binary
+const platform = os.platform();
+const arch = os.arch();
+let hostQjscName = '';
+
+if (platform === 'darwin') hostQjscName = (arch === 'arm64') ? 'qjsc_mac_arm' : 'qjsc_mac_intel';
+else if (platform === 'linux') hostQjscName = (arch === 'arm64' || arch === 'aarch64') ? 'qjsc_linux_arm' : 'qjsc_linux64';
+else if (platform === 'win32') hostQjscName = 'qjsc_win64.exe';
+
+const hostQjscPath = path.join(BIN_DIR, hostQjscName);
+
+// ==========================================================
+// STAGE 0: PATCHING
+// ==========================================================
+console.log("=== STAGE 0: PATCHING QUICKJS SOURCES ===");
+
+if (existsSync(LIBC_PATH)) {
+    if (!existsSync(LIBC_BAK)) cpSync(LIBC_PATH, LIBC_BAK);
+    let content = readFileSync(LIBC_PATH, 'utf8');
+
+    if (!content.includes('#include <process.h>')) {
+        content = '#if defined(_WIN32)\n#include <process.h>\n#endif\n' + content;
+    }
+
+    for (const name of Object.keys(customModules)) {
+        const decl = `JSModuleDef *js_init_module_${name}(JSContext *ctx, const char *module_name);`;
+        if (!content.includes(decl)) content = content.replace('#include "quickjs-libc.h"', `#include "quickjs-libc.h"\n\n${decl}`);
+    }
+
+    if (existsSync(EXEC_SRC_PATH)) {
+        const execImpl = readFileSync(EXEC_SRC_PATH, 'utf8');
+        if (!content.includes('js_os_exec_win32')) {
+            content = content.replace('static JSClassDef js_worker_class = {', execImpl + '\nstatic JSClassDef js_worker_class = {');
+        }
+        const oldEntry = '    JS_CFUNC_DEF("exec", 1, js_os_exec ),';
+        const newEntry = `#if defined(_WIN32)\n    JS_CFUNC_DEF("exec", 1, js_os_exec_win32 ),\n#else\n    JS_CFUNC_DEF("exec", 1, js_os_exec ),\n#endif`;
+        if (content.includes(oldEntry)) content = content.replace(oldEntry, newEntry);
+    }
+    writeFileSync(LIBC_PATH, content);
+    console.log("✅ quickjs-libc.c patched.");
+}
+
+[ [QJS_C_PATH, QJS_C_BAK], [QJSC_C_PATH, QJSC_C_BAK] ].forEach(([p, b]) => {
+    if (!existsSync(p)) return;
+    if (!existsSync(b)) cpSync(p, b);
+    let content = readFileSync(p, 'utf8');
+    const isQjsc = p.includes('qjsc.c');
+
+    for (const name of Object.keys(customModules)) {
+        if (isQjsc) {
+            const entry = `namelist_add(&cmodule_list, "${name}", "${name}", 0);`;
+            if (!content.includes(entry)) content = content.replace('namelist_add(&cmodule_list, "os", "os", 0);', `namelist_add(&cmodule_list, "os", "os", 0);\n    ${entry}`);
+        } else {
+            const decl = `JSModuleDef *js_init_module_${name}(JSContext *ctx, const char *module_name);`;
+            const call = `js_init_module_${name}(ctx, "${name}");`;
+            if (!content.includes(decl)) content = content.replace('#include "quickjs-libc.h"', `#include "quickjs-libc.h"\n\n${decl}`);
+            if (!content.includes(call)) content = content.replace('js_init_module_os(ctx, "os");', `js_init_module_os(ctx, "os");\n    ${call}`);
+        }
+    }
+    writeFileSync(p, content);
+    console.log(`✅ ${path.basename(p)} patched.`);
+});
+
+const baseSources = ['quickjs.c', 'libregexp.c', 'libunicode.c', 'cutils.c', 'quickjs-libc.c', 'dtoa.c']
+    .map(f => path.join(QUICKJS_DIR, f))
+    .concat(Object.values(customModules).map(f => path.resolve(USER_CWD, f)))
+    .join(' ');
+
+const targets = [
+  { id: 'x86_64-windows-gnu', qjs: 'qjs_win64.exe', qjsc: 'qjsc_win64.exe', app: `${APP_NAME}_win64.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE' },
+  { id: 'x86-windows-gnu',    qjs: 'qjs_win32.exe', qjsc: 'qjsc_win32.exe', app: `${APP_NAME}_win32.exe`, libs: '-lm', cflags: '-D_GNU_SOURCE' },
+  { id: 'x86_64-linux-gnu',   qjs: 'qjs_linux64',   qjsc: 'qjsc_linux64',   app: `${APP_NAME}_linux64`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
+  { id: 'x86-linux-gnu',     qjs: 'qjs_linux32',   qjsc: 'qjsc_linux32',   app: `${APP_NAME}_linux32`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
+  { id: 'aarch64-linux-gnu',  qjs: 'qjs_linux_arm64', qjsc: 'qjsc_linux_arm64', app: `${APP_NAME}_linux_arm64`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
+  { id: 'aarch64-macos',      qjs: 'qjs_mac_arm',   qjsc: 'qjsc_mac_arm',   app: `${APP_NAME}_mac_arm`,   libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' },
+  { id: 'x86_64-macos',       qjs: 'qjs_mac_intel', qjsc: 'qjsc_mac_intel', app: `${APP_NAME}_mac_intel`, libs: '-lm -lpthread -ldl', cflags: '-D_GNU_SOURCE -DCONFIG_PTHREAD' }
+];
+
+// ==========================================================
+// STAGE 1 & 2: TOOLS AND APPLICATION COMPILATION
+// ==========================================================
+const stubPath = path.join(QUICKJS_DIR, 'repl_stub.c');
+writeFileSync(stubPath, `const unsigned char qjsc_repl[] = {0}; const unsigned int qjsc_repl_size = 0;`);
+
+targets.forEach(t => {
+    console.log(`\n--- Compiling for: ${t.id} ---`);
+    const cmdBase = `${ZIG_PATH} cc -target ${t.id} -I${QUICKJS_DIR} -O2 ${t.cflags} -Wno-ignored-attributes -DCONFIG_VERSION=\\"${VERSION}\\" ${t.libs} -s`;
+
+    try {
+        execSync(`${cmdBase} -o "${path.join(BIN_DIR, t.qjs)}" ${baseSources} ${stubPath} "${path.join(QUICKJS_DIR, 'qjs.c')}"`);
+        execSync(`${cmdBase} -o "${path.join(BIN_DIR, t.qjsc)}" ${baseSources} "${path.join(QUICKJS_DIR, 'qjsc.c')}"`);
+        console.log(`✅ Build tools generated.`);
+
+        const tempC = path.join(BIN_DIR, `${t.id}_app.c`);
+        const relativeInput = path.relative(USER_CWD, INPUT_FILE_ABS);
+
+        execSync(`"${hostQjscPath}" -e -o "${tempC}" "${relativeInput}"`, { cwd: USER_CWD });
+
+        execSync(`${cmdBase} -o "${path.join(DIST_DIR, t.app)}" "${tempC}" ${baseSources} -I${QUICKJS_DIR}`);
+        console.log(`✅ Binary built: ${t.app}`);
+    } catch (e) {
+        console.error(`❌ Compilation failed for ${t.id}`);
+        console.error(e.stderr?.toString() || e.message);
+    }
+});
+
+// ==========================================================
+// STAGE 3: CLEANUP
+// ==========================================================
+console.log("\n=== STAGE 3: CLEANUP ===");
+
+// Remove all generated .c files in the bin directory
+const binFiles = readdirSync(BIN_DIR);
+binFiles.forEach(file => {
+    if (file.endsWith('_app.c')) {
+        unlinkSync(path.join(BIN_DIR, file));
+        console.log(`🗑️ Removed temporary source: ${file}`);
+    }
+});
+
+[ [LIBC_BAK, LIBC_PATH], [QJS_C_BAK, QJS_C_PATH], [QJSC_C_BAK, QJSC_C_PATH] ].forEach(([b, s]) => {
+    if (existsSync(b)) {
+        renameSync(b, s);
+        console.log(`🔄 Restored original: ${path.basename(s)}`);
+    }
+});
+if (existsSync(stubPath)) unlinkSync(stubPath);
+console.log("🚀 Build process complete.");

package/index.mjs

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+/**
+ * quickjs-zig CLI Dispatcher
+ * This script is the entry point when running 'npx quickjs-zig'
+ */
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import path from 'path';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function run() {
+    switch (command) {
+        case 'build':
+            console.log("🛠️  quickjs-zig: Starting build process...");
+
+            // On appelle build.mjs en lui passant le reste des arguments
+            const buildScript = path.join(__dirname, 'build.mjs');
+            const child = spawn('node', [buildScript, ...args.slice(1)], {
+                stdio: 'inherit',
+                shell: true
+            });
+
+            child.on('exit', (code) => {
+                if (code === 0) {
+                    console.log("✅ Build completed successfully.");
+                }
+                process.exit(code);
+            });
+            break;
+
+        case 'help':
+        case undefined:
+            console.log(`
+quickjs-zig - Native Binary Compiler for QuickJS
+
+Usage:
+  npx quickjs-zig <command> [options]
+
+Commands:
+  build    Compiles your project into native binaries based on package.json
+  help     Shows this help message
+
+Example:
+  npx quickjs-zig build
+            `);
+            break;
+
+        default:
+            console.log(`❌ Unknown command: "${command}"`);
+            console.log("Type 'npx quickjs-zig help' for usage.");
+            process.exit(1);
+    }
+}
+
+run();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "quickjs-zig",
+  "version": "1.0.0",
+  "description": "A generic build engine to compile QuickJS scripts into standalone native binaries using Zig for multi-platform cross-compilation.",
+  "type": "module",
+  "main": "index.mjs",
+  "bin": {
+    "quickjs-zig": "index.mjs"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.mjs"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "quickjs",
+    "zig",
+    "compiler",
+    "native-binaries",
+    "cross-compilation",
+    "c-modules"
+  ],
+  "author": "eid-app",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eid-app/quickjs-zig.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eid-app/quickjs-zig/issues"
+  },
+  "homepage": "https://github.com/eid-app/quickjs-zig#readme"
+}

package/postinstall.mjs

@@ -0,0 +1,116 @@
+import { execSync } from 'child_process';
+import { mkdirSync, existsSync, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import path from 'path';
+import os from 'os';
+import https from 'https';
+import { fileURLToPath } from 'url';
+
+// --- CONFIGURATION ---
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ZIG_VERSION = '0.15.2';
+const BIN_DIR = path.resolve(__dirname, 'bin', 'zig');
+
+// Mapping for Zig download URLs
+const platformMap = {
+    win32: 'windows',
+    darwin: 'macos',
+    linux: 'linux'
+};
+
+const archMap = {
+    x64: 'x86_64',
+    arm64: 'aarch64'
+};
+
+const platform = platformMap[os.platform()];
+const arch = archMap[os.arch()];
+
+if (!platform || !arch) {
+    console.error(`❌ Unsupported platform/arch: ${os.platform()} ${os.arch()}`);
+    process.exit(1);
+}
+
+// Fixed: Correct Zig URL order is arch-platform (e.g., x86_64-macos)
+const zigTarget = `${arch}-${platform}`;
+const zigFileName = `zig-${zigTarget}-${ZIG_VERSION}.${platform === 'windows' ? 'zip' : 'tar.xz'}`;
+const zigUrl = `https://ziglang.org/download/${ZIG_VERSION}/${zigFileName}`;
+
+const ZIG_BIN_PATH = path.join(BIN_DIR, platform === 'windows' ? 'zig.exe' : 'zig');
+
+// --- DOWNLOAD HELPER ---
+const downloadFile = (url, dest) => {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode === 302 || res.statusCode === 301) {
+                return downloadFile(res.headers.location, dest).then(resolve).catch(reject);
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`Failed to download: ${res.statusCode}`));
+                return;
+            }
+            const chunks = [];
+            res.on('data', chunk => chunks.push(chunk));
+            res.on('end', () => {
+                writeFileSync(dest, Buffer.concat(chunks));
+                resolve();
+            });
+        }).on('error', reject);
+    });
+};
+
+// --- MAIN EXECUTION ---
+async function install() {
+    console.log("=== POSTINSTALL: INITIALIZING PROJECT DEPENDENCIES ===");
+
+    // 1. Initialize Git Submodules (QuickJS source)
+    try {
+        console.log("📂 Initializing git submodules...");
+        execSync('git submodule update --init --recursive', { stdio: 'inherit' });
+        console.log("✅ Submodules initialized.");
+    } catch (err) {
+        console.warn("⚠️ Git submodule update failed. Ensure you are in a git repository or have QuickJS sources.");
+    }
+
+    // 2. Install Zig Compiler
+    if (existsSync(ZIG_BIN_PATH)) {
+        console.log(`✅ Zig ${ZIG_VERSION} already installed.`);
+        return;
+    }
+
+    if (!existsSync(BIN_DIR)) mkdirSync(BIN_DIR, { recursive: true });
+
+    console.log(`📥 Downloading Zig ${ZIG_VERSION} for ${zigTarget}...`);
+    const archivePath = path.join(BIN_DIR, zigFileName);
+
+    try {
+        await downloadFile(zigUrl, archivePath);
+        console.log(`📦 Extracting ${zigFileName}...`);
+
+        if (platform === 'windows') {
+            // Extraction using PowerShell for Windows
+            execSync(`powershell -command "Expand-Archive -Path '${archivePath}' -DestinationPath '${BIN_DIR}' -Force"`);
+            // Zig extracts into a subfolder named 'zig-windows-x86_64-0.15.2', let's flatten it
+            const subDir = path.join(BIN_DIR, `zig-${zigTarget}-${ZIG_VERSION}`);
+            if (existsSync(subDir)) {
+                execSync(`powershell -command "Move-Item -Path '${subDir}\\*' -Destination '${BIN_DIR}' -Force"`);
+            }
+        } else {
+            // Extraction for Unix with strip-components to avoid nested folder
+            execSync(`tar -xJf "${archivePath}" -C "${BIN_DIR}" --strip-components=1`);
+        }
+
+        // Cleanup
+        if (existsSync(archivePath)) unlinkSync(archivePath);
+
+        if (platform !== 'windows') {
+            chmodSync(ZIG_BIN_PATH, 0o755);
+        }
+
+        console.log(`🚀 Zig ${ZIG_VERSION} installed successfully at ${ZIG_BIN_PATH}`);
+    } catch (err) {
+        console.error(`❌ Installation failed: ${err.message}`);
+        process.exit(1);
+    }
+}
+
+install();

package/src/exec.c

@@ -0,0 +1,183 @@
+#if defined(_WIN32)
+#include <fcntl.h>
+#include <io.h>
+
+/* Helper to build the environment block for Windows */
+static char **build_envp(JSContext *ctx, JSValueConst obj)
+{
+    uint32_t len, i;
+    JSPropertyEnum *tab;
+    char **envp, *pair;
+    const char *key, *str;
+    JSValue val;
+    size_t key_len, str_len;
+
+    if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
+                               JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
+        return NULL;
+
+    envp = js_mallocz(ctx, sizeof(envp[0]) * ((size_t)len + 1));
+    if (!envp)
+        goto fail;
+
+    for(i = 0; i < len; i++) {
+        val = JS_GetProperty(ctx, obj, tab[i].atom);
+        if (JS_IsException(val))
+            goto fail;
+        str = JS_ToCString(ctx, val);
+        JS_FreeValue(ctx, val); // OK: 2 arguments
+        if (!str)
+            goto fail;
+
+        key = JS_AtomToCString(ctx, tab[i].atom);
+        if (!key) {
+            JS_FreeCString(ctx, str);
+            goto fail;
+        }
+
+        key_len = strlen(key);
+        str_len = strlen(str);
+        pair = js_malloc(ctx, key_len + str_len + 2);
+        if (!pair) {
+            JS_FreeCString(ctx, key);
+            JS_FreeCString(ctx, str);
+            goto fail;
+        }
+
+        memcpy(pair, key, key_len);
+        pair[key_len] = '=';
+        memcpy(pair + key_len + 1, str, str_len);
+        pair[key_len + 1 + str_len] = '\0';
+        envp[i] = pair;
+
+        JS_FreeCString(ctx, key);
+        JS_FreeCString(ctx, str);
+    }
+    envp[len] = NULL;
+
+done:
+    JS_FreePropertyEnum(ctx, tab, len);
+    return envp;
+fail:
+    if (envp) {
+        for(i = 0; i < len; i++) {
+            if (envp[i]) js_free(ctx, envp[i]);
+        }
+        js_free(ctx, envp);
+        envp = NULL;
+    }
+    goto done;
+}
+
+/* Main exec implementation for Windows */
+static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
+                          int argc, JSValueConst *argv)
+{
+    JSValueConst options, args = argv[0];
+    JSValue val, ret_val = JS_UNDEFINED;
+    const char **exec_argv = NULL;
+    char **envp = NULL;
+    const char *file = NULL;
+    uint32_t exec_argc = 0, i;
+    int ret, mode;
+    BOOL block_flag = TRUE, use_path = TRUE;
+
+    int custom_stdout_fd = -1;
+    int old_stdout = -1;
+
+    // 1. Arguments length
+    val = JS_GetPropertyStr(ctx, args, "length");
+    if (JS_IsException(val)) return JS_EXCEPTION;
+    ret = JS_ToUint32(ctx, &exec_argc, val);
+    JS_FreeValue(ctx, val); // OK: 2 arguments
+    if (ret < 0) return JS_EXCEPTION;
+
+    exec_argv = js_mallocz(ctx, sizeof(char *) * (exec_argc + 1));
+    if (!exec_argv) return JS_EXCEPTION;
+
+    for(i = 0; i < exec_argc; i++) {
+        val = JS_GetPropertyUint32(ctx, args, i);
+        if (JS_IsException(val)) goto exception;
+        exec_argv[i] = JS_ToCString(ctx, val);
+        JS_FreeValue(ctx, val); // OK: 2 arguments
+        if (!exec_argv[i]) goto exception;
+    }
+    exec_argv[exec_argc] = NULL;
+
+    // 2. Options & stdout fileno
+    if (argc >= 2) {
+        options = argv[1];
+        get_bool_option(ctx, &block_flag, options, "block");
+        get_bool_option(ctx, &use_path, options, "usePath");
+
+        val = JS_GetPropertyStr(ctx, options, "stdout");
+        if (!JS_IsUndefined(val) && !JS_IsNull(val)) {
+            JS_ToInt32(ctx, &custom_stdout_fd, val);
+        }
+        JS_FreeValue(ctx, val); // Était trop peu d'arguments ici !
+
+        val = JS_GetPropertyStr(ctx, options, "file");
+        if (!JS_IsUndefined(val) && !JS_IsNull(val)) {
+            file = JS_ToCString(ctx, val);
+        }
+        JS_FreeValue(ctx, val); // Était trop peu d'arguments ici !
+
+        val = JS_GetPropertyStr(ctx, options, "env");
+        if (!JS_IsUndefined(val) && !JS_IsNull(val)) {
+            envp = build_envp(ctx, val);
+        }
+        JS_FreeValue(ctx, val); // OK: 2 arguments
+    }
+
+    if (envp == NULL) envp = (char **)_environ;
+    const char *spawn_file = file ? file : exec_argv[0];
+
+    // 3. Redirection logic
+    if (custom_stdout_fd != -1) {
+        _flushall();
+        old_stdout = _dup(_fileno(stdout));
+        if (_dup2(custom_stdout_fd, _fileno(stdout)) == -1) {
+             _close(old_stdout);
+             old_stdout = -1;
+        }
+    }
+
+    mode = block_flag ? _P_WAIT : _P_NOWAIT;
+    _flushall();
+
+    if (use_path)
+        ret = _spawnvpe(mode, spawn_file, (const char * const *)exec_argv, (const char * const *)envp);
+    else
+        ret = _spawnve(mode, spawn_file, (const char * const *)exec_argv, (const char * const *)envp);
+
+    if (old_stdout != -1) {
+        _flushall();
+        _dup2(old_stdout, _fileno(stdout));
+        _close(old_stdout);
+    }
+
+    if (ret == -1) {
+        JS_ThrowTypeError(ctx, "exec error (spawn failed)");
+        goto exception;
+    }
+
+    ret_val = JS_NewInt32(ctx, ret);
+
+done:
+    if (file) JS_FreeCString(ctx, file);
+    if (exec_argv) {
+        for(i = 0; i < exec_argc; i++) if (exec_argv[i]) JS_FreeCString(ctx, exec_argv[i]);
+        js_free(ctx, exec_argv);
+    }
+    if (envp && envp != (char **)_environ) {
+        char **p = envp;
+        while (*p != NULL) { js_free(ctx, *p); p++; }
+        js_free(ctx, envp);
+    }
+    return ret_val;
+
+exception:
+    ret_val = JS_EXCEPTION;
+    goto done;
+}
+#endif