@isolated-vm/experimental 0.0.8 → 0.0.10

package/test/{00.random.ts → 00.agent/10.random.ts}

@@ -1,10 +1,10 @@
 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";
 
-const makeAgentRandom =	async (randomSeed?: number) => {
-	await using agent = await ivm.Agent.create({ randomSeed });
+const makeAgentRandom = async (randomSeed?: number) => {
+	await using agent = await Agent.create({ randomSeed });
 	return await unsafeEvalAsString(agent, () => Math.random());
 };
 

package/test/10.transfer/00.primitives.ts

@@ -0,0 +1,47 @@
+import * as assert from "node:assert/strict";
+import { test } from "node:test";
+import { Agent, Realm } from "@isolated-vm/experimental";
+import { unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
+
+async function check(agent: Agent, realm: Realm | null, fn: () => unknown) {
+	const result = await unsafeEvalAsStringInRealm(agent, realm, fn);
+	assert.deepStrictEqual(result, fn());
+}
+
+await test("primitives", async () => {
+	await using agent = await Agent.create();
+	const realm = await agent.createRealm();
+
+	// null, undefined, bool
+	await check(agent, realm, () => null);
+	await check(agent, realm, () => undefined);
+	await check(agent, realm, () => true);
+	await check(agent, realm, () => false);
+
+	// boolean
+	await check(agent, realm, () => true);
+	await check(agent, realm, () => false);
+
+	// string
+	await check(agent, realm, () => "hello world");
+	await check(agent, realm, () => "\u{10ffff}");
+
+	// number
+	await check(agent, realm, () => 0);
+	await check(agent, realm, () => Number.MAX_SAFE_INTEGER);
+	await check(agent, realm, () => Number.MAX_SAFE_INTEGER + 1);
+	await check(agent, realm, () => Number.MIN_SAFE_INTEGER);
+	await check(agent, realm, () => Number.MIN_SAFE_INTEGER - 1);
+	await check(agent, realm, () => Math.PI);
+
+	// bigint
+	await check(agent, realm, () => 0n);
+	await check(agent, realm, () => 9_223_372_036_854_775_807n); // int64 max
+	await check(agent, realm, () => 9_223_372_036_854_775_808n); // int64 max + 1
+	await check(agent, realm, () => -9_223_372_036_854_775_808n); // int64 min
+	await check(agent, realm, () => -9_223_372_036_854_775_809n); // int64 min - 1
+	await check(agent, realm, () => 18_446_744_073_709_551_615n); // uint64 max
+	await check(agent, realm, () => 18_446_744_073_709_551_616n); // uint64 max + 1
+	await check(agent, realm, () => 502_360_950_888_298_027_355_518_043_327_124_471_675_959_709_617_316_205_938_938_264_006_428_765_255_489n); // 256 bit number
+	await check(agent, realm, () => -502_360_950_888_298_027_355_518_043_327_124_471_675_959_709_617_316_205_938_938_264_006_428_765_255_490n); // 256 bit negative
+});

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);
@@ -130,20 +135,21 @@ await describe("shared array buffer", async () => {
 	});
 });
 
-await describe("typed array", async () => {
-	await test("transfer out", async () => {
-		await using agent = await ivm.Agent.create();
-		const [ uint8, uint8_copy ] = await unsafeEvalAsString(agent, () => {
-			const uint8 = new Uint8Array([ 1, 2, 3 ]);
-			return [ uint8, new Uint8Array(uint8.buffer) ];
-		});
-		assert.deepStrictEqual(uint8, new Uint8Array([ 1, 2, 3 ]));
-		assert.strictEqual(uint8.buffer, uint8_copy.buffer);
+// TODO: deno fails when this is in the `describe` (??)
+await test("transfer out", async () => {
+	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) ];
 	});
+	assert.deepStrictEqual(uint8, new Uint8Array([ 1, 2, 3 ]));
+	assert.strictEqual(uint8.buffer, uint8_copy.buffer);
+});
 
+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 ]);
@@ -158,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/50.interceptors.ts

@@ -0,0 +1,63 @@
+import * as assert from "node:assert/strict";
+import { describe, test } from "node:test";
+import { Agent } from "@isolated-vm/experimental";
+import { unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
+
+const supportsExpectedFailure =
+	// @ts-expect-error
+	process.isBun === undefined && process.versions.deno === undefined;
+
+if (supportsExpectedFailure) {
+	// None of these work!
+	await test("named proxy", { expectFailure: "interceptor invoked" }, async () => {
+		await using agent = await Agent.create();
+		const realm = await agent.createRealm();
+		const result = await unsafeEvalAsStringInRealm(agent, realm, () => {
+			const proxy = new Proxy({ name: "value" }, {
+				get() { throw new Error("interceptor invoked"); },
+			});
+			return proxy;
+		});
+		assert.deepStrictEqual(result, { name: undefined });
+	});
+
+	await test("indexed proxy", { expectFailure: "interceptor invoked" }, async () => {
+		await using agent = await Agent.create();
+		const realm = await agent.createRealm();
+		const result = await unsafeEvalAsStringInRealm(agent, realm, () => {
+			const proxy = new Proxy([ 0, 1 ], {
+				get() { throw new Error("interceptor invoked"); },
+			});
+			return proxy;
+		});
+		assert.deepStrictEqual(result, [ undefined, undefined ]);
+	});
+
+	await describe("named getter", { expectFailure: "interceptor invoked" }, async () => {
+		await using agent = await Agent.create();
+		const realm = await agent.createRealm();
+		const result = await unsafeEvalAsStringInRealm(agent, realm, () => {
+			const object = { name: "value" };
+			Object.defineProperty(object, "name", {
+				enumerable: true,
+				get() { throw new Error("interceptor invoked"); },
+			});
+			return object;
+		});
+		assert.deepStrictEqual(result, { name: undefined });
+	});
+
+	await describe("indexed getter", { expectFailure: "interceptor invoked" }, async () => {
+		await using agent = await Agent.create();
+		const realm = await agent.createRealm();
+		const result = await unsafeEvalAsStringInRealm(agent, realm, () => {
+			const array = [ 0, 1 ];
+			Object.defineProperty(array, 0, {
+				enumerable: true,
+				get() { throw new Error("interceptor invoked"); },
+			});
+			return array;
+		});
+		assert.deepStrictEqual(result, [ undefined, 1 ]);
+	});
+}

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,10 @@
 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";
 
 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 +28,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 +37,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 +46,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();

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/{10.reference.ts → 20.intrinsics/10.reference.ts}

@@ -1,24 +1,25 @@
+import type { Reference } from "@isolated-vm/experimental";
 import * as assert from "node:assert/strict";
 import { test } from "node:test";
-import * as ivm from "@isolated-vm/experimental";
-import { expectComplete, unsafeEvalAsStringInRealm } from "./fixtures.js";
+import { Agent, expect } from "@isolated-vm/experimental";
+import { expectComplete, unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
 
 await test("function reference invoke", 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.fn = () => "wow";
 	});
 	const global = await realm.acquireGlobalObject();
-	const property = (await global.get("fn")) as ivm.Reference<() => unknown>;
+	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 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.fn = (...values: unknown[]) => values;
@@ -32,14 +33,14 @@ await test("invoke function cross-param reference", async () => {
 });
 
 await test("invoke function reference with circular object", 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.fn = (value: unknown) => value;
 	});
 	const global = await realm.acquireGlobalObject();
-	const fn = (await global.get("fn")) as ivm.Reference<(value: unknown) => unknown>;
+	const fn = (await global.get("fn")) as Reference<(value: unknown) => unknown>;
 	const date = new Date();
 	const object: Record<string, any> = {
 		record: {},
@@ -55,8 +56,8 @@ await test("invoke function reference with circular object", async () => {
 });
 
 await test("get & set should not invoke proxies", 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.prox = new Proxy({}, {
@@ -67,16 +68,16 @@ await test("get & set should not invoke proxies", async () => {
 		});
 	});
 	const global = await realm.acquireGlobalObject();
-	const prox = await global.get("prox");
+	const prox = expect(await global.get("prox"));
 	await prox.get("name");
-	assert.equal(await (await global.get("failed")).copy(), undefined);
-	await prox.set("name", undefined);
-	assert.equal(await (await global.get("failed")).copy(), undefined);
+	assert.equal(await expect(await global.get("failed")).copy(), undefined);
+	expect(await prox.set("name", undefined));
+	assert.equal(await expect(await global.get("failed")).copy(), undefined);
 
 	// sanity check
 	await unsafeEvalAsStringInRealm(agent, realm, () => {
 		// @ts-expect-error
 		globalThis.failed = true;
 	});
-	assert.equal(await (await global.get("failed")).copy(), true);
+	assert.equal(await expect(await global.get("failed")).copy(), true);
 });

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();
@@ -87,7 +87,7 @@ await test("synthetic module with circular reference", async () => {
 // 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 +109,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 +118,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 +128,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");
 });