rivetkit 2.3.5-rc.1 → 2.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "rivetkit",
-	"version": "2.3.5-rc.1",
+	"version": "2.3.6",
 	"description": "Lightweight libraries for building stateful actors on edge platforms",
 	"license": "Apache-2.0",
 	"keywords": [
@@ -72,6 +72,16 @@
 				"default": "./dist/tsup/db/drizzle.cjs"
 			}
 		},
+		"./unstable/migrations": {
+			"import": {
+				"types": "./dist/tsup/unstable/migrations.d.ts",
+				"default": "./dist/tsup/unstable/migrations.js"
+			},
+			"require": {
+				"types": "./dist/tsup/unstable/migrations.d.cts",
+				"default": "./dist/tsup/unstable/migrations.cjs"
+			}
+		},
 		"./dynamic": {
 			"import": {
 				"types": "./dist/tsup/dynamic/mod.d.ts",
@@ -171,7 +181,7 @@
 		"./dist/tsup/chunk-*.cjs"
 	],
 	"scripts": {
-		"build": "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/inspector-tab/mod.ts src/db/mod.ts src/db/drizzle.ts src/dynamic/mod.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
+		"build": "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/utils.ts src/workflow/mod.ts src/test/mod.ts src/inspector/mod.ts src/inspector-tab/mod.ts src/db/mod.ts src/db/drizzle.ts src/dynamic/mod.ts src/unstable/migrations.ts && tsup src/agent-os/index.ts --no-clean --out-dir dist/tsup/agent-os",
 		"build:browser": "tsup --config tsup.browser.config.ts",
 		"check-types": "tsc --noEmit",
 		"lint": "biome check . && pnpm run check:test-skips && pnpm run check:wait-for-comments",
@@ -191,14 +201,14 @@
 		"@hono/zod-openapi": "^1.1.5",
 		"@rivet-dev/agent-os-core": "^0.1.1",
 		"@rivetkit/bare-ts": "^0.6.2",
-		"@rivetkit/engine-cli": "2.3.5-rc.1",
-		"@rivetkit/engine-envoy-protocol": "2.3.5-rc.1",
+		"@rivetkit/engine-cli": "2.3.6",
+		"@rivetkit/engine-envoy-protocol": "2.3.6",
 		"@rivetkit/on-change": "6.0.1",
-		"@rivetkit/rivetkit-napi": "2.3.5-rc.1",
-		"@rivetkit/rivetkit-wasm": "2.3.5-rc.1",
-		"@rivetkit/traces": "2.3.5-rc.1",
-		"@rivetkit/virtual-websocket": "2.3.5-rc.1",
-		"@rivetkit/workflow-engine": "2.3.5-rc.1",
+		"@rivetkit/rivetkit-napi": "2.3.6",
+		"@rivetkit/rivetkit-wasm": "2.3.6",
+		"@rivetkit/traces": "2.3.6",
+		"@rivetkit/virtual-websocket": "2.3.6",
+		"@rivetkit/workflow-engine": "2.3.6",
 		"cbor-x": "^1.6.0",
 		"drizzle-orm": "^0.44.2",
 		"hono": "^4.7.0",

package/src/actor/actions.ts

@@ -0,0 +1,119 @@
+import type { PrimitiveSchema } from "./schema";
+
+export type RuntimeActionHandler = (...args: any[]) => any;
+
+export function flattenActionHandlers(
+	actions: unknown,
+): Record<string, RuntimeActionHandler> {
+	const flattened = Object.create(null) as Record<
+		string,
+		RuntimeActionHandler
+	>;
+	for (const { name, handler } of collectActionEntries(actions)) {
+		flattened[name] = handler;
+	}
+	return flattened;
+}
+
+export function flattenActionInputSchemas(
+	actions: unknown,
+	schemas: unknown,
+): Record<string, PrimitiveSchema> | undefined {
+	if (schemas === undefined) return undefined;
+	if (!isRecord(schemas)) {
+		throw new TypeError("actionInputSchemas must be an object");
+	}
+
+	const flattened = Object.create(null) as Record<string, PrimitiveSchema>;
+	for (const { name, path } of collectActionEntries(actions)) {
+		const nestedSchema = lookupNestedSchema(schemas, path);
+		const flatSchema = schemas[name];
+		if (
+			nestedSchema !== undefined &&
+			flatSchema !== undefined &&
+			nestedSchema !== flatSchema
+		) {
+			throw new TypeError(
+				`Action input schema \`${name}\` is defined by both a nested path and a dotted key`,
+			);
+		}
+
+		const schema = nestedSchema ?? flatSchema;
+		if (schema !== undefined) {
+			flattened[name] = schema as PrimitiveSchema;
+		}
+	}
+	return flattened;
+}
+
+interface ActionEntry {
+	name: string;
+	path: string[];
+	handler: RuntimeActionHandler;
+}
+
+function collectActionEntries(actions: unknown): ActionEntry[] {
+	const entries: ActionEntry[] = [];
+	const names = new Set<string>();
+	visitActionGroup(actions ?? {}, [], entries, names);
+	return entries;
+}
+
+function visitActionGroup(
+	value: unknown,
+	path: string[],
+	entries: ActionEntry[],
+	names: Set<string>,
+) {
+	if (!isRecord(value)) {
+		throw new TypeError(
+			`${formatActionPath(path)} must be an action handler or group`,
+		);
+	}
+
+	for (const [segment, child] of Object.entries(value)) {
+		const childPath = [...path, segment];
+		if (typeof child === "function") {
+			const name = childPath.join(".");
+			if (names.has(name)) {
+				throw new TypeError(
+					`Multiple action definitions flatten to \`${name}\``,
+				);
+			}
+			names.add(name);
+			entries.push({
+				name,
+				path: childPath,
+				handler: child as RuntimeActionHandler,
+			});
+		} else {
+			visitActionGroup(child, childPath, entries, names);
+		}
+	}
+}
+
+function lookupNestedSchema(
+	schemas: Record<string, unknown>,
+	path: string[],
+): unknown {
+	let value: unknown = schemas;
+	for (const segment of path) {
+		if (!isRecord(value) || !Object.hasOwn(value, segment)) {
+			return undefined;
+		}
+		value = value[segment];
+	}
+	return value;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return false;
+	}
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+function formatActionPath(path: string[]): string {
+	return path.length === 0 ? "actions" : `Action \`${path.join(".")}\``;
+}

package/src/actor/config.ts

@@ -6,6 +6,7 @@ import type {
 } from "@/common/database/config";
 import type { UniversalWebSocket } from "@/common/websocket-interface";
 import type { Registry } from "@/registry";
+import { flattenActionHandlers } from "./actions";
 import type { BaseActorDefinition } from "./definition";
 import type {
 	EventSchemaConfig,
@@ -792,6 +793,32 @@ const zFunction = <
 	T extends (...args: any[]) => any = (...args: unknown[]) => unknown,
 >() => z.custom<T>((val) => typeof val === "function");
 
+const zActionTree = z
+	.custom<Record<string, unknown>>((value) => {
+		if (
+			typeof value !== "object" ||
+			value === null ||
+			Array.isArray(value)
+		) {
+			return false;
+		}
+		const prototype = Object.getPrototypeOf(value);
+		return prototype === Object.prototype || prototype === null;
+	})
+	.superRefine((actions, ctx) => {
+		try {
+			flattenActionHandlers(actions);
+		} catch (error) {
+			ctx.addIssue({
+				code: "custom",
+				message:
+					error instanceof Error
+						? error.message
+						: "Invalid action definition",
+			});
+		}
+	});
+
 export type InspectorUnsubscribe = () => void;
 
 export interface WorkflowInspectorConfig<THistory = unknown> {
@@ -1128,7 +1155,7 @@ export const ActorConfigSchema = z
 		onBeforeActionResponse: zFunction().optional(),
 		onRequest: zFunction().optional(),
 		onWebSocket: zFunction().optional(),
-		actions: z.record(z.string(), zFunction()).default(() => ({})),
+		actions: zActionTree.default(() => ({})),
 		actionInputSchemas: z.record(z.string(), z.any()).optional(),
 		connParamsSchema: z.any().optional(),
 		events: z.record(z.string(), z.any()).optional(),
@@ -1275,19 +1302,34 @@ export interface Actions<
 	TEvents extends EventSchemaConfig = Record<never, never>,
 	TQueues extends QueueSchemaConfig = Record<never, never>,
 > {
-	[Action: string]: (
-		c: ActionContext<
-			TState,
-			TConnParams,
-			TConnState,
-			TVars,
-			TInput,
-			TDatabase,
-			TEvents,
-			TQueues
-		>,
-		...args: any[]
-	) => any;
+	[Action: string]:
+		| ((
+				c: ActionContext<
+					TState,
+					TConnParams,
+					TConnState,
+					TVars,
+					TInput,
+					TDatabase,
+					TEvents,
+					TQueues
+				>,
+				...args: any[]
+		  ) => any)
+		| Actions<
+				TState,
+				TConnParams,
+				TConnState,
+				TVars,
+				TInput,
+				TDatabase,
+				TEvents,
+				TQueues
+		  >;
+}
+
+export interface ActionInputSchemas {
+	[Action: string]: PrimitiveSchema | ActionInputSchemas;
 }
 
 //export type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TAuthData> = BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TAuthData> &
@@ -1655,9 +1697,10 @@ interface BaseActorConfig<
 	actions?: TActions;
 
 	/**
-	 * Optional schema map for validating action argument tuples in native runtimes.
+	 * Optional schemas for validating action argument tuples in native runtimes.
+	 * May mirror nested action groups or use dot-separated low-level action names.
 	 */
-	actionInputSchemas?: Record<string, PrimitiveSchema>;
+	actionInputSchemas?: ActionInputSchemas;
 
 	/**
 	 * Optional schema for validating connection params in native runtimes.
@@ -2184,13 +2227,13 @@ export const DocActorConfigSchema = z
 			.record(z.string(), z.unknown())
 			.optional()
 			.describe(
-				"Map of action name to handler function. Defaults to an empty object.",
+				"Tree of action names or nested groups to handler functions. Nested paths use dot-separated low-level action names. Defaults to an empty object.",
 			),
 		actionInputSchemas: z
 			.record(z.string(), z.unknown())
 			.optional()
 			.describe(
-				"Optional schema map for validating action argument tuples in native runtimes.",
+				"Optional schemas for validating action argument tuples in native runtimes. May mirror nested action groups or use dot-separated low-level action names.",
 			),
 		connParamsSchema: z
 			.unknown()

package/src/actor/definition.ts

@@ -1,5 +1,6 @@
 import type { AnyDatabaseProvider } from "@/common/database/config";
 import type { RegistryConfig } from "@/registry/config";
+import { flattenActionHandlers, flattenActionInputSchemas } from "./actions";
 import {
 	type Actions,
 	type ActorConfig,
@@ -206,6 +207,8 @@ export function actor<
 		TQueues,
 		TActions
 	>;
+	flattenActionHandlers(config.actions);
+	flattenActionInputSchemas(config.actions, config.actionInputSchemas);
 	return new ActorDefinition(config);
 }
 

package/src/client/actor-common.ts

@@ -43,7 +43,9 @@ type ActorActionMap<R> = {
 		...args: infer Args
 	) => infer Return
 		? ActorActionFunction<Args, Awaited<Return>>
-		: never;
+		: NonNullable<R>[K] extends Record<string, unknown>
+			? ActorActionMap<NonNullable<R>[K]>
+			: never;
 };
 
 type ActionsOf<AD extends AnyActorDefinition> =

package/src/client/client.ts

@@ -515,11 +515,30 @@ export function createClientWithDriver<A extends Registry<any>>(
 /**
  * Creates a proxy for a actor that enables calling actions without explicitly using `.action`.
  **/
-function createActorProxy<AD extends AnyActorDefinition>(
+export function createActorProxy<AD extends AnyActorDefinition>(
 	handle: ActorHandleRaw | ActorConnRaw,
 ): ActorHandle<AD> | ActorConn<AD> {
-	// Stores returned action functions for faster calls
+	// Stores returned action path proxies for faster calls.
 	const methodCache = new Map<string, ActorActionFunction>();
+	const actionPath = (name: string): ActorActionFunction => {
+		let method = methodCache.get(name);
+		if (method) return method;
+
+		method = new Proxy(
+			(...args: unknown[]) => handle.action({ name, args }),
+			{
+				get(target, prop: string | symbol) {
+					if (typeof prop === "symbol")
+						return Reflect.get(target, prop);
+					if (prop === "then") return undefined;
+					return actionPath(`${name}.${prop}`);
+				},
+			},
+		) as ActorActionFunction;
+		methodCache.set(name, method);
+		return method;
+	};
+
 	return new Proxy(handle, {
 		get(target: ActorHandleRaw, prop: string | symbol, receiver: unknown) {
 			// Handle built-in Symbol properties
@@ -542,13 +561,7 @@ function createActorProxy<AD extends AnyActorDefinition>(
 				// If JS is attempting to calling this as a promise, ignore it
 				if (prop === "then") return undefined;
 
-				let method = methodCache.get(prop);
-				if (!method) {
-					method = (...args: unknown[]) =>
-						target.action({ name: prop, args });
-					methodCache.set(prop, method);
-				}
-				return method;
+				return actionPath(prop);
 			}
 		},
 
@@ -575,6 +588,7 @@ function createActorProxy<AD extends AnyActorDefinition>(
 			target: ActorHandleRaw,
 			prop: string | symbol,
 		) {
+			if (prop === "then") return undefined;
 			const targetDescriptor = Reflect.getOwnPropertyDescriptor(
 				target,
 				prop,
@@ -588,8 +602,7 @@ function createActorProxy<AD extends AnyActorDefinition>(
 					configurable: true,
 					enumerable: false,
 					writable: false,
-					value: (...args: unknown[]) =>
-						target.action({ name: prop, args }),
+					value: actionPath(prop),
 				};
 			}
 			return undefined;

package/src/registry/config/index.ts

@@ -353,9 +353,7 @@ export const RegistryConfigSchema = z
 		const endpoint = config.startEngine
 			? localEngineEndpoint
 			: (parsedEndpoint?.endpoint ??
-				(isDevEnv
-					? buildEngineEndpoint(ENGINE_HOST, ENGINE_PORT)
-					: undefined));
+				(isDevEnv ? localEngineEndpoint : undefined));
 		const validateServerlessEndpoint = Boolean(
 			config.startEngine || parsedEndpoint,
 		);
@@ -388,7 +386,7 @@ export const RegistryConfigSchema = z
 		// In dev mode, clients connect directly to the local Rivet Engine.
 		const publicEndpoint =
 			parsedPublicEndpoint?.endpoint ??
-			(isDevEnv && config.startEngine ? endpoint : undefined);
+			(isDevEnv && !parsedEndpoint ? endpoint : undefined);
 		// We extract publicNamespace to validate that it matches the backend
 		// namespace (see validation above), not for functional use.
 		const publicNamespace = parsedPublicEndpoint?.namespace;

package/src/registry/index.ts

@@ -19,6 +19,8 @@ import type { RuntimeServerlessResponseHead } from "./runtime";
 
 type ShutdownSignal = "SIGINT" | "SIGTERM";
 
+const REGISTRY_READY_TIMEOUT_MS = 30_000;
+
 function signalExitCode(signal: ShutdownSignal): number {
 	switch (signal) {
 		case "SIGINT":
@@ -73,6 +75,8 @@ export class Registry<A extends RegistryActors> {
 	}
 
 	#runtimeServePromise?: Promise<void>;
+	#runtimeServeLifecyclePromise?: Promise<void>;
+	#runtimeReadyPromise?: Promise<void>;
 	#runtimeServeConfiguredPromise?: ReturnType<typeof buildConfiguredRegistry>;
 	#runtimeServerlessPromise?: ReturnType<typeof buildConfiguredRegistry>;
 	#configureServerlessPoolPromise?: Promise<void>;
@@ -490,17 +494,20 @@ export class Registry<A extends RegistryActors> {
 			const configuredRegistryPromise =
 				this.#buildConfiguredRegistry(config);
 			this.#runtimeServeConfiguredPromise = configuredRegistryPromise;
-			this.#runtimeServePromise = configuredRegistryPromise
-				.then(async ({ runtime, registry, serveConfig }) => {
+			this.#runtimeServeLifecyclePromise = configuredRegistryPromise.then(
+				async ({ runtime, registry, serveConfig }) => {
 					await runtime.serveRegistry(registry, serveConfig);
-				})
-				.catch((error) => {
+				},
+			);
+			this.#runtimeServePromise = this.#runtimeServeLifecyclePromise.catch(
+				(error) => {
 					// Always-attached catch so the stored promise never leaves a
 					// rejection unhandled. Downstream awaits (e.g. #runShutdown's
 					// Promise.race) attach their own catches and still observe
 					// resolution via the race.
 					logger().warn({ error }, "runtime registry serve errored");
-				});
+				},
+			);
 			// Install signal handlers once an envoy lifecycle has begun. Only
 			// Mode A ever reaches here. Mode B (handler(request)) intentionally
 			// does not install handlers because it runs on Workers/Vercel/Deno
@@ -694,6 +701,80 @@ export class Registry<A extends RegistryActors> {
 		this.#startEnvoy(this.parseConfig(), true);
 	}
 
+	/**
+	 * Starts the serverful registry if needed and waits until its envoy has
+	 * registered with the Engine. Repeated and concurrent calls share one
+	 * startup lifecycle and readiness promise.
+	 *
+	 * Unlike {@link start}, this reports startup failures and does not resolve
+	 * merely because an HTTP health endpoint is listening.
+	 */
+	public startAndWait(): Promise<void> {
+		if (this.#shutdownInFlight !== null) {
+			return Promise.reject(
+				new Error("registry.startAndWait() cannot run after shutdown has begun"),
+			);
+		}
+		if (this.#runtimeReadyPromise) return this.#runtimeReadyPromise;
+		if (getRivetkitRuntimeMode() === "serverless") {
+			return Promise.reject(
+				new Error(
+					"registry.startAndWait() requires envoy runtime mode; serverless registries become ready per request",
+				),
+			);
+		}
+
+		const config = this.parseConfig();
+		if (config.runtime === "wasm") {
+			return Promise.reject(
+				new Error(
+					"registry.startAndWait() requires the native runtime; WebAssembly registries do not host an envoy",
+				),
+			);
+		}
+		this.#startEnvoy(config, true);
+		const configuredRegistryPromise = this.#runtimeServeConfiguredPromise;
+		const serveLifecyclePromise = this.#runtimeServeLifecyclePromise;
+		if (!configuredRegistryPromise || !serveLifecyclePromise) {
+			throw new Error("registry envoy startup did not initialize");
+		}
+
+		let timeout: ReturnType<typeof setTimeout> | undefined;
+		const timeoutPromise = new Promise<never>((_resolve, reject) => {
+			timeout = setTimeout(
+				() =>
+					reject(
+						new Error(
+							`RivetKit registry did not register with the Engine within ${REGISTRY_READY_TIMEOUT_MS}ms`,
+						),
+					),
+				REGISTRY_READY_TIMEOUT_MS,
+			);
+			timeout.unref?.();
+		});
+		const readinessPromise = (async () => {
+			const { runtime, registry } = await configuredRegistryPromise;
+			const stoppedBeforeReady = serveLifecyclePromise.then(() => {
+				throw new Error("RivetKit registry stopped before becoming ready");
+			});
+			await Promise.race([
+				runtime.waitRegistryReady(registry),
+				stoppedBeforeReady,
+			]);
+		})();
+		this.#runtimeReadyPromise = Promise.race([
+			readinessPromise,
+			timeoutPromise,
+		]).finally(() => {
+			if (timeout !== undefined) clearTimeout(timeout);
+		});
+		// The native registry is consumed once serve begins. Retrying the same
+		// instance after failure could duplicate partially-created resources, so
+		// retain the rejected promise and return the same failure to later calls.
+		this.#runtimeReadyPromise.catch(() => {});
+		return this.#runtimeReadyPromise;
+	}
+
 	/**
 	 * Starts the actor envoy for standalone server deployments.
 	 *

package/src/registry/napi-runtime.ts

@@ -226,6 +226,10 @@ export class NapiCoreRuntime implements CoreRuntime {
 		await asNativeRegistry(registry).serve(config);
 	}
 
+	async waitRegistryReady(registry: RegistryHandle): Promise<void> {
+		await asNativeRegistry(registry).waitReady();
+	}
+
 	async shutdownRegistry(registry: RegistryHandle): Promise<void> {
 		await asNativeRegistry(registry).shutdown();
 	}

package/src/registry/native.ts

@@ -1,17 +1,21 @@
 import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
+import {
+	flattenActionHandlers,
+	flattenActionInputSchemas,
+} from "@/actor/actions";
 import {
 	ACTOR_CONTEXT_INTERNAL_SYMBOL,
-	CONN_STATE_MANAGER_SYMBOL,
-	disposeRunInspector,
-	getRunFunction,
-	getRunInspectorConfig,
-	RAW_STATE_SYMBOL,
 	type ActorCron,
 	type ActorCronEveryOptions,
 	type ActorCronSetOptions,
 	type ActorSchedule,
+	CONN_STATE_MANAGER_SYMBOL,
 	type CronFire,
 	type CronJobInfo,
+	disposeRunInspector,
+	getRunFunction,
+	getRunInspectorConfig,
+	RAW_STATE_SYMBOL,
 	type ScheduledEventInfo,
 	type WorkflowInspectorConfig,
 } from "@/actor/config";
@@ -84,10 +88,10 @@ import type {
 	RegistryHandle,
 	RuntimeActorConfig,
 	RuntimeBytes,
-	RuntimeHttpResponse,
-	RuntimeInspectorTabEntry,
 	RuntimeCronFire,
 	RuntimeCronJobInfo,
+	RuntimeHttpResponse,
+	RuntimeInspectorTabEntry,
 	RuntimeQueueMessage,
 	RuntimeScheduledEventInfo,
 	RuntimeScheduledFireInfo,
@@ -3524,7 +3528,7 @@ function buildActorConfig(
 		preloadMaxConnectionsBytes: options.preloadMaxConnectionsBytes as
 			| number
 			| undefined,
-		actions: Object.keys((config.actions ?? {}) as Record<string, unknown>)
+		actions: Object.keys(flattenActionHandlers(config.actions))
 			.sort()
 			.map((name) => ({ name })),
 		inspectorTabs: buildInspectorTabs(config.inspector, runtimeKind),
@@ -3628,19 +3632,16 @@ export function buildNativeFactory(
 ): ActorFactoryHandle {
 	const config = definition.config as Record<string, any>;
 	const databaseProvider = config.db as AnyDatabaseProvider;
+	const actionHandlers = flattenActionHandlers(config.actions);
 	const schemaConfig: NativeValidationConfig = {
-		actionInputSchemas: config.actionInputSchemas,
+		actionInputSchemas: flattenActionInputSchemas(
+			config.actions,
+			config.actionInputSchemas,
+		),
 		connParamsSchema: config.connParamsSchema,
 		events: config.events,
 		queues: config.queues,
 	};
-	const actionHandlers = Object.fromEntries(
-		(
-			Object.entries(config.actions ?? {}) as Array<
-				[string, (...args: Array<any>) => any]
-			>
-		).map(([name, handler]) => [name, handler]),
-	);
 	const createClient = () =>
 		createClientWithDriver(
 			new RemoteEngineControlClient(

package/src/registry/runtime.ts

@@ -412,6 +412,7 @@ export interface CoreRuntime {
 		registry: RegistryHandle,
 		config: RuntimeServeConfig,
 	): Promise<void>;
+	waitRegistryReady(registry: RegistryHandle): Promise<void>;
 	shutdownRegistry(registry: RegistryHandle): Promise<void>;
 	registryActorStopThresholdMs?(
 		registry: RegistryHandle,

package/src/registry/wasm-runtime.ts

@@ -274,6 +274,12 @@ export class WasmCoreRuntime implements CoreRuntime {
 		await callWasm(() => asWasmRegistry(registry).serve(config));
 	}
 
+	async waitRegistryReady(): Promise<void> {
+		throw new Error(
+			"registry.startAndWait() is not supported by the WASM runtime",
+		);
+	}
+
 	async shutdownRegistry(registry: RegistryHandle): Promise<void> {
 		await callWasm(() => asWasmRegistry(registry).shutdown());
 	}

package/src/test/mod.ts

@@ -1,31 +1,13 @@
-import pRetry from "p-retry";
 import type { TestContext } from "vitest";
 import { convertRegistryConfigToClientConfig } from "@/client/config";
 import { type Client, createClient } from "@/client/mod";
-import { getMetadata } from "@/engine-client/api-endpoints";
 import type { Registry } from "@/registry";
+import { waitForRegistryReady } from "./ready";
 
 export interface SetupTestResult<A extends Registry<any>> {
 	client: Client<A>;
 }
 
-async function waitForRegistryReady(registry: Registry<any>): Promise<void> {
-	const clientConfig = convertRegistryConfigToClientConfig(
-		registry.parseConfig(),
-	);
-
-	await pRetry(
-		async () => {
-			await getMetadata(clientConfig);
-		},
-		{
-			retries: 20,
-			minTimeout: 50,
-			maxTimeout: 250,
-		},
-	);
-}
-
 export async function setupTest<A extends Registry<any>>(
 	c: TestContext,
 	registry: A,