@gorules/quickjs 0.1.3

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2025 GoRules.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy,
+modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,285 @@
+# @gorules/quickjs
+
+A high-performance, sandboxed JavaScript runtime for Node.js and browsers, powered by [QuickJS](https://bellard.org/quickjs/) and built with Rust via [napi-rs](https://napi.rs/).
+
+## Features
+
+- **Sandboxed Execution** - Run untrusted JavaScript code safely with isolated contexts
+- **Resource Constraints** - Limit execution time, memory usage, and stack size
+- **HTTP Client** - Built-in `http` library for making HTTP requests
+- **Custom Modules** - Define and import ES6 modules dynamically
+- **Async/Await** - Full support for asynchronous JavaScript
+- **Cross-Platform** - Works on macOS, Linux, Windows, and browsers (WASM)
+
+## Installation
+
+```bash
+npm install @gorules/quickjs
+# or
+yarn add @gorules/quickjs
+```
+
+## Quick Start
+
+```javascript
+import { JavascriptRunner } from '@gorules/quickjs';
+import { createFetchAdapter } from '@gorules/quickjs/fetch-adapter';
+
+const runner = new JavascriptRunner({
+  fetch: createFetchAdapter(),
+});
+
+// Evaluate simple expressions
+const result = await runner.evaluate('1 + 1');
+console.log(result); // 2
+
+// Evaluate complex scripts
+const data = await runner.evaluate(`
+  const users = [
+    { name: 'Alice', age: 30 },
+    { name: 'Bob', age: 25 }
+  ];
+  users.filter(u => u.age > 26).map(u => u.name)
+`);
+console.log(data); // ['Alice']
+
+// Clean up when done
+runner.dispose();
+```
+
+## API Reference
+
+### JavascriptRunner
+
+The main class for evaluating JavaScript code.
+
+```typescript
+interface JavascriptRunnerOptions {
+  fetch: (url: string, options?: FetchOptions) => Promise<FetchResponse>;
+  modules?: Array<JavascriptModule>;
+  maxPoolSize?: number;
+  memoryLimit?: number;        // Memory limit in bytes
+  maxStackSize?: number;       // Stack size limit in bytes
+  maxDuration?: number;        // Execution timeout in milliseconds
+}
+
+const runner = new JavascriptRunner(options);
+```
+
+#### Methods
+
+- `evaluate(script: string): Promise<any>` - Execute JavaScript code and return the result
+- `dispose(): void` - Clean up resources
+
+### JavascriptModule
+
+Define custom modules that can be imported in evaluated scripts.
+
+```typescript
+interface NewJavascriptModuleOptions {
+  name: string;
+  source: string;
+}
+
+const module = new JavascriptModule({ name: 'myModule', source: '...' });
+// or create multiple at once
+const modules = JavascriptModule.fromList([...]);
+```
+
+## Usage Examples
+
+### HTTP Requests
+
+The runtime provides a built-in `http` object for making HTTP requests:
+
+```javascript
+const runner = new JavascriptRunner({
+  fetch: createFetchAdapter(),
+});
+
+const result = await runner.evaluate(`
+  const response = await http.get("https://api.example.com/users");
+  response.data
+`);
+```
+
+Supported methods:
+- `http.get(url, options?)` - GET request
+- `http.post(url, body?, options?)` - POST request
+- `http.put(url, body?, options?)` - PUT request
+- `http.delete(url, options?)` - DELETE request
+
+Request options:
+```javascript
+{
+  headers: { "Authorization": "Bearer token" },
+  params: { "q": "search", "limit": "10" },
+  baseURL: "https://api.example.com"
+}
+```
+
+Response format:
+```javascript
+{
+  status: 200,
+  statusText: "OK",
+  headers: { "content-type": "application/json" },
+  data: { ... }  // Parsed JSON or string
+}
+```
+
+### Custom Modules
+
+Define reusable modules that scripts can import:
+
+```javascript
+import { JavascriptRunner, JavascriptModule } from '@gorules/quickjs';
+
+const modules = JavascriptModule.fromList([
+  {
+    name: 'utils',
+    source: `
+      export const double = x => x * 2;
+      export const capitalize = s => s.charAt(0).toUpperCase() + s.slice(1);
+    `
+  },
+  {
+    name: 'api',
+    source: `
+      export async function fetchUsers() {
+        const response = await http.get("https://api.example.com/users");
+        return response.data;
+      }
+    `
+  }
+]);
+
+const runner = new JavascriptRunner({
+  fetch: createFetchAdapter(),
+  modules,
+});
+
+const result = await runner.evaluate(`
+  const { double } = await import('utils');
+  const { fetchUsers } = await import('api');
+
+  const users = await fetchUsers();
+  users.map(u => ({ ...u, score: double(u.score) }))
+`);
+```
+
+### Resource Constraints
+
+Protect against runaway scripts with execution limits:
+
+```javascript
+const runner = new JavascriptRunner({
+  fetch: createFetchAdapter(),
+  maxDuration: 1000,           // 1 second timeout
+  memoryLimit: 10 * 1024 * 1024, // 10 MB memory limit
+  maxStackSize: 512 * 1024,    // 512 KB stack size
+});
+
+// This will throw an error after 1 second
+try {
+  await runner.evaluate('while(true) {}');
+} catch (error) {
+  console.log('Script interrupted:', error.message);
+}
+
+// This will throw a memory error
+try {
+  await runner.evaluate(`
+    const arr = [];
+    while(true) { arr.push("x".repeat(10000)); }
+  `);
+} catch (error) {
+  console.log('Memory limit exceeded:', error.message);
+}
+```
+
+### Async Operations
+
+Full support for async/await and Promises:
+
+```javascript
+const result = await runner.evaluate(`
+  async function processData() {
+    const [users, posts] = await Promise.all([
+      http.get("https://api.example.com/users"),
+      http.get("https://api.example.com/posts")
+    ]);
+
+    return {
+      userCount: users.data.length,
+      postCount: posts.data.length
+    };
+  }
+
+  await processData()
+`);
+```
+
+A `sleep` function is also available:
+
+```javascript
+await runner.evaluate(`
+  await sleep(100);  // Sleep for 100ms
+  "done"
+`);
+```
+
+## Browser Usage (WASM)
+
+The package includes WASM support for browser environments:
+
+```javascript
+import { JavascriptRunner } from '@gorules/quickjs/browser';
+
+// The WASM module loads asynchronously
+const runner = new JavascriptRunner({
+  fetch: async (url, options) => {
+    const res = await fetch(url, options);
+    return {
+      status: res.status,
+      statusText: res.statusText,
+      headers: Object.fromEntries(res.headers),
+      data: await res.text(),
+    };
+  },
+});
+
+const result = await runner.evaluate('2 + 2');
+```
+
+## Execution Isolation
+
+Each call to `evaluate()` runs in an isolated context. Variables defined in one evaluation are not accessible in subsequent evaluations:
+
+```javascript
+await runner.evaluate('var x = 100');
+const result = await runner.evaluate('typeof x');
+console.log(result); // 'undefined'
+```
+
+## Platform Support
+
+| Platform | Architecture | Support |
+|----------|--------------|---------|
+| macOS | x64, ARM64 | Native |
+| Linux | x64, ARM64 (glibc) | Native |
+| Linux | x64, ARM64 (musl) | Native |
+| Windows | x64 | Native |
+| Browser | WASM | WASM |
+
+## Built with Rust
+
+The core runtime is implemented in Rust using:
+- [rquickjs](https://github.com/deltalabs-ai/rquickjs) - Rust bindings for QuickJS
+- [napi-rs](https://napi.rs/) - Node.js native addon framework
+
+This provides excellent performance while maintaining memory safety.
+
+## License
+
+MIT

package/browser.js

@@ -0,0 +1 @@
+export * from '@gorules/quickjs-wasm32-wasi'

package/fetch-adapter.d.ts

@@ -0,0 +1,10 @@
+import type { FetchOptions, FetchResponse } from './index';
+
+/**
+ * Creates a fetch adapter that wraps native fetch for use with Runner.
+ * Transforms the native Response object into the FetchResponse format.
+ */
+export function createFetchAdapter(): (
+  url: string,
+  options?: FetchOptions
+) => Promise<FetchResponse>;

package/fetch-adapter.js

@@ -0,0 +1,29 @@
+/**
+ * Creates a fetch adapter that wraps native fetch for use with Runner.
+ * Transforms the native Response object into the FetchResponse format.
+ *
+ * @returns {(url: string, options?: import('./index').FetchOptions) => Promise<import('./index').FetchResponse>}
+ */
+function createFetchAdapter() {
+  return async (...args) => {
+    const [url, options] = Array.isArray(args[0]) ? args[0] : args;
+    const res = await fetch(url, {
+      method: options?.method ?? 'GET',
+      headers: options?.headers,
+      body: options?.body,
+    });
+
+    const data = await res.text();
+    const headers = {};
+    res.headers.forEach((v, k) => { headers[k] = v; });
+
+    return {
+      status: res.status,
+      statusText: res.statusText,
+      headers,
+      data,
+    };
+  };
+}
+
+module.exports.createFetchAdapter = createFetchAdapter;

package/index.d.ts

@@ -0,0 +1,43 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class JavascriptModule {
+  constructor(options: NewJavascriptModuleOptions)
+  static fromList(options: Array<NewJavascriptModuleOptions>): Array<JavascriptModule>
+  get name(): string
+  compiled(): Promise<boolean>
+}
+
+export declare class JavascriptRunner {
+  constructor(options: JavascriptRunnerOptions)
+  evaluate(script: string): Promise<any>
+  dispose(): void
+}
+
+export interface FetchOptions {
+  method?: string
+  headers?: Record<string, string>
+  body?: string
+  timeout?: number
+}
+
+export interface FetchResponse {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  data: string
+}
+
+export interface JavascriptRunnerOptions {
+  fetch: (url: string, options?: FetchOptions) => Promise<FetchResponse>
+  modules?: Array<JavascriptModule>
+  maxPoolSize?: number
+  memoryLimit?: number
+  maxStackSize?: number
+  /** Max duration in milliseconds */
+  maxDuration?: number
+}
+
+export interface NewJavascriptModuleOptions {
+  name: string
+  source: string
+}

package/index.js

@@ -0,0 +1,576 @@
+// prettier-ignore
+/* eslint-disable */
+// @ts-nocheck
+/* auto-generated by NAPI-RS */
+
+const { readFileSync } = require('node:fs')
+let nativeBinding = null
+const loadErrors = []
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
+    }
+  }
+  return musl
+}
+
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      return require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./quickjs.android-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-android-arm64')
+        const bindingPackageVersion = require('@gorules/quickjs-android-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./quickjs.android-arm-eabi.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-android-arm-eabi')
+        const bindingPackageVersion = require('@gorules/quickjs-android-arm-eabi/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`))
+    }
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      if (process.config?.variables?.shlib_suffix === 'dll.a' || process.config?.variables?.node_target_type === 'shared_library') {
+        try {
+        return require('./quickjs.win32-x64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-win32-x64-gnu')
+        const bindingPackageVersion = require('@gorules/quickjs-win32-x64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      } else {
+        try {
+        return require('./quickjs.win32-x64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-win32-x64-msvc')
+        const bindingPackageVersion = require('@gorules/quickjs-win32-x64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      }
+    } else if (process.arch === 'ia32') {
+      try {
+        return require('./quickjs.win32-ia32-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-win32-ia32-msvc')
+        const bindingPackageVersion = require('@gorules/quickjs-win32-ia32-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./quickjs.win32-arm64-msvc.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-win32-arm64-msvc')
+        const bindingPackageVersion = require('@gorules/quickjs-win32-arm64-msvc/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`))
+    }
+  } else if (process.platform === 'darwin') {
+    try {
+      return require('./quickjs.darwin-universal.node')
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    try {
+      const binding = require('@gorules/quickjs-darwin-universal')
+      const bindingPackageVersion = require('@gorules/quickjs-darwin-universal/package.json').version
+      if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      }
+      return binding
+    } catch (e) {
+      loadErrors.push(e)
+    }
+    if (process.arch === 'x64') {
+      try {
+        return require('./quickjs.darwin-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-darwin-x64')
+        const bindingPackageVersion = require('@gorules/quickjs-darwin-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./quickjs.darwin-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-darwin-arm64')
+        const bindingPackageVersion = require('@gorules/quickjs-darwin-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      try {
+        return require('./quickjs.freebsd-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-freebsd-x64')
+        const bindingPackageVersion = require('@gorules/quickjs-freebsd-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm64') {
+      try {
+        return require('./quickjs.freebsd-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-freebsd-arm64')
+        const bindingPackageVersion = require('@gorules/quickjs-freebsd-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        try {
+          return require('./quickjs.linux-x64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-x64-musl')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-x64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./quickjs.linux-x64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-x64-gnu')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-x64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        try {
+          return require('./quickjs.linux-arm64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-arm64-musl')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-arm64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./quickjs.linux-arm64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-arm64-gnu')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-arm64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        try {
+          return require('./quickjs.linux-arm-musleabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-arm-musleabihf')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-arm-musleabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./quickjs.linux-arm-gnueabihf.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-arm-gnueabihf')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-arm-gnueabihf/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'loong64') {
+      if (isMusl()) {
+        try {
+          return require('./quickjs.linux-loong64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-loong64-musl')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-loong64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./quickjs.linux-loong64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-loong64-gnu')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-loong64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        try {
+          return require('./quickjs.linux-riscv64-musl.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-riscv64-musl')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-riscv64-musl/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      } else {
+        try {
+          return require('./quickjs.linux-riscv64-gnu.node')
+        } catch (e) {
+          loadErrors.push(e)
+        }
+        try {
+          const binding = require('@gorules/quickjs-linux-riscv64-gnu')
+          const bindingPackageVersion = require('@gorules/quickjs-linux-riscv64-gnu/package.json').version
+          if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          }
+          return binding
+        } catch (e) {
+          loadErrors.push(e)
+        }
+      }
+    } else if (process.arch === 'ppc64') {
+      try {
+        return require('./quickjs.linux-ppc64-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-linux-ppc64-gnu')
+        const bindingPackageVersion = require('@gorules/quickjs-linux-ppc64-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 's390x') {
+      try {
+        return require('./quickjs.linux-s390x-gnu.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-linux-s390x-gnu')
+        const bindingPackageVersion = require('@gorules/quickjs-linux-s390x-gnu/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      try {
+        return require('./quickjs.openharmony-arm64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-openharmony-arm64')
+        const bindingPackageVersion = require('@gorules/quickjs-openharmony-arm64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'x64') {
+      try {
+        return require('./quickjs.openharmony-x64.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-openharmony-x64')
+        const bindingPackageVersion = require('@gorules/quickjs-openharmony-x64/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else if (process.arch === 'arm') {
+      try {
+        return require('./quickjs.openharmony-arm.node')
+      } catch (e) {
+        loadErrors.push(e)
+      }
+      try {
+        const binding = require('@gorules/quickjs-openharmony-arm')
+        const bindingPackageVersion = require('@gorules/quickjs-openharmony-arm/package.json').version
+        if (bindingPackageVersion !== '0.1.3' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 0.1.3 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        }
+        return binding
+      } catch (e) {
+        loadErrors.push(e)
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`))
+    }
+  } else {
+    loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  let wasiBinding = null
+  let wasiBindingError = null
+  try {
+    wasiBinding = require('./quickjs.wasi.cjs')
+    nativeBinding = wasiBinding
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      wasiBindingError = err
+    }
+  }
+  if (!nativeBinding) {
+    try {
+      wasiBinding = require('@gorules/quickjs-wasm32-wasi')
+      nativeBinding = wasiBinding
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        wasiBindingError.cause = err
+        loadErrors.push(err)
+      }
+    }
+  }
+  if (process.env.NAPI_RS_FORCE_WASI === 'error' && !wasiBinding) {
+    const error = new Error('WASI binding not found and NAPI_RS_FORCE_WASI is set to error')
+    error.cause = wasiBindingError
+    throw error
+  }
+}
+
+if (!nativeBinding) {
+  if (loadErrors.length > 0) {
+    throw new Error(
+      `Cannot find native binding. ` +
+        `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` +
+        'Please try `npm i` again after removing both package-lock.json and node_modules directory.',
+      {
+        cause: loadErrors.reduce((err, cur) => {
+          cur.cause = err
+          return cur
+        }),
+      },
+    )
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+module.exports = nativeBinding
+module.exports.JavascriptModule = nativeBinding.JavascriptModule
+module.exports.JavascriptRunner = nativeBinding.JavascriptRunner

package/package.json

@@ -0,0 +1,103 @@
+{
+  "name": "@gorules/quickjs",
+  "version": "0.1.3",
+  "description": "High-performance, sandboxed JavaScript runtime for Node.js and browsers, powered by QuickJS and Rust",
+  "author": "GoRules <hi@gorules.io> (https://gorules.io)",
+  "license": "MIT",
+  "homepage": "https://gorules.io",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gorules/quickjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/gorules/quickjs/issues"
+  },
+  "keywords": [
+    "quickjs",
+    "javascript",
+    "sandbox",
+    "runtime",
+    "eval",
+    "isolated",
+    "secure",
+    "wasm",
+    "webassembly",
+    "napi",
+    "rust",
+    "embedded",
+    "scripting",
+    "interpreter"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "main": "index.js",
+  "browser": "browser.js",
+  "types": "./index.d.ts",
+  "typings": "index.d.ts",
+  "packageManager": "yarn@4.12.0",
+  "files": [
+    "fetch-adapter.js",
+    "fetch-adapter.d.ts",
+    "index.js",
+    "index.d.ts",
+    "browser.js",
+    "README.md"
+  ],
+  "napi": {
+    "binaryName": "quickjs",
+    "targets": [
+      "x86_64-apple-darwin",
+      "x86_64-unknown-linux-gnu",
+      "x86_64-unknown-linux-musl",
+      "x86_64-pc-windows-msvc",
+      "aarch64-unknown-linux-gnu",
+      "aarch64-unknown-linux-musl",
+      "aarch64-apple-darwin",
+      "wasm32-wasip1-threads"
+    ],
+    "npmClient": "yarn",
+    "wasm": {
+      "browser": {
+        "fs": false,
+        "asyncInit": true
+      }
+    }
+  },
+  "scripts": {
+    "build": "napi build --platform --release",
+    "build:debug": "napi build --platform",
+    "test": "node --experimental-transform-types --test tests/**/*.test.mts",
+    "format": "prettier tests/*.mts --write",
+    "repl": "node --experimental-transform-types repl.mts",
+    "artifacts": "napi artifacts -d artifacts",
+    "createNpmDirs": "napi create-npm-dirs",
+    "release": "release-it"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.5.0",
+    "@release-it/conventional-changelog": "^10.0.0",
+    "@types/node": "^25.0.3",
+    "prettier": "^3.7.4",
+    "release-it": "^18.1.2",
+    "typescript": "^5.9.3"
+  },
+  "release-it": {
+    "git": {
+      "commitMessage": "chore: release v${version}",
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true
+    },
+    "npm": {
+      "publish": false
+    },
+    "plugins": {
+      "@release-it/conventional-changelog": {
+        "preset": "angular",
+        "infile": "CHANGELOG.md"
+      }
+    }
+  }
+}