## Core Upgrade

  - Upgrade quickjs-emscripten from 0.25.0 to 0.29.0
  - Fix Disposable interface implementation in vmutil.ts to support Symbol.dispose (required by 0.29.0)

  ## Module System Enhancements (0.29.0)
  - Update evalModule() to return module exports (previously returned void)
  - Add comprehensive documentation and examples for accessing module exports
  - Add 5 new tests for module export functionality:
    - exported values and objects
    - exported functions
    - default exports
    - class static method exports
    - top-level await support

  ## Promise State Inspection (0.29.1)
  - Add getPromiseState() method for synchronous promise state checking
  - Returns pending, fulfilled, or rejected states
  - Add 4 tests covering various promise state scenarios
  - Useful for determining when to sync promise results without async operations

  ## Intrinsics Configuration Support (0.26.0)
  - Export Intrinsics, JSPromiseState, and JSPromiseStateEnum types
  - Add documentation showing how to configure intrinsics at context creation
  - Enables security sandboxing by disabling dangerous features (eval, Proxy, etc.)
  - Add test demonstrating intrinsics configuration usage

Author: bnimit

src/index.test.ts

@@ -1012,3 +1012,119 @@ describe("memory management", () => {
     ctx.dispose();
   });
 });
+
+describe("intrinsics configuration", () => {
+  test("intrinsics can be configured when creating context", async () => {
+    const quickjs = await getQuickJS();
+    const runtime = quickjs.newRuntime();
+
+    // Example: disable eval for sandboxing
+    const ctx = runtime.newContext({ intrinsics: { Eval: false } });
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // This test demonstrates that intrinsics are configured at context creation
+    // The actual restrictions would be enforced by quickjs-emscripten
+    expect(arena).toBeDefined();
+    expect(arena.context).toBeDefined();
+
+    arena.dispose();
+    ctx.dispose();
+    runtime.dispose();
+  });
+});
+
+describe("promise state inspection", () => {
+  test("getPromiseState returns fulfilled for resolved promise", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    const handle = arena.context.unwrapResult(arena.context.evalCode("Promise.resolve(42)"));
+
+    // Promise.resolve creates an already fulfilled promise
+    expect(arena.getPromiseState(handle)).toBe("fulfilled");
+
+    handle.dispose();
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("getPromiseState returns pending then fulfilled", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // Create a promise that requires job execution to resolve
+    const handle = arena.context.unwrapResult(
+      arena.context.evalCode(`
+      new Promise((resolve) => {
+        globalThis.resolveIt = resolve;
+      })
+    `),
+    );
+
+    expect(arena.getPromiseState(handle)).toBe("pending");
+
+    // Now resolve it
+    arena.evalCode("globalThis.resolveIt(123)");
+    arena.executePendingJobs();
+
+    expect(arena.getPromiseState(handle)).toBe("fulfilled");
+
+    handle.dispose();
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("getPromiseState with chained promises", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // Create a pending promise
+    const handle = arena.context.unwrapResult(
+      arena.context.evalCode(`
+      new Promise((resolve) => {
+        globalThis.doResolve = resolve;
+      }).then(x => x * 2)
+    `),
+    );
+
+    expect(arena.getPromiseState(handle)).toBe("pending");
+
+    // Resolve the original promise
+    arena.evalCode("globalThis.doResolve(10)");
+    arena.executePendingJobs();
+
+    expect(arena.getPromiseState(handle)).toBe("fulfilled");
+
+    handle.dispose();
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("getPromiseState detects state changes", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // Set up a promise that can be controlled
+    arena.evalCode(`
+      globalThis.promiseState = new Promise((resolve, reject) => {
+        globalThis.doResolve = resolve;
+        globalThis.doReject = reject;
+      });
+    `);
+
+    const handle = arena.context.getProp(arena.context.global, "promiseState");
+
+    // Initially pending
+    expect(arena.getPromiseState(handle)).toBe("pending");
+
+    // Resolve it
+    arena.evalCode("globalThis.doResolve(42)");
+    arena.executePendingJobs();
+
+    expect(arena.getPromiseState(handle)).toBe("fulfilled");
+
+    handle.dispose();
+    arena.dispose();
+    ctx.dispose();
+  });
+});

src/index.ts

@@ -4,6 +4,9 @@ import type {
   QuickJSContext,
   SuccessOrFail,
   VmCallResult,
+  Intrinsics,
+  JSPromiseState,
+  JSPromiseStateEnum,
 } from "quickjs-emscripten";
 
 import { wrapContext, QuickJSContextEx } from "./contextex";
@@ -31,6 +34,8 @@ export {
   consumeAll,
 };
 
+export type { Intrinsics, JSPromiseState, JSPromiseStateEnum };
+
 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");
@@ -266,6 +271,38 @@ export class Arena {
     return this.context.runtime.dumpMemoryUsage();
   }
 
+  /**
+   * Get the state of a VM Promise synchronously.
+   *
+   * Note: This only works with promises that were created in the VM and accessed
+   * via their internal handle. For marshaled promises from evalCode/evalModule,
+   * the promise is already resolved on the host side.
+   *
+   * Requires quickjs-emscripten >= 0.29.1
+   *
+   * @param promiseHandle - The QuickJS handle to the promise
+   * @returns The state of the promise: "pending", "fulfilled", or "rejected"
+   *
+   * @example
+   * ```js
+   * const handle = arena.context.unwrapResult(
+   *   arena.context.evalCode('Promise.resolve(42)')
+   * );
+   *
+   * console.log(arena.getPromiseState(handle)); // "pending" (before job execution)
+   *
+   * arena.executePendingJobs();
+   *
+   * console.log(arena.getPromiseState(handle)); // "fulfilled"
+   *
+   * handle.dispose();
+   * ```
+   */
+  getPromiseState(promiseHandle: QuickJSHandle): "pending" | "fulfilled" | "rejected" {
+    const state = this.context.getPromiseState(promiseHandle);
+    return state.type;
+  }
+
   /**
    * Expose objects as global objects in the VM.
    *