quickjs-emscripten-sync 1.5.2 → 1.7.0

package/src/index.ts

@@ -4,6 +4,7 @@ import type {
   QuickJSContext,
   SuccessOrFail,
   VmCallResult,
+  Intrinsics,
 } from "quickjs-emscripten";
 
 import { wrapContext, QuickJSContextEx } from "./contextex";
@@ -31,6 +32,8 @@ export {
   consumeAll,
 };
 
+export type { Intrinsics };
+
 export type Options = {
   /** A callback that returns a boolean value that determines whether an object is marshalled or not. If false, no marshaling will be done and undefined will be passed to the QuickJS VM, otherwise marshaling will be done. By default, all objects will be marshalled. */
   isMarshalable?: boolean | "json" | ((target: any) => boolean | "json");
@@ -103,6 +106,43 @@ export class Arena {
     return this._unwrapResultAndUnmarshal(handle);
   }
 
+  /**
+   * Evaluate ES module code in the VM and get the module's exports.
+   *
+   * Requires quickjs-emscripten >= 0.29.0 for export access.
+   *
+   * @param code - The ES module code to evaluate
+   * @param filename - Optional filename for debugging purposes (default: "module.js")
+   * @returns The module's exports object, or a Promise resolving to exports if using top-level await
+   *
+   * @example
+   * ```js
+   * // Simple module with exports
+   * const exports = arena.evalModule(`
+   *   export const value = 42;
+   *   export function greet(name) {
+   *     return "Hello, " + name;
+   *   }
+   * `);
+   * console.log(exports.value); // 42
+   * console.log(exports.greet("World")); // "Hello, World"
+   *
+   * // Module with default export
+   * const mod = arena.evalModule('export default function(x) { return x * 2; }');
+   * console.log(mod.default(21)); // 42
+   *
+   * // Module with top-level await
+   * const promise = arena.evalModule('export const data = await Promise.resolve(123);');
+   * arena.executePendingJobs();
+   * const exports = await promise;
+   * console.log(exports.data); // 123
+   * ```
+   */
+  evalModule<T = any>(code: string, filename = "module.js"): T | Promise<T> {
+    const handle = this.context.evalCode(code, filename, { type: "module" });
+    return this._unwrapResultAndUnmarshal(handle);
+  }
+
   /**
    * Almost same as `vm.executePendingJobs()`, but it converts and re-throws error objects when an error is thrown during evaluation.
    */
@@ -114,6 +154,121 @@ export class Arena {
     throw this._unwrapIfNotSynced(result.error.consume(this._unmarshal));
   }
 
+  /**
+   * Set the max memory this runtime can allocate.
+   * To remove the limit, set to `-1`.
+   *
+   * This is useful for preventing runaway memory usage in untrusted code.
+   *
+   * @param limitBytes - Maximum memory in bytes, or -1 to remove limit
+   *
+   * @example
+   * ```js
+   * // Limit sandbox to 10MB
+   * arena.setMemoryLimit(10 * 1024 * 1024);
+   *
+   * try {
+   *   arena.evalCode(`const huge = new Array(1000000000);`);
+   * } catch (e) {
+   *   console.log("Memory limit exceeded");
+   * }
+   * ```
+   */
+  setMemoryLimit(limitBytes: number): void {
+    this.context.runtime.setMemoryLimit(limitBytes);
+  }
+
+  /**
+   * Set the max stack size for this runtime, in bytes.
+   * To remove the limit, set to `0`.
+   *
+   * This is useful for preventing stack overflow from deeply nested calls or recursion.
+   *
+   * @param stackSize - Maximum stack size in bytes, or 0 to remove limit
+   *
+   * @example
+   * ```js
+   * // Limit stack to 512KB
+   * arena.setMaxStackSize(512 * 1024);
+   *
+   * try {
+   *   arena.evalCode(`function recurse() { recurse(); } recurse();`);
+   * } catch (e) {
+   *   console.log("Stack overflow prevented");
+   * }
+   * ```
+   */
+  setMaxStackSize(stackSize: number): void {
+    this.context.runtime.setMaxStackSize(stackSize);
+  }
+
+  /**
+   * Get detailed memory usage statistics for this runtime.
+   *
+   * @returns An object containing detailed memory allocation information
+   *
+   * @example
+   * ```js
+   * const stats = arena.getMemoryUsage();
+   * console.log(`Memory used: ${stats.memory_used_size} bytes`);
+   * console.log(`Object count: ${stats.obj_count}`);
+   * console.log(`Memory limit: ${stats.malloc_limit}`);
+   * ```
+   */
+  getMemoryUsage(): {
+    malloc_limit: number;
+    memory_used_size: number;
+    malloc_count: number;
+    memory_used_count: number;
+    atom_count: number;
+    atom_size: number;
+    str_count: number;
+    str_size: number;
+    obj_count: number;
+    obj_size: number;
+    prop_count: number;
+    prop_size: number;
+    shape_count: number;
+    shape_size: number;
+    js_func_count: number;
+    js_func_size: number;
+    js_func_code_size: number;
+    js_func_pc2line_count: number;
+    js_func_pc2line_size: number;
+    c_func_count: number;
+    array_count: number;
+    fast_array_count: number;
+    fast_array_elements: number;
+    binary_object_count: number;
+    binary_object_size: number;
+  } {
+    const handle = this.context.runtime.computeMemoryUsage();
+    try {
+      return this.context.dump(handle);
+    } finally {
+      handle.dispose();
+    }
+  }
+
+  /**
+   * Get a human-readable description of memory usage in this runtime.
+   *
+   * @returns A formatted string showing memory statistics
+   *
+   * @example
+   * ```js
+   * console.log(arena.dumpMemoryUsage());
+   * // Output:
+   * // QuickJS memory usage:
+   * //   malloc_limit: 4294967295
+   * //   memory_used_size: 67078
+   * //   ...
+   * ```
+   */
+  dumpMemoryUsage(): string {
+    return this.context.runtime.dumpMemoryUsage();
+  }
+
   /**
    * Expose objects as global objects in the VM.
    *

package/src/vmutil.ts

@@ -10,10 +10,12 @@ export function fn(
   code: string,
 ): ((thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]) => QuickJSHandle) & Disposable {
   const handle = ctx.unwrapResult(ctx.evalCode(code));
-  const f = (thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]): any => {
+  const f: any = (thisArg: QuickJSHandle | undefined, ...args: QuickJSHandle[]): any => {
     return ctx.unwrapResult(ctx.callFunction(handle, thisArg ?? ctx.undefined, ...args));
   };
-  f.dispose = () => handle.dispose();
+  const disposeFn = () => handle.dispose();
+  f.dispose = disposeFn;
+  f[Symbol.dispose] = disposeFn;
   f.alive = true;
   Object.defineProperty(f, "alive", {
     get: () => handle.alive,