quickjs-emscripten-sync 1.9.1 → 1.11.0

package/src/identity.test.ts

@@ -0,0 +1,57 @@
+import { getQuickJS } from "quickjs-emscripten";
+import { describe, expect, it } from "vitest";
+
+import { Arena } from ".";
+
+// A host function's return value is disposed by the VM once consumed. Marshalled
+// object handles are retained in the VMMap for identity while sync is on, so the
+// returned handle must be dup'd — otherwise the map entry goes stale and the same
+// value marshalled twice yields two distinct VM objects. These tests pin the
+// identity behaviour (issue #4); the no-leak side is covered by
+// remarshalleak.test.ts under the debug-sync runtime.
+async function withArena(
+  options: ConstructorParameters<typeof Arena>[1],
+  fn: (arena: Arena) => void,
+) {
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, options);
+  fn(arena);
+  arena.dispose();
+  ctx.dispose();
+}
+
+describe("marshal identity", () => {
+  it("preserves identity for a VM object round-tripped through the host", async () => {
+    await withArena({ isMarshalable: true }, arena => {
+      arena.expose({ id: (x: any) => x });
+      // foo originates in the VM, is passed to the host and returned: the
+      // round-trip must yield the same object.
+      expect(arena.evalCode(`let foo = id({}); foo === id(foo)`)).toBe(true);
+    });
+  });
+
+  it("returns the same VM object when a host function returns the same object twice", async () => {
+    await withArena({ isMarshalable: true }, arena => {
+      const shared = { k: 1 };
+      arena.expose({ get: () => shared });
+      expect(arena.evalCode(`get() === get()`)).toBe(true);
+    });
+  });
+
+  it("keeps identity across retained references", async () => {
+    await withArena({ isMarshalable: true }, arena => {
+      const shared = { k: 1 };
+      arena.expose({ get: () => shared });
+      expect(arena.evalCode(`let a = get(); let b = get(); a === b`)).toBe(true);
+    });
+  });
+
+  it("does not retain identity when sync is disabled", async () => {
+    await withArena({ isMarshalable: true, syncEnabled: false }, arena => {
+      const shared = { k: 1 };
+      arena.expose({ get: () => shared });
+      // With sync off, objects are not retained, so each marshal is independent.
+      expect(arena.evalCode(`get() === get()`)).toBe(false);
+    });
+  });
+});

package/src/index.test.ts

@@ -73,6 +73,70 @@ describe("readme", () => {
   });
 });
 
+describe("class constructors (#92)", () => {
+  test("new on an exposed class inside the VM", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    class Cls {
+      hoge = "";
+
+      constructor() {
+        this.hoge = "foo";
+      }
+    }
+    arena.expose({ Cls });
+
+    const instance = arena.evalCode(`new Cls()`) as { hoge: string };
+    expect(instance.hoge).toBe("foo");
+    expect(arena.evalCode(`new Cls() instanceof Cls`)).toBe(true);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("constructor arguments reach the host", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    class Cls {
+      value: number;
+
+      constructor(a: number, b: number) {
+        this.value = a + b;
+      }
+    }
+    arena.expose({ Cls });
+
+    const instance = arena.evalCode(`new Cls(2, 3)`) as { value: number };
+    expect(instance.value).toBe(5);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("new on a synced class inside the VM", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    class Cls {
+      hoge = "";
+
+      constructor(v = "foo") {
+        this.hoge = v;
+      }
+    }
+    arena.expose({ Cls: arena.sync(Cls) });
+
+    const instance = arena.evalCode(`new Cls("bar")`) as { hoge: string };
+    expect(instance.hoge).toBe("bar");
+    expect(arena.evalCode(`new Cls() instanceof Cls`)).toBe(true);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+});
+
 describe("evalCode", () => {
   test("simple object and function", async () => {
     const ctx = (await getQuickJS()).newContext();
@@ -254,6 +318,36 @@ describe("evalCode", () => {
     arena.dispose();
     ctx.dispose();
   });
+
+  test("options are forwarded (strict mode)", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // Assigning to an undeclared variable succeeds in sloppy mode...
+    expect(arena.evalCode("x = 1")).toBe(1);
+    // ...but throws a ReferenceError in strict mode.
+    expect(() => arena.evalCode("y = 1", undefined, { strict: true })).toThrow(ReferenceError);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("filename appears in error stacks", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    try {
+      arena.evalCode(`throw new Error("boom")`, "my-special-file.js");
+      throw new Error("should have thrown");
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+      expect((e as Error).message).toBe("boom");
+      expect((e as Error).stack).toContain("my-special-file.js");
+    }
+
+    arena.dispose();
+    ctx.dispose();
+  });
 });
 
 describe("expose without sync", () => {
@@ -550,6 +644,26 @@ test("register and unregister", async () => {
   ctx.dispose();
 });
 
+test("plain call passes `this` as undefined, method call passes the receiver", async () => {
+  const ctx = (await getQuickJS()).newContext();
+  const arena = new Arena(ctx, { isMarshalable: true });
+
+  arena.expose({
+    whoAmI() {
+      return this;
+    },
+  });
+
+  // A plain call would see `this === globalThis` in plain JS; the VM global is
+  // intentionally not marshalled to the host, so `this` is undefined here.
+  expect(arena.evalCode(`whoAmI()`)).toBe(undefined);
+  // A method call still receives its receiver.
+  expect(arena.evalCode(`const o = { v: 42, whoAmI }; o.whoAmI().v`)).toBe(42);
+
+  arena.dispose();
+  ctx.dispose();
+});
+
 test("registeredObjects option", async () => {
   const ctx = (await getQuickJS()).newContext();
   const arena = new Arena(ctx, {
@@ -816,6 +930,30 @@ describe("evalModule", () => {
     arena.dispose();
     ctx.dispose();
   });
+
+  test("user options are merged and type is forced to module", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // `strict` is passed through, and a user-supplied `type` is overridden with
+    // "module" so `export` still works and the exports are returned.
+    const exports = arena.evalModule(
+      `
+      export const value = 42;
+      export function greet(name) {
+        return "Hi, " + name;
+      }
+    `,
+      "with-options.js",
+      { strict: true, type: "global" },
+    );
+
+    expect(exports.value).toBe(42);
+    expect(exports.greet("World")).toBe("Hi, World");
+
+    arena.dispose();
+    ctx.dispose();
+  });
 });
 
 describe("memory management", () => {
@@ -1015,6 +1153,27 @@ describe("memory management", () => {
     arena.dispose();
     ctx.dispose();
   });
+
+  test("setInterruptHandler interrupts infinite loops", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true });
+
+    // Interrupt after the handler has been called a number of times.
+    let calls = 0;
+    arena.setInterruptHandler(() => ++calls > 1000);
+
+    expect(() => {
+      arena.evalCode(`while (true) {}`);
+    }).toThrow();
+    expect(calls).toBeGreaterThan(1000);
+
+    // After removing the handler, normal evaluation works again.
+    arena.removeInterruptHandler();
+    expect(arena.evalCode(`1 + 2`)).toBe(3);
+
+    arena.dispose();
+    ctx.dispose();
+  });
 });
 
 describe("intrinsics configuration", () => {
@@ -1096,6 +1255,149 @@ describe("AsyncArena", () => {
   });
 });
 
+describe("asyncify (#32)", () => {
+  test("without the option an async fn yields a Promise in the guest", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true });
+
+    arena.expose({ f: async () => "result" });
+    expect(await arena.evalCodeAsync(`typeof f()`)).toBe("object");
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("asyncify: true resolves the value synchronously in the guest", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({
+      f: async () => {
+        await new Promise(r => setTimeout(r, 1));
+        return "result";
+      },
+      g: async () => ({ a: 1, b: [2, 3] }),
+    });
+
+    expect(await arena.evalCodeAsync(`typeof f()`)).toBe("string");
+    expect(await arena.evalCodeAsync(`f()`)).toBe("result");
+    expect(await arena.evalCodeAsync(`const o = g(); [typeof o, o.a, o.b[1]]`)).toEqual([
+      "object",
+      1,
+      3,
+    ]);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("asyncify: true passes arguments through", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({ add: async (a: number, b: number) => a + b });
+    expect(await arena.evalCodeAsync(`add(2, 3)`)).toBe(5);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("predicate form only asyncifies matching functions", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, {
+      isMarshalable: true,
+      asyncify: target => (target as any).asyncified === true,
+    });
+
+    const yes = async () => "sync-value";
+    (yes as any).asyncified = true;
+    const no = async () => "promise-value";
+
+    arena.expose({ yes, no });
+
+    expect(await arena.evalCodeAsync(`typeof yes()`)).toBe("string");
+    expect(await arena.evalCodeAsync(`yes()`)).toBe("sync-value");
+    expect(await arena.evalCodeAsync(`typeof no()`)).toBe("object");
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("a rejecting asyncified fn surfaces as a catchable VM error", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({
+      boom: async () => {
+        throw new Error("kaboom");
+      },
+    });
+
+    // Uncaught in the guest: the error propagates back to the host.
+    await expect(arena.evalCodeAsync(`boom()`)).rejects.toThrow("kaboom");
+
+    // Caught in the guest: the guest can handle it synchronously.
+    expect(
+      await arena.evalCodeAsync(`
+        try {
+          boom();
+          "no-throw";
+        } catch (e) {
+          "caught:" + e.message;
+        }
+      `),
+    ).toBe("caught:kaboom");
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("sequential asyncified calls in one evalCodeAsync work", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({
+      first: async () => 10,
+      second: async (n: number) => n + 5,
+    });
+
+    expect(await arena.evalCodeAsync(`const a = first(); const b = second(a); a + b`)).toBe(25);
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("calling an asyncified fn during synchronous evalCode fails", async () => {
+    const ctx = await newAsyncContext();
+    const arena = new AsyncArena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({ f: async () => "result" });
+
+    // Asyncify can only suspend through an async entry point; a synchronous
+    // evalCode cannot unwind the stack, so it throws.
+    expect(() => arena.evalCode(`f()`)).toThrow("Function unexpectedly returned a Promise");
+
+    arena.dispose();
+    ctx.dispose();
+  });
+
+  test("sync context fallback: asyncify does not break, async fn behaves as today", async () => {
+    const ctx = (await getQuickJS()).newContext();
+    const arena = new Arena(ctx, { isMarshalable: true, asyncify: true });
+
+    arena.expose({ f: async () => "result" });
+    // No newAsyncifiedFunction on a plain context: falls back to Promise marshalling.
+    expect(arena.evalCode(`globalThis.__p = f(); typeof __p`)).toBe("object");
+    // Let the host promise settle into the VM promise before disposing, so the
+    // marshalled resolution does not touch a disposed context.
+    await new Promise(r => setTimeout(r));
+    arena.executePendingJobs();
+
+    arena.dispose();
+    ctx.dispose();
+  });
+});
+
 describe("Symbol.dispose", () => {
   test("using disposes the arena", async () => {
     const ctx = (await getQuickJS()).newContext();