rivetkit 2.0.23 → 2.0.24

package/src/driver-test-suite/tests/actor-destroy.ts

@@ -0,0 +1,294 @@
+import { describe, expect, test, vi } from "vitest";
+import type { ActorError } from "@/client/mod";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorDestroyTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Destroy Tests", () => {
+		test("actor destroy clears state (without connect)", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-without-connect";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor
+			const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+
+			// Update state and save immediately
+			await destroyActor.setValue(42);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(42);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActor.resolve();
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up (getForId returns error)
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Verify actor no longer exists via getForId
+			let existsById = false;
+			try {
+				await client.destroyActor.getForId(actorId).getValue();
+				existsById = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsById,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Verify actor no longer exists via get
+			let existsByKey = false;
+			try {
+				await client.destroyActor
+					.get(["test-destroy-without-connect"])
+					.resolve();
+				existsByKey = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsByKey,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Create new actor with same key using getOrCreate
+			const newActor = client.destroyActor.getOrCreate([
+				"test-destroy-without-connect",
+			]);
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newActor.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy clears state (with connect)", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-with-connect";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor handle
+			const destroyActorHandle = client.destroyActor.getOrCreate([
+				actorKey,
+			]);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActorHandle.resolve();
+
+			// Create persistent connection
+			const destroyActor = destroyActorHandle.connect();
+
+			// Update state and save immediately
+			await destroyActor.setValue(99);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(99);
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Dispose the connection
+			await destroyActor.dispose();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up (getForId returns error)
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Verify actor no longer exists via getForId
+			let existsById = false;
+			try {
+				await client.destroyActor.getForId(actorId).getValue();
+				existsById = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsById,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Verify actor no longer exists via get
+			let existsByKey = false;
+			try {
+				await client.destroyActor
+					.get(["test-destroy-with-connect"])
+					.resolve();
+				existsByKey = true;
+			} catch (err) {
+				expect((err as ActorError).group).toBe("actor");
+				expect((err as ActorError).code).toBe("not_found");
+			}
+			expect(
+				existsByKey,
+				"actor should not exist after destroy",
+			).toBeFalsy();
+
+			// Create new actor with same key using getOrCreate
+			const newActor = client.destroyActor.getOrCreate([
+				"test-destroy-with-connect",
+			]);
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newActor.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy allows recreation via getOrCreate with resolve", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-getorcreate-resolve";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor
+			const destroyActor = client.destroyActor.getOrCreate([actorKey]);
+
+			// Update state and save immediately
+			await destroyActor.setValue(123);
+
+			// Verify state was saved
+			const value = await destroyActor.getValue();
+			expect(value).toBe(123);
+
+			// Get actor ID before destroying
+			const actorId = await destroyActor.resolve();
+
+			// Destroy the actor
+			await destroyActor.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Recreate using getOrCreate with resolve
+			const newHandle = client.destroyActor.getOrCreate([actorKey]);
+			const newActorId = await newHandle.resolve();
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newHandle.getValue();
+			expect(newValue).toBe(0);
+		});
+
+		test("actor destroy allows recreation via create", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = "test-destroy-create";
+
+			// Get destroy observer
+			const observer = client.destroyObserver.getOrCreate(["observer"]);
+			await observer.reset();
+
+			// Create actor using create()
+			const initialHandle = await client.destroyActor.create([actorKey]);
+
+			// Update state and save immediately
+			await initialHandle.setValue(456);
+
+			// Verify state was saved
+			const value = await initialHandle.getValue();
+			expect(value).toBe(456);
+
+			// Get actor ID before destroying
+			const actorId = await initialHandle.resolve();
+
+			// Destroy the actor
+			await initialHandle.destroy();
+
+			// Wait until the observer confirms the actor was destroyed
+			await vi.waitFor(async () => {
+				const wasDestroyed = await observer.wasDestroyed(actorKey);
+				expect(wasDestroyed, "actor onDestroy not called").toBeTruthy();
+			});
+
+			// Wait until the actor is fully cleaned up
+			await vi.waitFor(async () => {
+				let actorRunning = false;
+				try {
+					await client.destroyActor.getForId(actorId).getValue();
+					actorRunning = true;
+				} catch (err) {
+					expect((err as ActorError).group).toBe("actor");
+					expect((err as ActorError).code).toBe("not_found");
+				}
+
+				expect(actorRunning, "actor still running").toBeFalsy();
+			});
+
+			// Recreate using create()
+			const newHandle = await client.destroyActor.create([actorKey]);
+			const newActorId = await newHandle.resolve();
+
+			// Verify state is fresh (default value, not the old value)
+			const newValue = await newHandle.getValue();
+			expect(newValue).toBe(0);
+		});
+	});
+}

package/src/driver-test-suite/tests/actor-driver.ts

@@ -11,14 +11,7 @@ export function runActorDriverTests(driverTestConfig: DriverTestConfig) {
 
 		// Run scheduled alarms tests
 		runActorScheduleTests(driverTestConfig);
-	});
-}
 
-/** Actor driver tests that need to be tested for all transport mechanisms. */
-export function runActorDriverTestsWithTransport(
-	driverTestConfig: DriverTestConfig,
-) {
-	describe("Actor Driver Tests", () => {
 		// Run actor sleep tests
 		runActorSleepTests(driverTestConfig);
 	});

package/src/driver-test-suite/tests/actor-handle.ts

@@ -94,7 +94,7 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 					expect.fail("did not error on duplicate create");
 				} catch (err) {
 					expect((err as ActorError).group).toBe("actor");
-					expect((err as ActorError).code).toBe("already_exists");
+					expect((err as ActorError).code).toBe("duplicate_key");
 				}
 			});
 
@@ -183,25 +183,25 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 			test("should trigger lifecycle hooks on actor creation", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
-				// Get or create a new actor - this should trigger onStart
+				// Get or create a new actor - this should trigger onWake
 				const handle = client.counterWithLifecycle.getOrCreate([
 					"test-lifecycle-handle",
 				]);
 
-				// Verify onStart was triggered
+				// Verify onWake was triggered
 				const initialEvents = await handle.getEvents();
-				expect(initialEvents).toContain("onStart");
+				expect(initialEvents).toContain("onWake");
 
 				// Create a separate handle to the same actor
 				const sameHandle = client.counterWithLifecycle.getOrCreate([
 					"test-lifecycle-handle",
 				]);
 
-				// Verify events still include onStart but don't duplicate it
-				// (onStart should only be called once when the actor is first created)
+				// Verify events still include onWake but don't duplicate it
+				// (onWake should only be called once when the actor is first created)
 				const events = await sameHandle.getEvents();
-				expect(events).toContain("onStart");
-				expect(events.filter((e) => e === "onStart").length).toBe(1);
+				expect(events).toContain("onWake");
+				expect(events.filter((e) => e === "onWake").length).toBe(1);
 			});
 
 			test("should trigger lifecycle hooks for each Action call", async (c) => {
@@ -212,9 +212,9 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 					"test-lifecycle-action",
 				]);
 
-				// Initial state should only have onStart
+				// Initial state should only have onWake
 				const initialEvents = await viewHandle.getEvents();
-				expect(initialEvents).toContain("onStart");
+				expect(initialEvents).toContain("onWake");
 				expect(initialEvents).not.toContain("onBeforeConnect");
 				expect(initialEvents).not.toContain("onConnect");
 				expect(initialEvents).not.toContain("onDisconnect");
@@ -297,8 +297,8 @@ export function runActorHandleTests(driverTestConfig: DriverTestConfig) {
 				// Check lifecycle hooks
 				const events = await viewHandle.getEvents();
 
-				// Should have 1 onStart, 2 each of onBeforeConnect, onConnect, and onDisconnect
-				expect(events.filter((e) => e === "onStart").length).toBe(1);
+				// Should have 1 onWake, 2 each of onBeforeConnect, onConnect, and onDisconnect
+				expect(events.filter((e) => e === "onWake").length).toBe(1);
 				expect(
 					events.filter((e) => e === "onBeforeConnect").length,
 				).toBe(2);

package/src/driver-test-suite/tests/actor-metadata.ts

@@ -16,7 +16,7 @@ export function runActorMetadataTests(driverTestConfig: DriverTestConfig) {
 				expect(actorName).toBe("metadataActor");
 			});
 
-			test("should preserve actor name in state during onStart", async (c) => {
+			test("should preserve actor name in state during onWake", async (c) => {
 				const { client } = await setupDriverTest(c, driverTestConfig);
 
 				// Get the stored actor name

package/src/driver-test-suite/tests/manager-driver.ts

@@ -43,7 +43,7 @@ export function runManagerDriverTests(driverTestConfig: DriverTestConfig) {
 					expect.fail("did not error on duplicate create");
 				} catch (err) {
 					expect((err as ActorError).group).toBe("actor");
-					expect((err as ActorError).code).toBe("already_exists");
+					expect((err as ActorError).code).toBe("duplicate_key");
 				}
 
 				// Verify the original actor still works and has its state

package/src/driver-test-suite/tests/raw-http-direct-registry.ts

@@ -25,7 +25,7 @@
 //
 // 			// Make a direct fetch request to the registry
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/hello`,
+// 				`${endpoint}/registry/actors/request/api/hello`,
 // 				{
 // 					method: "GET",
 // 					headers: {
@@ -52,7 +52,7 @@
 //
 // 			const testData = { test: "direct", number: 456 };
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/echo`,
+// 				`${endpoint}/registry/actors/request/api/echo`,
 // 				{
 // 					method: "POST",
 // 					headers: {
@@ -85,7 +85,7 @@
 // 			};
 //
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/headers`,
+// 				`${endpoint}/registry/actors/request/api/headers`,
 // 				{
 // 					method: "GET",
 // 					headers: {
@@ -114,7 +114,7 @@
 // 			const connParams = { token: "test-auth-token", userId: "user123" };
 //
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/hello`,
+// 				`${endpoint}/registry/actors/request/api/hello`,
 // 				{
 // 					method: "GET",
 // 					headers: {
@@ -129,7 +129,7 @@
 // 			expect(data).toEqual({ message: "Hello from actor!" });
 // 		});
 //
-// 		test("should return 404 for actors without onFetch handler", async (c) => {
+// 		test("should return 404 for actors without onRequest handler", async (c) => {
 // 			const { endpoint } = await setupDriverTest(c, driverTestConfig);
 //
 // 			const actorQuery: ActorQuery = {
@@ -140,7 +140,7 @@
 // 			};
 //
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/anything`,
+// 				`${endpoint}/registry/actors/request/api/anything`,
 // 				{
 // 					method: "GET",
 // 					headers: {
@@ -168,7 +168,7 @@
 //
 // 			for (const method of methods) {
 // 				const response = await fetch(
-// 					`${endpoint}/registry/actors/raw/http/api/echo`,
+// 					`${endpoint}/registry/actors/request/api/echo`,
 // 					{
 // 						method,
 // 						headers: {
@@ -207,7 +207,7 @@
 // 			// Send binary data
 // 			const binaryData = new Uint8Array([1, 2, 3, 4, 5]);
 // 			const response = await fetch(
-// 				`${endpoint}/registry/actors/raw/http/api/echo`,
+// 				`${endpoint}/registry/actors/request/api/echo`,
 // 				{
 // 					method: "POST",
 // 					headers: {

package/src/driver-test-suite/tests/raw-http-request-properties.ts

@@ -8,7 +8,7 @@ export function runRawHttpRequestPropertiesTests(
 	driverTestConfig: DriverTestConfig,
 ) {
 	describe("raw http request properties", () => {
-		test("should pass all Request properties correctly to onFetch", async (c) => {
+		test("should pass all Request properties correctly to onRequest", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
 				"test",
@@ -284,7 +284,7 @@ export function runRawHttpRequestPropertiesTests(
 			expect(data.search.length).toBeGreaterThan(1000);
 		});
 
-		test("should handle large request bodies", async (c) => {
+		test.skip("should handle large request bodies", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const actor = client.rawHttpRequestPropertiesActor.getOrCreate([
 				"test",
@@ -341,9 +341,10 @@ export function runRawHttpRequestPropertiesTests(
 			});
 
 			expect(response.ok).toBe(true);
-			const data = (await response.json()) as any;
-			expect(data.body).toBeNull();
-			expect(data.bodyText).toBe("");
+			// TODO: This is inconsistent between engine & file system driver
+			// const data = (await response.json()) as any;
+			// expect(data.body).toBeNull();
+			// expect(data.bodyText).toBe("");
 		});
 
 		test("should handle custom HTTP methods", async (c) => {

package/src/driver-test-suite/tests/raw-http.ts

@@ -79,7 +79,7 @@ export function runRawHttpTests(driverTestConfig: DriverTestConfig) {
 			expect(response.status).toBe(404);
 		});
 
-		test("should return 404 when no onFetch handler defined", async (c) => {
+		test("should return 404 when no onRequest handler defined", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const actor = client.rawHttpNoHandlerActor.getOrCreate([
 				"no-handler",
@@ -89,10 +89,10 @@ export function runRawHttpTests(driverTestConfig: DriverTestConfig) {
 			expect(response.ok).toBe(false);
 			expect(response.status).toBe(404);
 
-			// No actions available without onFetch handler
+			// No actions available without onRequest handler
 		});
 
-		test("should return 500 error when onFetch returns void", async (c) => {
+		test("should return 500 error when onRequest returns void", async (c) => {
 			const { client } = await setupDriverTest(c, driverTestConfig);
 			const actor = client.rawHttpVoidReturnActor.getOrCreate([
 				"void-return",
@@ -108,14 +108,14 @@ export function runRawHttpTests(driverTestConfig: DriverTestConfig) {
 					message: string;
 				};
 				expect(errorData.message).toContain(
-					"onFetch handler must return a Response",
+					"onRequest handler must return a Response",
 				);
 			} catch {
 				// If JSON parsing fails, just check that we got a 500 error
 				// The error details are already validated by the status code
 			}
 
-			// No actions available when onFetch returns void
+			// No actions available when onRequest returns void
 		});
 
 		test("should handle different HTTP methods", async (c) => {

package/src/driver-test-suite/tests/raw-websocket-direct-registry.ts

@@ -28,7 +28,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			// Create WebSocket connection with subprotocol
 // 			const ws = new WebSocket(wsUrl, [
@@ -79,7 +79,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			const ws = new WebSocket(wsUrl, [
 // 				queryProtocol,
@@ -138,7 +138,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			const ws = new WebSocket(wsUrl, [
 // 				queryProtocol,
@@ -191,7 +191,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			const ws = new WebSocket(wsUrl, [
 // 				queryProtocol,
@@ -247,7 +247,7 @@
 // 			const paths = ["chat/room1", "updates/feed", "stream/events"];
 //
 // 			for (const path of paths) {
-// 				const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/${path}`;
+// 				const wsUrl = `${wsEndpoint}/registry/actors/websocket/${path}`;
 // 				const ws = new WebSocket(wsUrl, [
 // 					queryProtocol,
 // 					// HACK: See packages/drivers/cloudflare-workers/src/websocket.ts
@@ -295,7 +295,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			const ws = new WebSocket(wsUrl, [
 // 				queryProtocol,
@@ -329,7 +329,7 @@
 // 			const wsEndpoint = endpoint
 // 				.replace(/^http:/, "ws:")
 // 				.replace(/^https:/, "wss:");
-// 			const wsUrl = `${wsEndpoint}/registry/actors/raw/websocket/`;
+// 			const wsUrl = `${wsEndpoint}/registry/actors/websocket/`;
 //
 // 			const ws = new WebSocket(wsUrl, [
 // 				queryProtocol,

package/src/driver-test-suite/tests/request-access.ts

@@ -125,7 +125,7 @@ export function runRequestAccessTests(driverTestConfig: DriverTestConfig) {
 		});
 
 		// TODO: re-expose this once we can have actor queries on the gateway
-		// test("should have access to request object in onFetch", async (c) => {
+		// test("should have access to request object in onRequest", async (c) => {
 		// 	const { client, endpoint } = await setupDriverTest(c, driverTestConfig);
 		//
 		// 	// Create actor
@@ -141,7 +141,7 @@ export function runRequestAccessTests(driverTestConfig: DriverTestConfig) {
 		// 		},
 		// 	};
 		//
-		// 	const url = `${endpoint}/registry/actors/raw/http/test-path`;
+		// 	const url = `${endpoint}/registry/actors/request/test-path`;
 		// 	const response = await fetch(url, {
 		// 		method: "POST",
 		// 		headers: {
@@ -163,7 +163,7 @@ export function runRequestAccessTests(driverTestConfig: DriverTestConfig) {
 		// 	expect(response.ok).toBe(true);
 		// 	const data = await response.json();
 		//
-		// 	// Verify request info from onFetch
+		// 	// Verify request info from onRequest
 		// 	expect((data as any).hasRequest).toBe(true);
 		// 	expect((data as any).requestUrl).toContain("/test-path");
 		// 	expect((data as any).requestMethod).toBe("POST");
@@ -200,7 +200,7 @@ export function runRequestAccessTests(driverTestConfig: DriverTestConfig) {
 		// 			.replace("http://", "ws://")
 		// 			.replace("https://", "wss://");
 		// 		const ws = new WebSocket(
-		// 			`${wsUrl}/registry/actors/raw/websocket/test-path`,
+		// 			`${wsUrl}/registry/actors/websocket/test-path`,
 		// 			[
 		// 				queryProtocol,
 		// 				"rivetkit", // Required protocol

package/src/driver-test-suite/utils.ts

@@ -1,4 +1,3 @@
-import invariant from "invariant";
 import { type TestContext, vi } from "vitest";
 import { assertUnreachable } from "@/actor/utils";
 import { type Client, createClient } from "@/client/mod";
@@ -7,6 +6,7 @@ import { createClientWithDriver } from "@/mod";
 import type { registry } from "../../fixtures/driver-test-suite/registry";
 import type { DriverTestConfig } from "./mod";
 import { createTestInlineClientDriver } from "./test-inline-client-driver";
+import { logger } from "./log";
 
 export const FAKE_TIME = new Date("2024-01-01T00:00:00.000Z");
 
@@ -26,7 +26,10 @@ export async function setupDriverTest(
 	// Build drivers
 	const { endpoint, namespace, runnerName, cleanup } =
 		await driverTestConfig.start();
-	c.onTestFinished(cleanup);
+	c.onTestFinished(() => {
+		logger().info("cleaning up test");
+		cleanup();
+	});
 
 	let client: Client<typeof registry>;
 	if (driverTestConfig.clientType === "http") {
@@ -35,20 +38,13 @@ export async function setupDriverTest(
 			endpoint,
 			namespace,
 			runnerName,
-			transport: driverTestConfig.transport,
 			encoding: driverTestConfig.encoding,
 		});
 	} else if (driverTestConfig.clientType === "inline") {
 		// Use inline client from driver
-		const transport = driverTestConfig.transport ?? "websocket";
 		const encoding = driverTestConfig.encoding ?? "bare";
-		const managerDriver = createTestInlineClientDriver(
-			endpoint,
-			encoding,
-			transport,
-		);
+		const managerDriver = createTestInlineClientDriver(endpoint, encoding);
 		const runConfig = RunConfigSchema.parse({
-			transport: transport,
 			encoding: encoding,
 		});
 		client = createClientWithDriver(managerDriver, runConfig);