@isolated-vm/experimental 0.0.9 → 0.0.11

package/test/{20.array_buffer.ts → 10.transfer/10.array_buffer.ts}

@@ -1,7 +1,7 @@
 import * as assert from "node:assert/strict";
 import { describe, test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { injectAssert, unsafeEvalAsString, unsafeEvalAsStringInRealm } from "./fixtures.js";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { injectAssert, unsafeEvalAsString, unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
 
 const hostSupportsSharedArraySupport =
 	// @ts-expect-error
@@ -9,7 +9,7 @@ const hostSupportsSharedArraySupport =
 
 await describe("array buffer", async () => {
 	await describe("transfer out", async () => {
-		await using agent = await ivm.Agent.create();
+		await using agent = await Agent.create();
 		const ab = await unsafeEvalAsString(agent, () => {
 			const uint8 = new Uint8Array([ 1, 2, 3 ]);
 			return uint8.buffer;
@@ -20,7 +20,7 @@ await describe("array buffer", async () => {
 
 	if (hostSupportsSharedArraySupport) {
 		await test("transfer out same reference", async () => {
-			await using agent = await ivm.Agent.create();
+			await using agent = await Agent.create();
 			const ab = await unsafeEvalAsString(agent, () => {
 				// nb: also tests zero-length buffer
 				const ab = new ArrayBuffer(0);
@@ -30,38 +30,43 @@ await describe("array buffer", async () => {
 		});
 	}
 
-	await test("transfer in", async () => {
-		await using agent = await ivm.Agent.create();
-		const realm = await agent.createRealm();
-		await injectAssert(agent, realm);
-		const global = await realm.acquireGlobalObject();
-		await global.set("ab", new Uint8Array([ 1, 2, 3 ]).buffer);
-		await unsafeEvalAsStringInRealm(agent, realm, () => {
-			// @ts-expect-error
-			const uint8 = new Uint8Array(ab);
-			assert.deepStrictEqual([ ...uint8 ], [ 1, 2, 3 ]);
+	// These tests work individually in Deno but something about the test runner is choking when run
+	// in the suite.
+	if (process.versions.deno === undefined) {
+		await test("transfer in", async () => {
+			await using agent = await Agent.create();
+			const realm = expect(await agent.createRealm());
+			await injectAssert(agent, realm);
+			const global = await realm.acquireGlobalObject();
+			await global.set("ab", new Uint8Array([ 1, 2, 3 ]).buffer);
+			await unsafeEvalAsStringInRealm(agent, realm, () => {
+				// @ts-expect-error
+				const uint8 = new Uint8Array(ab);
+				assert.deepStrictEqual([ ...uint8 ], [ 1, 2, 3 ]);
+			});
+			await agent.disposeAsync();
 		});
-	});
 
-	await test("transfer in same reference", async () => {
-		await using agent = await ivm.Agent.create();
-		const realm = await agent.createRealm();
-		await injectAssert(agent, realm);
-		const global = await realm.acquireGlobalObject();
-		const ab = new ArrayBuffer(0);
-		await global.set("abs", [ ab, ab ]);
-		await unsafeEvalAsStringInRealm(agent, realm, () => {
+		await test("transfer in same reference", async () => {
+			await using agent = await Agent.create();
+			const realm = expect(await agent.createRealm());
+			await injectAssert(agent, realm);
+			const global = await realm.acquireGlobalObject();
+			const ab = new ArrayBuffer(0);
+			await global.set("abs", [ ab, ab ]);
+			await unsafeEvalAsStringInRealm(agent, realm, () => {
 			// @ts-expect-error
 			// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-			assert.strictEqual(abs[0], abs[1]);
+				assert.strictEqual(abs[0], abs[1]);
+			});
 		});
-	});
+	}
 });
 
 await describe("shared array buffer", async () => {
 	if (hostSupportsSharedArraySupport) {
 		await describe("transfer out", async () => {
-			await using agent = await ivm.Agent.create();
+			await using agent = await Agent.create();
 			const realm = await agent.createRealm();
 			const sab = await unsafeEvalAsStringInRealm(agent, realm, () => {
 				const sab = new SharedArrayBuffer(3);
@@ -85,7 +90,7 @@ await describe("shared array buffer", async () => {
 		});
 
 		await test("transfer out same reference", async () => {
-			await using agent = await ivm.Agent.create();
+			await using agent = await Agent.create();
 			const ab = await unsafeEvalAsString(agent, () => {
 				// nb: also tests zero-length buffer
 				const sab = new SharedArrayBuffer(0);
@@ -95,8 +100,8 @@ await describe("shared array buffer", async () => {
 		});
 
 		await test("transfer in", async () => {
-			await using agent = await ivm.Agent.create();
-			const realm = await agent.createRealm();
+			await using agent = await Agent.create();
+			const realm = expect(await agent.createRealm());
 			await injectAssert(agent, realm);
 			const global = await realm.acquireGlobalObject();
 			const sab = new SharedArrayBuffer(3);
@@ -113,8 +118,8 @@ await describe("shared array buffer", async () => {
 	}
 
 	await test("transfer in same reference", async () => {
-		await using agent = await ivm.Agent.create();
-		const realm = await agent.createRealm();
+		await using agent = await Agent.create();
+		const realm = expect(await agent.createRealm());
 		await injectAssert(agent, realm);
 		const global = await realm.acquireGlobalObject();
 		const ab = new ArrayBuffer(0);
@@ -132,7 +137,7 @@ await describe("shared array buffer", async () => {
 
 // TODO: deno fails when this is in the `describe` (??)
 await test("transfer out", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const [ uint8, uint8_copy ] = await unsafeEvalAsString(agent, () => {
 		const uint8 = new Uint8Array([ 1, 2, 3 ]);
 		return [ uint8, new Uint8Array(uint8.buffer) ];
@@ -143,8 +148,8 @@ await test("transfer out", async () => {
 
 await describe("typed array", async () => {
 	await test("transfer in", async () => {
-		await using agent = await ivm.Agent.create();
-		const realm = await agent.createRealm();
+		await using agent = await Agent.create();
+		const realm = expect(await agent.createRealm());
 		await injectAssert(agent, realm);
 		const global = await realm.acquireGlobalObject();
 		const uint8 = new Uint8Array([ 1, 2, 3 ]);
@@ -159,7 +164,7 @@ await describe("typed array", async () => {
 
 	if (hostSupportsSharedArraySupport) {
 		await test("shared transfer out", async () => {
-			await using agent = await ivm.Agent.create();
+			await using agent = await Agent.create();
 			const [ shared_uint8, shared_uint8_copy ] = await unsafeEvalAsString(agent, () => {
 				const sab = new SharedArrayBuffer(3);
 				const uint8 = new Uint8Array(sab);

package/test/10.transfer/90.regressions.ts

@@ -0,0 +1,38 @@
+import { test } from "node:test";
+import { Agent, expect } from "@isolated-vm/experimental";
+import "@isolated-vm/experimental/test/fixtures";
+
+const hostSupportsSharedArraySupport =
+	// @ts-expect-error
+	process.isBun === undefined && process.versions.deno === undefined;
+
+// TODO: deno fails when this is in the `describe` (??)
+await test("numeric references", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const global = await realm.acquireGlobalObject();
+	// doubles are stored as references in `value_t`, because they are bigger than 32-bit. there was
+	// a failure with more than one of them in the same transfer operation.
+	expect(await global.set("xx", { zero: 0.1, one: 0.2 }));
+});
+
+await test("numeric indices", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const global = await realm.acquireGlobalObject();
+	// numeric array indices broke as part of a double to int32_t change.
+	expect(await global.set("xx", [ false, true ]));
+});
+
+if (hostSupportsSharedArraySupport) {
+	await test("seen index type", async () => {
+		await using agent = await Agent.create();
+		const realm = expect(await agent.createRealm());
+		const global = await realm.acquireGlobalObject();
+		const payload = {
+			number: 0,
+			buffer: [ new Uint8Array(new SharedArrayBuffer(0)) ],
+		};
+		expect(await global.set("xx", [ payload ]));
+	});
+}

package/test/{10.script.ts → 20.intrinsics/00.script.ts}

@@ -1,10 +1,12 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { expectComplete, expectThrow, unsafeEvalAsStringInRealm, unsafeIIFEAsString } from "./fixtures.js";
+import { Agent } from "@isolated-vm/experimental";
+import { expectComplete, expectThrow, unsafeEvalAsStringInRealm, unsafeIIFEAsString } from "@isolated-vm/experimental/test/fixtures";
+
+const illegalAccess = new Error("illegal access");
 
 await test("script source origin", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const script = expectComplete(await agent.compileScript(
 		unsafeIIFEAsString(() => {
 			try {
@@ -28,7 +30,7 @@ await test("script source origin", async () => {
 });
 
 await test("script which throws", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const script = expectComplete(await agent.compileScript("throw new Error('wow');", { origin: { name: "test:script" } }));
 	const error = expectThrow(await script.run(realm)) as Error;
@@ -37,7 +39,7 @@ await test("script which throws", async () => {
 });
 
 await test("script with syntax error", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const error = expectThrow(await agent.compileScript("}"));
 	// @ts-expect-error
 	const message: unknown = error.message;
@@ -46,7 +48,7 @@ await test("script with syntax error", async () => {
 });
 
 await test("script which returns a circular object", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const result = await unsafeEvalAsStringInRealm(agent, realm, () => {
 		const date = new Date();
@@ -61,3 +63,16 @@ await test("script which returns a circular object", async () => {
 	assert.strictEqual(result.date1, result.date2);
 	assert.strictEqual(result.object, result);
 });
+
+await test("script result should not invoke interceptors", async () => {
+	await using agent = await Agent.create();
+	const realm = await agent.createRealm();
+	const script = expectComplete(await agent.compileScript(unsafeIIFEAsString(() => {
+		const object = Object.defineProperty({ name: "value" }, "name", {
+			enumerable: true,
+			get() { throw new Error("interceptor invoked"); },
+		});
+		return object;
+	})));
+	await assert.rejects(async () => expectComplete(await script.run(realm)), illegalAccess);
+});

package/test/{05.global.ts → 20.intrinsics/05.global.ts}

@@ -1,17 +1,17 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { unsafeEvalAsStringInRealm } from "./fixtures.js";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
 
 await test("realm global reference", async () => {
-	await using agent = await ivm.Agent.create();
-	const realm = await agent.createRealm();
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
 	await unsafeEvalAsStringInRealm(agent, realm, () => {
 		// @ts-expect-error
 		globalThis.test = 123;
 	});
 	const global = await realm.acquireGlobalObject();
-	const property = await global.get("test");
+	const property = expect(await global.get("test"));
 	const value = await property.copy();
 	assert.equal(value, 123);
 });

package/test/20.intrinsics/10.reference.ts

@@ -0,0 +1,111 @@
+import type { Reference } from "@isolated-vm/experimental";
+import * as assert from "node:assert/strict";
+import { test } from "node:test";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { expectComplete, unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
+
+const illegalAccess = new Error("illegal access");
+
+await test("function reference invoke", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		// @ts-expect-error
+		globalThis.fn = () => "wow";
+	});
+	const global = await realm.acquireGlobalObject();
+	const property = (await global.get("fn")) as Reference<() => unknown>;
+	const value = expectComplete(await property.invoke([]));
+	assert.equal(value, "wow");
+});
+
+await test("invoke function cross-param reference", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		// @ts-expect-error
+		globalThis.fn = (...values: unknown[]) => values;
+	});
+	const global = await realm.acquireGlobalObject();
+	const fn = await global.get("fn");
+	const object = {};
+	// @ts-expect-error
+	const [ left, right ] = expectComplete(await fn.invoke([ object, object ]));
+	assert.strictEqual(left, right);
+});
+
+await test("invoke function reference with circular object", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		// @ts-expect-error
+		globalThis.fn = (value: unknown) => value;
+	});
+	const global = await realm.acquireGlobalObject();
+	const fn = (await global.get("fn")) as Reference<(value: unknown) => unknown>;
+	const date = new Date();
+	const object: Record<string, any> = {
+		record: {},
+		date1: date,
+		date2: date,
+	};
+	object.object = object;
+	const result = expectComplete(await fn.invoke([ object ]));
+	// @ts-expect-error
+	assert.strictEqual(result.date1, result.date2);
+	// @ts-expect-error
+	assert.strictEqual(result.object, result);
+});
+
+await test("get & set should not invoke proxies", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		const proxy = new Proxy({}, {
+			get() { throw new Error("interceptor invoked"); },
+			set() { throw new Error("interceptor invoked"); },
+		});
+		// @ts-expect-error
+		globalThis.proxy = proxy;
+	});
+	const global = await realm.acquireGlobalObject();
+	const proxy = expect(await global.get("proxy"));
+	expect(await proxy.get("name"));
+	expect(await proxy.set("name", undefined));
+});
+
+await test("copy should not invoke interceptors", async () => {
+	await using agent = await Agent.create();
+	const realm = await agent.createRealm();
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		const object =
+			Object.defineProperty({}, "name", {
+				enumerable: true,
+				get() { throw new Error("interceptor invoked"); },
+			});
+		// @ts-expect-error
+		globalThis.object = object;
+	});
+	const global = await realm?.acquireGlobalObject();
+	const object = await global?.get("object");
+	await assert.rejects(async () => object?.copy(), illegalAccess);
+});
+
+await test("invoke should not invoke interceptors", async () => {
+	await using agent = await Agent.create();
+	const realm = await agent.createRealm();
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		// @ts-expect-error
+		globalThis.fn = () => {};
+		// eslint-disable-next-line no-extend-native
+		Object.defineProperty(Object.prototype, "name", {
+			set() { throw new Error("interceptor invoked"); },
+		});
+	});
+	const global = await realm?.acquireGlobalObject();
+	const fn = await global?.get("fn") as Reference<(...args: unknown[]) => unknown> | null;
+	await assert.rejects(
+		async () => expectComplete(await fn?.invoke([ { name: "value" } ])),
+		illegalAccess,
+	);
+});

package/test/{10.module.ts → 20.intrinsics/20.module.ts}

@@ -1,11 +1,11 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { makeNullLinker } from "../utility/linker.js";
-import { expectComplete, expectThrow } from "./fixtures.js";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { expectComplete, expectThrow } from "@isolated-vm/experimental/test/fixtures";
+import { makeNullLinker } from "@isolated-vm/experimental/utility/linker";
 
 await test("module linker", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const left = expectComplete(await agent.compileModule('import { right } from "right"; globalThis.right = right;'));
 	const right = expectComplete(await agent.compileModule('export function right() { return "hello"; }'));
@@ -20,18 +20,18 @@ await test("module linker", async () => {
 });
 
 await test("nested compilation in module linker", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const left = expectComplete(await agent.compileModule('import "right";'));
 	await left.link(realm, async () => expectComplete(await agent.compileModule("export {};")));
 });
 
 await test("synthetic module capability", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const capabilityName = "isolated-vm:///capability";
 	let didInvoke = false;
-	const realm = await agent.createRealm();
-	const capability = await realm.createCapability(
+	const realm = expect(await agent.createRealm());
+	const capability = expect(await realm.createCapability(
 		() => ({
 			default: (value1: unknown, value2: unknown) => {
 				didInvoke = true;
@@ -39,7 +39,7 @@ await test("synthetic module capability", async () => {
 				assert.equal(value2, "world");
 			},
 		}),
-		{ origin: capabilityName });
+		{ origin: capabilityName }));
 	const left = expectComplete(await agent.compileModule(`
 		import capability from ${JSON.stringify(capabilityName)};
 		capability("hello", "world");
@@ -53,10 +53,10 @@ await test("synthetic module capability", async () => {
 });
 
 await test("synthetic module with circular reference", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const capabilityName = "isolated-vm:///capability";
-	const realm = await agent.createRealm();
-	const capability = await realm.createCapability(
+	const realm = expect(await agent.createRealm());
+	const capability = expect(await realm.createCapability(
 		() => ({
 			default: (value1: unknown) => {
 				// @ts-expect-error
@@ -65,7 +65,7 @@ await test("synthetic module with circular reference", async () => {
 				assert.strictEqual(value1.object, value1);
 			},
 		}),
-		{ origin: capabilityName });
+		{ origin: capabilityName }));
 	const left = expectComplete(await agent.compileModule(`
 		import capability from ${JSON.stringify(capabilityName)};
 		const date = new Date();
@@ -84,10 +84,32 @@ await test("synthetic module with circular reference", async () => {
 	await left.evaluate(realm);
 });
 
+await test("synthetic module with data templates", async () => {
+	await using agent = await Agent.create();
+	const capabilityName = "isolated-vm:///capability";
+	const realm = expect(await agent.createRealm());
+	const capability = expect(await realm.createCapability(
+		() => ({
+			string: "string",
+		}),
+		{ origin: capabilityName }));
+	const entry = expectComplete(await agent.compileModule(`
+		import { string } from ${JSON.stringify(capabilityName)};
+		globalThis.result = JSON.stringify({ string });
+	`));
+	await entry.link(realm, () => capability);
+	await entry.evaluate(realm);
+	const global = expect(await realm.acquireGlobalObject());
+	const result = expect(await global.get("result"));
+	assert.equal(await result.copy(), JSON.stringify({
+		string: "string",
+	}));
+});
+
 // TODO: This terminates the process. It should probably raise an async error, because there is no
 // promise.
 // await test("throw from synthetic module", async () => {
-// 	await using agent = await ivm.Agent.create();
+// 	await using agent = await Agent.create();
 // 	const capabilityName = "isolated-vm:///capability";
 // 	const realm = await agent.createRealm();
 // 	const capability = await realm.createCapability(
@@ -109,7 +131,7 @@ await test("synthetic module with circular reference", async () => {
 // });
 
 await test("throw from linker", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const left = expectComplete(await agent.compileModule('import "right";'));
 	await assert.rejects(left.link(realm, () => {
@@ -118,7 +140,7 @@ await test("throw from linker", async () => {
 });
 
 await test("throw from evaluation", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const module = expectComplete(await agent.compileModule('throw new Error("wow");', { origin: { name: "test:module" } }));
 	await module.link(realm, makeNullLinker());
@@ -128,7 +150,7 @@ await test("throw from evaluation", async () => {
 });
 
 await test("missing imports", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const realm = await agent.createRealm();
 	const left = expectComplete(await agent.compileModule('import { nothing } from "right";'));
 	await assert.rejects(left.link(realm, async () =>

package/test/{50.timers.ts → 50.features/50.timers.ts}

@@ -1,16 +1,16 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { expectComplete } from "@isolated-vm/experimental/test/fixtures";
 import { makeCompositeLinker, makeDirectResolver, makeFileSystemCompilationLoader, makeLinker, makeLocalResolver, makeStaticLoader } from "@isolated-vm/experimental/utility/linker";
-import { expectComplete } from "./fixtures.js";
 
 await test("setTimeout capability", async () => {
-	await using agent = await ivm.Agent.create();
-	const realm = await agent.createRealm();
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
 	const runTimers = expectComplete(await agent.compileScript("runTimers()"));
 	const resolvers = Promise.withResolvers();
 	const capabilities = makeStaticLoader({
-		"isolated-vm:capability/timers": await realm.createCapability(
+		"isolated-vm:capability/timers": expect(await realm.createCapability(
 			() => ({
 				default: (/*timeout*/) => {
 					void async function() {
@@ -18,12 +18,12 @@ await test("setTimeout capability", async () => {
 					}();
 				},
 			}),
-			{ origin: "isolated-vm:capability/timers" }),
-		"notify-test": await realm.createCapability(
+			{ origin: "isolated-vm:capability/timers" })),
+		"notify-test": expect(await realm.createCapability(
 			() => ({
 				default: (message: unknown) => { resolvers.resolve(message); },
 			}),
-			{ origin: "notify-test" }),
+			{ origin: "notify-test" })),
 	});
 
 	const runtime = makeFileSystemCompilationLoader(agent);

package/test/{99.i18n.ts → 50.features/90.i18n.ts}

@@ -1,16 +1,16 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { unsafeEvalAsString } from "./fixtures.js";
+import { Agent } from "@isolated-vm/experimental";
+import { unsafeEvalAsString } from "@isolated-vm/experimental/test/fixtures";
 
 await test("localCompare", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const result = await unsafeEvalAsString(agent, () => "a".localeCompare("b"));
 	assert.equal(result, -1);
 });
 
 await test("i18n locales", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const supported = await unsafeEvalAsString(agent, () =>
 		Intl.NumberFormat.supportedLocalesOf([ "ar-EG", "fa-IR", "zh-Hans", "hi-IN", "th-TH", "km-KH" ]));
 	// no "km-KH"
@@ -18,7 +18,7 @@ await test("i18n locales", async () => {
 });
 
 await test("i18n format", async () => {
-	await using agent = await ivm.Agent.create();
+	await using agent = await Agent.create();
 	const german = await unsafeEvalAsString(agent, () => new Intl.NumberFormat("de-DE").format(1234567.89));
 	assert.equal(german, "1.234.567,89");
 });

package/test/90.isolation/00.dispose.ts

@@ -1,15 +1,22 @@
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import {} from "@isolated-vm/experimental/test/fixtures";
+import { Agent, expectComplete } from "@isolated-vm/experimental";
+import "@isolated-vm/experimental/test/fixtures";
 
 await test("dispose while running", async () => {
 	const result = async function() {
-		await using agent = await ivm.Agent.create();
+		await using agent = await Agent.create();
 		const realm = await agent.createRealm();
-		const script = ivm.expectComplete(await agent.compileScript("for(;;);"));
+		const script = expectComplete(await agent.compileScript("for(;;);"));
 		// eslint-disable-next-line @typescript-eslint/return-await
 		return script.run(realm);
 	}();
-	assert.strictEqual(await result, undefined);
+	assert.strictEqual(await result, null);
+});
+
+await test("busy dispose", async () => {
+	await using agent = await Agent.create();
+	const [ dispose, realm ] = await Promise.all([ agent.disposeAsync(), agent.createRealm() ]);
+	assert.strictEqual(dispose, undefined);
+	assert.strictEqual(realm, null);
 });

package/test/90.isolation/10.memory.ts

@@ -0,0 +1,28 @@
+import assert from "node:assert";
+import { test } from "node:test";
+import { Agent, expectComplete } from "@isolated-vm/experimental";
+import "@isolated-vm/experimental/test/fixtures";
+
+await test("memory limit", async () => {
+	await using agent = await Agent.create({ memoryLimitBytes: 128 << 20 });
+	const realm = await agent.createRealm();
+	const sourceText =
+`const x = [];
+for (;;) {
+	let a = 'a';
+	for(; a.length < 2**28;) a += a;
+	x.push(a);
+}`;
+	const script = expectComplete(await agent.compileScript(sourceText));
+	const result = await script.run(realm);
+	assert.strictEqual(result, null);
+});
+
+await test("array spread", async () => {
+	await using agent = await Agent.create({ memoryLimitBytes: 128 << 20 });
+	const realm = await agent.createRealm();
+	const sourceText = "[...'.'.repeat(5e7)]; undefined";
+	const script = expectComplete(await agent.compileScript(sourceText));
+	const result = await script.run(realm);
+	assert.strictEqual(result, null);
+});