@isolated-vm/experimental 0.0.12 → 0.0.13

package/test/10.transfer/20.transfer_list.ts

@@ -0,0 +1,102 @@
+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";
+
+/** Returns a reference to a function which describes the buffers in its parameter */
+async function makeDescribe(agent: Agent) {
+	type Describe = (message?: unknown) => readonly (number | boolean | null)[] | null;
+	const realm = expect(await agent.createRealm());
+	await unsafeEvalAsStringInRealm(agent, realm, () => {
+		// @ts-expect-error
+		globalThis.fn = (message: { buffer?: ArrayBuffer; view?: Uint8Array }) =>
+			message.buffer
+				? [ message.view ? message.view.buffer === message.buffer : null, ...new Uint8Array(message.buffer) ]
+				: null;
+	});
+	const global = await realm.acquireGlobalObject();
+	return expect(await global.get("fn")) as Reference<Describe>;
+}
+
+await test("transferred buffer is moved", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+	const result = expectComplete(await fn.invoke([ { buffer } ], { transfer: [ buffer ] }));
+	assert.equal(buffer.byteLength, 0);
+	assert.deepStrictEqual(result, [ null, 1, 2, 3 ]);
+});
+
+await test("transferred buffer reached through a view", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const view = Uint8Array.from([ 1, 2, 3 ]);
+	const result = expectComplete(await fn.invoke([ { buffer: view.buffer, view } ], { transfer: [ view.buffer ] }));
+	assert.equal(view.buffer.byteLength, 0);
+	assert.deepStrictEqual(result, [ true, 1, 2, 3 ]);
+});
+
+await test("transferred buffer keeps its identity", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+	const view = new Uint8Array(buffer);
+	const result = expectComplete(await fn.invoke([ { buffer, view } ], { transfer: [ buffer ] }));
+	assert.equal(buffer.byteLength, 0);
+	assert.deepStrictEqual(result, [ true, 1, 2, 3 ]);
+});
+
+await test("unlisted buffer is copied", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+	const result = expectComplete(await fn.invoke([ { buffer } ]));
+	assert.equal(buffer.byteLength, 3);
+	assert.deepStrictEqual(result, [ null, 1, 2, 3 ]);
+});
+
+await test("unvisited buffer is detached", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = new ArrayBuffer(3);
+	expectComplete(await fn.invoke([ "hello" ], { transfer: [ buffer ] }));
+	assert.equal(buffer.byteLength, 0);
+});
+
+await test("duplicate buffer throws", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = new ArrayBuffer(3);
+	assert.throws(() => void fn.invoke([], { transfer: [ buffer, buffer ] }));
+	assert.equal(buffer.byteLength, 3);
+});
+
+await test("unknown transfer value throws", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	assert.throws(() => void fn.invoke([], { transfer: [ {} ] }));
+});
+
+await test("sparse transfer list throws", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const buffer = new ArrayBuffer(3);
+	const list = new Array<ArrayBuffer>(2);
+	list[1] = buffer;
+	assert.throws(() => void fn.invoke([], { transfer: list }), /sparse/i);
+	assert.equal(buffer.byteLength, 3);
+});
+
+await test("throwing transfer list getter propagates", async () => {
+	await using agent = await Agent.create();
+	const fn = await makeDescribe(agent);
+	const list: ArrayBuffer[] = [];
+	Object.defineProperty(list, 0, {
+		enumerable: true,
+		get: () => {
+			throw new Error("boom");
+		},
+	});
+	assert.throws(() => void fn.invoke([], { transfer: list }), /boom/);
+});

package/test/20.intrinsics/15.transfer_return.ts

@@ -0,0 +1,109 @@
+import type { Realm, 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, expectThrow, unsafeEvalAsStringInRealm } from "@isolated-vm/experimental/test/fixtures";
+import { makeDirectResolver, makeLinker, makeStaticLoader } from "@isolated-vm/experimental/utility/linker";
+
+async function makeTransferFunction(agent: Agent, realm: Realm, body: string) {
+	const runtime = expect(await realm.instantiateRuntime());
+	const module = expectComplete(await agent.compileModule(`
+		import { transfer } from "isolated-vm://runtime";
+		globalThis.fn = () => { ${body} };
+	`));
+	await module.link(realm, makeLinker(makeDirectResolver(), makeStaticLoader({ "isolated-vm://runtime": runtime })));
+	expectComplete(await module.evaluate(realm));
+	const global = await realm.acquireGlobalObject();
+	return expect(await global.get("fn")) as Reference<(...args: unknown[]) => unknown>;
+}
+
+function byteLengthInRealm(agent: Agent, realm: Realm) {
+	return unsafeEvalAsStringInRealm(agent, realm, () =>
+		(globalThis as unknown as { buffer: ArrayBuffer }).buffer.byteLength);
+}
+
+await test("returned buffer is moved", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+		globalThis.buffer = buffer;
+		return transfer(buffer, [ buffer ]);`);
+	const result = expectComplete(await fn.invoke([])) as ArrayBuffer;
+	assert.deepStrictEqual(Array.from(new Uint8Array(result)), [ 1, 2, 3 ]);
+	assert.equal(await byteLengthInRealm(agent, realm), 0);
+});
+
+await test("returned buffer reached through a view", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`const view = Uint8Array.from([ 1, 2, 3 ]);
+		globalThis.buffer = view.buffer;
+		return transfer(view, [ view.buffer ]);`);
+	const result = expectComplete(await fn.invoke([])) as Uint8Array;
+	assert.deepStrictEqual(Array.from(result), [ 1, 2, 3 ]);
+	assert.equal(await byteLengthInRealm(agent, realm), 0);
+});
+
+await test("returned buffer keeps its identity", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+		const view = new Uint8Array(buffer);
+		return transfer({ buffer, view }, [ buffer ]);`);
+	const result = expectComplete(await fn.invoke([])) as { buffer: ArrayBuffer; view: Uint8Array };
+	assert.equal(result.view.buffer, result.buffer);
+	assert.deepStrictEqual(Array.from(new Uint8Array(result.buffer)), [ 1, 2, 3 ]);
+});
+
+await test("unlisted buffer is copied", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`const buffer = Uint8Array.from([ 1, 2, 3 ]).buffer;
+		globalThis.buffer = buffer;
+		return transfer(buffer);`);
+	const result = expectComplete(await fn.invoke([])) as ArrayBuffer;
+	assert.deepStrictEqual(Array.from(new Uint8Array(result)), [ 1, 2, 3 ]);
+	assert.equal(await byteLengthInRealm(agent, realm), 3);
+});
+
+await test("unvisited buffer is detached", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`globalThis.buffer = new ArrayBuffer(3);
+		return transfer("hello", [ globalThis.buffer ]);`);
+	const result = expectComplete(await fn.invoke([]));
+	assert.equal(result, "hello");
+	assert.equal(await byteLengthInRealm(agent, realm), 0);
+});
+
+await test("getters throw", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm,
+		`const buffer = new ArrayBuffer(3);
+		const transferList = [ buffer ];
+		Object.defineProperty(transferList, 0, {
+			get() { return buffer }
+		});
+		return transfer("hello", transferList);`);
+	expectThrow(await fn.invoke([]));
+});
+
+await test("invalid transfer list throws", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm, "return transfer(1, 'nope')");
+	expectThrow(await fn.invoke([]));
+});
+
+await test("unknown transfer value throws", async () => {
+	await using agent = await Agent.create();
+	const realm = expect(await agent.createRealm());
+	const fn = await makeTransferFunction(agent, realm, "return transfer(1, [ {} ])");
+	expectThrow(await fn.invoke([]));
+});

package/test/20.intrinsics/20.module.ts

@@ -32,13 +32,13 @@ await test("synthetic module capability", async () => {
 	let didInvoke = false;
 	const realm = expect(await agent.createRealm());
 	const capability = expect(await realm.createCapability(
-		() => ({
+		{
 			default: (value1: unknown, value2: unknown) => {
 				didInvoke = true;
 				assert.equal(value1, "hello");
 				assert.equal(value2, "world");
 			},
-		}),
+		},
 		{ origin: capabilityName }));
 	const left = expectComplete(await agent.compileModule(`
 		import capability from ${JSON.stringify(capabilityName)};
@@ -57,14 +57,14 @@ await test("synthetic module with circular reference", async () => {
 	const capabilityName = "isolated-vm:///capability";
 	const realm = expect(await agent.createRealm());
 	const capability = expect(await realm.createCapability(
-		() => ({
+		{
 			default: (value1: unknown) => {
 				// @ts-expect-error
 				assert.strictEqual(value1.date1, value1.date2);
 				// @ts-expect-error
 				assert.strictEqual(value1.object, value1);
 			},
-		}),
+		},
 		{ origin: capabilityName }));
 	const left = expectComplete(await agent.compileModule(`
 		import capability from ${JSON.stringify(capabilityName)};
@@ -89,9 +89,9 @@ await test("synthetic module with data templates", async () => {
 	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)};
@@ -113,11 +113,11 @@ await test("synthetic module with data templates", async () => {
 // 	const capabilityName = "isolated-vm:///capability";
 // 	const realm = await agent.createRealm();
 // 	const capability = await realm.createCapability(
-// 		() => ({
+// 		{
 // 			default: () => {
 // 				throw new Error("capability error");
 // 			},
-// 		}),
+// 		},
 // 		{ origin: capabilityName });
 // 	const left = expectComplete(await agent.compileModule(`
 // 		import capability from ${JSON.stringify(capabilityName)};

package/test/50.features/50.timers.ts

@@ -11,18 +11,18 @@ await test("setTimeout capability", async () => {
 	const resolvers = Promise.withResolvers();
 	const capabilities = makeStaticLoader({
 		"isolated-vm:capability/timers": expect(await realm.createCapability(
-			() => ({
+			{
 				default: (/*timeout*/) => {
 					void async function() {
 						await runTimers.run(realm);
 					}();
 				},
-			}),
+			},
 			{ origin: "isolated-vm:capability/timers" })),
 		"notify-test": expect(await realm.createCapability(
-			() => ({
+			{
 				default: (message: unknown) => { resolvers.resolve(message); },
-			}),
+			},
 			{ origin: "notify-test" })),
 	});
 

package/utility/object.ts

@@ -0,0 +1,22 @@
+/** @internal */
+export type Constructor<Type> = (abstract new (...args: any[]) => Type);
+
+type AddThis<Type, Fn> =
+	Fn extends (...args: infer Args) => infer Return
+		? (this: Type, ...args: Args) => Return
+		: never;
+
+/** @internal */
+export function extend<Type, Proto extends {
+	[Key in keyof Type]?: AddThis<Type, Type[Key]>;
+}>(constructor: Constructor<Type>, prototype: Proto): void {
+	const descriptors = Object.getOwnPropertyDescriptors(prototype);
+	for (const key of Reflect.ownKeys(descriptors)) {
+		const info = descriptors[key as keyof Proto];
+		if (info.value && typeof info.value === "function") {
+			Object.defineProperty(constructor.prototype, key, { ...info, enumerable: false });
+		} else {
+			throw new Error(`Cannot extend ${constructor.name} with non-function property ${String(key)}`);
+		}
+	}
+}