rivetkit 2.3.0-rc.8 → 2.3.0

package/src/drivers/engine/actor-driver.ts

@@ -1,9 +1,9 @@
 import type { EnvoyConfig } from "@rivetkit/rivetkit-native/wrapper";
 import {
-	type HibernatingWebSocketMetadata,
 	type EnvoyHandle,
+	type HibernatingWebSocketMetadata,
 	openDatabaseFromEnvoy,
-	protocol,
+	type protocol,
 	startEnvoySync,
 } from "@rivetkit/rivetkit-native/wrapper";
 import * as cbor from "cbor-x";
@@ -11,17 +11,19 @@ import type { Context as HonoContext } from "hono";
 import { streamSSE } from "hono/streaming";
 import { WSContext, type WSContextInit } from "hono/ws";
 import invariant from "invariant";
-import { type AnyConn, CONN_STATE_MANAGER_SYMBOL } from "@/actor/conn/mod";
+import { CONN_STATE_MANAGER_SYMBOL } from "@/actor/conn/mod";
 import { isStaticActorDefinition, lookupInRegistry } from "@/actor/definition";
+import type { ActorDriver } from "@/actor/driver";
+import { KEYS } from "@/actor/instance/keys";
+import type { AnyActorInstance } from "@/actor/instance/mod";
 import {
-	isStaticActorInstance,
 	type AnyStaticActorInstance,
+	isStaticActorInstance,
 } from "@/actor/instance/mod";
-import { KEYS } from "@/actor/instance/keys";
 import {
-	type PreloadMap,
 	compareBytes,
 	createPreloadMap,
+	type PreloadMap,
 } from "@/actor/instance/preload-map";
 import { deserializeActorKey } from "@/actor/keys";
 import type { Encoding } from "@/actor/protocol/serde";
@@ -41,6 +43,10 @@ import {
 } from "@/common/actor-router-consts";
 import { getLogger } from "@/common/log";
 import { deconstructError } from "@/common/utils";
+import type {
+	RivetMessageEvent,
+	UniversalWebSocket,
+} from "@/common/websocket-interface";
 import {
 	buildHibernatableWebSocketAckStateTestResponse,
 	type IndexedWebSocketPayload,
@@ -49,21 +55,19 @@ import {
 	setHibernatableWebSocketAckTestHooks,
 	unregisterRemoteHibernatableWebSocketAckHooks,
 } from "@/common/websocket-test-hooks";
-import type {
-	RivetMessageEvent,
-	UniversalWebSocket,
-} from "@/common/websocket-interface";
-import type { ActorDriver } from "@/actor/driver";
-import type { AnyActorInstance } from "@/actor/instance/mod";
 import {
-	getInitialActorKvState,
+	type JsNativeDatabaseLike,
+	wrapJsNativeDatabase,
+} from "@/db/native-database";
+import {
 	type EngineControlClient,
+	getInitialActorKvState,
 } from "@/driver-helpers/mod";
 import { DynamicActorInstance } from "@/dynamic/instance";
-import { DynamicActorIsolateRuntime } from "@/dynamic/isolate-runtime";
 import { isDynamicActorDefinition } from "@/dynamic/internal";
-import { buildActorNames, type RegistryConfig } from "@/registry/config";
+import { DynamicActorIsolateRuntime } from "@/dynamic/isolate-runtime";
 import { getEndpoint } from "@/engine-client/api-utils";
+import { buildActorNames, type RegistryConfig } from "@/registry/config";
 import {
 	type LongTimeoutHandle,
 	promiseWithResolvers,
@@ -71,10 +75,6 @@ import {
 	stringifyError,
 	VERSION,
 } from "@/utils";
-import {
-	wrapJsNativeDatabase,
-	type JsNativeDatabaseLike,
-} from "@/db/native-database";
 import { logger } from "./log";
 
 const ENVOY_SSE_PING_INTERVAL = 1000;
@@ -88,13 +88,13 @@ const REMOTE_ACK_HOOK_QUERY_PARAM = "__rivetkitAckHook";
 //
 // See engine/packages/pegboard-gateway/src/shared_state.rs
 // (HWS_MESSAGE_ACK_TIMEOUT)
-const CONN_MESSAGE_ACK_DEADLINE = 5_000;
+const _CONN_MESSAGE_ACK_DEADLINE = 5_000;
 
 // Force saveState when cumulative message size reaches this threshold (0.5 MB)
 //
 // See engine/packages/pegboard-gateway/src/shared_state.rs
 // (HWS_MAX_PENDING_MSGS_SIZE_PER_REQ)
-const CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD = 500_000;
+const _CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD = 500_000;
 
 interface ActorHandler {
 	actor?: AnyActorInstance;
@@ -144,7 +144,6 @@ export type DriverContext = {};
 
 export class EngineActorDriver implements ActorDriver {
 	#config: RegistryConfig;
-	#engineClient: EngineControlClient;
 	#inlineClient: Client<any>;
 	#envoy: EnvoyHandle;
 	#actors: Map<string, ActorHandler> = new Map();
@@ -161,15 +160,6 @@ export class EngineActorDriver implements ActorDriver {
 		string,
 		HibernatableRunnerWebSocketBinding
 	>();
-	#hwsMessageIndex = new Map<
-		string,
-		{
-			serverMessageIndex: number;
-			bufferedMessageSize: number;
-			pendingAckFromMessageIndex: boolean;
-			pendingAckFromBufferSize: boolean;
-		}
-	>();
 	#actorRouter: ActorRouter;
 
 	#envoyStarted: PromiseWithResolvers<void> = promiseWithResolvers((reason) =>
@@ -376,8 +366,7 @@ export class EngineActorDriver implements ActorDriver {
 		requestId: ArrayBuffer,
 	): void {
 		const key = this.#hibernatableWebSocketAckKey(gatewayId, requestId);
-		const binding =
-			this.#hibernatableRunnerWebSocketBindings.get(key);
+		const binding = this.#hibernatableRunnerWebSocketBindings.get(key);
 		if (!binding) {
 			return;
 		}
@@ -397,8 +386,7 @@ export class EngineActorDriver implements ActorDriver {
 		requestId: ArrayBuffer,
 	): void {
 		const key = this.#hibernatableWebSocketAckKey(gatewayId, requestId);
-		const binding =
-			this.#hibernatableRunnerWebSocketBindings.get(key);
+		const binding = this.#hibernatableRunnerWebSocketBindings.get(key);
 		binding?.detach?.();
 		this.#hibernatableRunnerWebSocketBindings.delete(key);
 	}
@@ -585,7 +573,7 @@ export class EngineActorDriver implements ActorDriver {
 		return handler;
 	}
 
-	getContext(actorId: string): DriverContext {
+	getContext(_actorId: string): DriverContext {
 		return {};
 	}
 
@@ -1140,7 +1128,10 @@ export class EngineActorDriver implements ActorDriver {
 						actorId: binding.actorId,
 						error: stringifyError(error),
 					});
-					binding.websocket.close(1011, "dynamic.websocket_forward_failed");
+					binding.websocket.close(
+						1011,
+						"dynamic.websocket_forward_failed",
+					);
 				});
 		};
 		const onClose = (event: CloseEvent) => {
@@ -1270,7 +1261,10 @@ export class EngineActorDriver implements ActorDriver {
 					msg: "dynamic runtime websocket binding is missing after restore",
 					actorId: binding.actorId,
 				});
-				binding.websocket.close(1011, "dynamic.websocket_forward_failed");
+				binding.websocket.close(
+					1011,
+					"dynamic.websocket_forward_failed",
+				);
 				return;
 			}
 
@@ -1286,7 +1280,10 @@ export class EngineActorDriver implements ActorDriver {
 						actorId: binding.actorId,
 						error: stringifyError(error),
 					});
-					binding.websocket.close(1011, "dynamic.websocket_forward_failed");
+					binding.websocket.close(
+						1011,
+						"dynamic.websocket_forward_failed",
+					);
 				});
 		};
 		const onClose = (event: CloseEvent) => {
@@ -1990,7 +1987,10 @@ export class EngineActorDriver implements ActorDriver {
 				isRestoringHibernatable,
 			);
 		} catch (error) {
-			logger().error({ msg: "building websocket handlers errored", error });
+			logger().error({
+				msg: "building websocket handlers errored",
+				error,
+			});
 			websocketRaw.close(1011, "ws.route_error");
 			return;
 		}
@@ -2005,7 +2005,7 @@ export class EngineActorDriver implements ActorDriver {
 		// Get connection and actor from wsHandler (may be undefined for inspector endpoint)
 		const conn = wsHandler.conn;
 		const actor = wsHandler.actor;
-		const connStateManager = conn?.[CONN_STATE_MANAGER_SYMBOL];
+		const _connStateManager = conn?.[CONN_STATE_MANAGER_SYMBOL];
 
 		// Bind event listeners to Hono WebSocket handlers
 		//
@@ -2044,16 +2044,15 @@ export class EngineActorDriver implements ActorDriver {
 
 			const currentActor = this.#actors.get(actorId)?.actor;
 			const actorForDispatch =
-				currentActor &&
-				isStaticActorInstance(currentActor)
+				currentActor && isStaticActorInstance(currentActor)
 					? currentActor
 					: actor;
 			const connForDispatch =
 				isHibernatable && actorForDispatch
-					? actorForDispatch.connectionManager.findHibernatableConn(
+					? (actorForDispatch.connectionManager.findHibernatableConn(
 							gatewayIdBuf,
 							requestIdBuf,
-						) ?? conn
+						) ?? conn)
 					: conn;
 
 			if (actorForDispatch?.isStopping) {
@@ -2063,7 +2062,10 @@ export class EngineActorDriver implements ActorDriver {
 					actorId: actorForDispatch?.id,
 					messageIndex: event.rivetMessageIndex,
 				});
-				if (!isRawWebSocketPath && websocket.readyState !== websocket.CLOSED) {
+				if (
+					!isRawWebSocketPath &&
+					websocket.readyState !== websocket.CLOSED
+				) {
 					websocket.close(1011, "actor.stopping");
 				}
 				return;

package/src/dynamic/instance.ts

@@ -0,0 +1,32 @@
+import type { DynamicActorIsolateRuntime } from "./isolate-runtime";
+
+export class DynamicActorInstance {
+	constructor(
+		public readonly id: string,
+		private readonly runtime: DynamicActorIsolateRuntime,
+	) {}
+
+	get isStopping(): boolean {
+		return this.runtime.isStopping;
+	}
+
+	async onStop(mode: "sleep" | "destroy"): Promise<void> {
+		await this.runtime.stop(mode);
+	}
+
+	async onAlarm(): Promise<void> {
+		await this.runtime.onAlarm();
+	}
+
+	async cleanupPersistedConnections(reason?: string): Promise<number> {
+		return await this.runtime.cleanupPersistedConnections(reason);
+	}
+
+	async getHibernatingWebSockets() {
+		return await this.runtime.getHibernatingWebSockets();
+	}
+
+	getHibernatingWebSocketMetadata() {
+		return this.runtime.getHibernatingWebSocketMetadata();
+	}
+}

package/src/dynamic/internal.ts

@@ -0,0 +1,50 @@
+import type {
+	AnyActorDefinition,
+	BaseActorDefinition,
+} from "@/actor/definition";
+
+export const DYNAMIC_ACTOR_DEFINITION_SYMBOL = Symbol.for(
+	"rivetkit.dynamic_actor_definition",
+);
+
+export interface DynamicActorSource {
+	source: string;
+	nodeProcess?: {
+		memoryLimit?: number;
+		cpuTimeLimitMs?: number;
+	};
+}
+
+export interface DynamicActorLoadContext {
+	key: string[];
+	client(): Promise<any>;
+}
+
+export type DynamicActorLoader = (
+	c: DynamicActorLoadContext,
+) => DynamicActorSource | Promise<DynamicActorSource>;
+
+export interface DynamicActorDefinition extends AnyActorDefinition {
+	readonly [DYNAMIC_ACTOR_DEFINITION_SYMBOL]: true;
+	readonly loader: DynamicActorLoader;
+}
+
+export function isDynamicActorDefinition(
+	definition: BaseActorDefinition<
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any,
+		any
+	>,
+): definition is DynamicActorDefinition {
+	return (
+		(definition as Partial<DynamicActorDefinition>)[
+			DYNAMIC_ACTOR_DEFINITION_SYMBOL
+		] === true
+	);
+}

package/src/dynamic/isolate-runtime.ts

@@ -0,0 +1,66 @@
+import type { ActorDriver } from "@/actor/driver";
+import type { Client } from "@/client/client";
+import type { RegistryConfig } from "@/registry/config";
+import type { DynamicActorLoader } from "./internal";
+
+export interface DynamicActorIsolateRuntimeConfig {
+	actorId: string;
+	actorName: string;
+	actorKey: string[];
+	input: unknown;
+	region: string;
+	loader: DynamicActorLoader;
+	actorDriver: ActorDriver;
+	inlineClient: Client<any>;
+	test: RegistryConfig["test"];
+}
+
+export interface DynamicHibernatingWebSocketMetadata {
+	gatewayId: ArrayBuffer;
+	requestId: ArrayBuffer;
+	serverMessageIndex: number;
+	clientMessageIndex: number;
+	path: string;
+	headers: Record<string, string>;
+}
+
+export class DynamicActorIsolateRuntime {
+	#isStopping = false;
+
+	constructor(private readonly config: DynamicActorIsolateRuntimeConfig) {}
+
+	get isStopping(): boolean {
+		return this.#isStopping;
+	}
+
+	async start(): Promise<void> {
+		await this.config.loader({
+			key: this.config.actorKey,
+			client: async () => this.config.inlineClient,
+		});
+	}
+
+	async stop(_mode: "sleep" | "destroy"): Promise<void> {
+		this.#isStopping = true;
+	}
+
+	async dispose(): Promise<void> {
+		this.#isStopping = true;
+	}
+
+	async onAlarm(): Promise<void> {}
+
+	async cleanupPersistedConnections(_reason?: string): Promise<number> {
+		return 0;
+	}
+
+	async getHibernatingWebSockets(): Promise<
+		DynamicHibernatingWebSocketMetadata[]
+	> {
+		return [];
+	}
+
+	getHibernatingWebSocketMetadata(): DynamicHibernatingWebSocketMetadata[] {
+		return [];
+	}
+}

package/src/dynamic/mod.ts

@@ -0,0 +1,32 @@
+import { ActorConfigSchema } from "@/actor/config";
+import type { AnyActorDefinition } from "@/actor/definition";
+import {
+	DYNAMIC_ACTOR_DEFINITION_SYMBOL,
+	type DynamicActorDefinition,
+	type DynamicActorLoader,
+} from "./internal";
+
+export interface DynamicActorConfig {
+	load: DynamicActorLoader;
+}
+
+export function dynamicActor(
+	input: DynamicActorConfig,
+): DynamicActorDefinition {
+	const config = ActorConfigSchema.parse({
+		actions: {},
+	}) as unknown as AnyActorDefinition["config"];
+
+	return {
+		[DYNAMIC_ACTOR_DEFINITION_SYMBOL]: true,
+		config,
+		loader: input.load,
+	};
+}
+
+export type {
+	DynamicActorDefinition,
+	DynamicActorLoadContext,
+	DynamicActorLoader,
+	DynamicActorSource,
+} from "./internal";

package/src/engine-client/actor-http-client.ts

@@ -5,7 +5,7 @@ import {
 	HEADER_RIVET_TARGET,
 	HEADER_RIVET_TOKEN,
 } from "@/common/actor-router-consts";
-import { shouldSkipReadyWait, type GatewayRequestOptions } from "./driver";
+import { type GatewayRequestOptions, shouldSkipReadyWait } from "./driver";
 
 export interface HttpGatewayRequestOptions extends GatewayRequestOptions {
 	directActorId?: string;
@@ -34,9 +34,9 @@ export async function sendHttpRequestToGateway(
 			bodyToSend = reqBody;
 
 			// If this is a streaming request, we need to convert the headers
-			// for the basic array buffer
+			// for the basic array buffer.
 			guardHeaders.delete("transfer-encoding");
-			guardHeaders.set("content-length", String(bodyToSend.byteLength));
+			guardHeaders.delete("content-length");
 		}
 	}
 

package/src/engine-client/actor-websocket-client.ts

@@ -2,24 +2,24 @@ import {
 	type ClientConfig,
 	DEFAULT_MAX_QUERY_INPUT_SIZE,
 } from "@/client/config";
+import type { ActorGatewayQuery, CrashPolicy } from "@/client/query";
 import {
+	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_CONN_PARAMS,
 	WS_PROTOCOL_ENCODING,
 	WS_PROTOCOL_STANDARD as WS_PROTOCOL_RIVETKIT,
-	WS_PROTOCOL_TARGET,
-	WS_PROTOCOL_ACTOR,
 	WS_PROTOCOL_SKIP_READY_WAIT,
+	WS_PROTOCOL_TARGET,
 	WS_PROTOCOL_TEST_ACK_HOOK,
 	WS_PROTOCOL_TOKEN,
 } from "@/common/actor-router-consts";
+import type { JsonCompatValue } from "@/common/encoding";
 import { importWebSocket } from "@/common/websocket";
 import { setRemoteHibernatableWebSocketAckTestHooks } from "@/common/websocket-test-hooks";
-import type { ActorGatewayQuery, CrashPolicy } from "@/client/query";
 import type { Encoding, UniversalWebSocket } from "@/mod";
-import type { JsonCompatValue } from "@/common/encoding";
 import { encodeCborCompat, uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath } from "@/utils";
-import { shouldSkipReadyWait, type GatewayRequestOptions } from "./driver";
+import { type GatewayRequestOptions, shouldSkipReadyWait } from "./driver";
 import { logger } from "./log";
 
 class BufferedRemoteWebSocket implements UniversalWebSocket {

package/src/engine-client/api-endpoints.ts

@@ -107,12 +107,59 @@ export async function getDatacenters(
 	return apiCall<never, DatacentersResponse>(config, "GET", `/datacenters`);
 }
 
+// MARK: Get runner configs
+export interface RunnerConfig {
+	normal?: {
+		drain_on_version_upgrade?: boolean;
+		actor_eviction_period?: number;
+		actor_eviction_rate?: number;
+	};
+	serverless?: {
+		url: string;
+		headers: Record<string, string>;
+		drain_grace_period?: number;
+		max_runners: number;
+		min_runners: number;
+		request_lifespan: number;
+		runners_margin: number;
+		slots_per_runner: number;
+		metadata_poll_interval?: number;
+		drain_on_version_upgrade?: boolean;
+		actor_eviction_period?: number;
+		actor_eviction_rate?: number;
+	};
+	protocol_version?: number;
+}
+
+export interface RunnerConfigDatacenters {
+	datacenters: Record<string, RunnerConfig>;
+}
+
+export interface RunnerConfigsResponse {
+	runner_configs: Record<string, RunnerConfigDatacenters>;
+}
+
+export async function getRunnerConfig(
+	config: ClientConfig,
+	name: string,
+): Promise<RunnerConfigsResponse> {
+	return apiCall<never, RunnerConfigsResponse>(
+		config,
+		"GET",
+		`/runner-configs?runner_name=${name}`,
+	);
+}
+
 // MARK: Update runner config
 export interface RegistryConfigRequest {
 	datacenters: Record<
 		string,
 		{
-			normal?: Record<string, unknown>;
+			normal?: {
+				drain_on_version_upgrade?: boolean;
+				actor_eviction_period?: number;
+				actor_eviction_rate?: number;
+			};
 			serverless?: {
 				url: string;
 				headers: Record<string, string>;
@@ -123,9 +170,11 @@ export interface RegistryConfigRequest {
 				runners_margin: number;
 				slots_per_runner: number;
 				metadata_poll_interval?: number;
+				drain_on_version_upgrade?: boolean;
+				actor_eviction_period?: number;
+				actor_eviction_rate?: number;
 			};
 			metadata?: Record<string, unknown>;
-			drain_on_version_upgrade?: boolean;
 		}
 	>;
 }

package/src/engine-client/api-utils.ts

@@ -1,10 +1,10 @@
 import { z } from "zod/v4";
+import { RivetError } from "@/actor/errors";
 import type { ClientConfig } from "@/client/config";
 import { sendHttpRequest } from "@/client/utils";
-import { RivetError } from "@/actor/errors";
+import type { RegistryConfig } from "@/registry/config";
 import { combineUrlPath } from "@/utils";
 import { logger } from "./log";
-import { RegistryConfig } from "@/registry/config";
 
 export { RivetError as EngineApiError };
 

package/src/engine-client/driver.ts

@@ -1,8 +1,8 @@
 import type { Hono, Context as HonoContext } from "hono";
 import type { ActorKey, Encoding, UniversalWebSocket } from "@/actor/mod";
+import type { ActorQuery, CrashPolicy } from "@/client/query";
 import type { RegistryConfig } from "@/registry/config";
 import type { GetUpgradeWebSocket } from "@/utils";
-import type { ActorQuery, CrashPolicy } from "@/client/query";
 
 export type GatewayTarget = { directId: string } | ActorQuery;
 

package/src/engine-client/mod.ts

@@ -7,9 +7,9 @@ import {
 	PATH_WEBSOCKET_BASE,
 	PATH_WEBSOCKET_PREFIX,
 } from "@/common/actor-router-consts";
+import type { JsonCompatValue } from "@/common/encoding";
 import { noopNext } from "@/common/utils";
 import type { Actor as ApiActor } from "@/engine-api/actors";
-import { shouldSkipReadyWait } from "@/engine-client/driver";
 import type {
 	ActorOutput,
 	CreateInput,
@@ -22,8 +22,8 @@ import type {
 	ListActorsInput,
 	RuntimeDisplayInformation,
 } from "@/engine-client/driver";
+import { shouldSkipReadyWait } from "@/engine-client/driver";
 import type { Encoding, UniversalWebSocket } from "@/mod";
-import type { JsonCompatValue } from "@/common/encoding";
 import { encodeCborCompat, uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath, type GetUpgradeWebSocket } from "@/utils";
 import { getNextPhase } from "@/utils/env-vars";
@@ -182,7 +182,9 @@ export class RemoteEngineControlClient implements EngineControlClient {
 			key: serializeActorKey(key),
 			runner_name_selector: this.#config.poolName,
 			input: actorInput
-				? uint8ArrayToBase64(encodeCborCompat(actorInput as JsonCompatValue))
+				? uint8ArrayToBase64(
+						encodeCborCompat(actorInput as JsonCompatValue),
+					)
 				: undefined,
 			crash_policy: crashPolicy ?? "sleep",
 		});

package/src/engine-client/ws-proxy.ts

@@ -9,7 +9,7 @@ import { logger } from "./log";
  * Returns Hono `upgradeWebSocket` args that will proxy requests from the client to a destination address.
  */
 export async function createWebSocketProxy(
-	c: HonoContext,
+	_c: HonoContext,
 	targetUrl: string,
 	protocols: string[],
 ): Promise<UpgradeWebSocketArgs> {
@@ -23,7 +23,7 @@ export async function createWebSocketProxy(
 	const state: WsState = {};
 
 	return {
-		onOpen: async (event: any, clientWs: WSContext) => {
+		onOpen: async (_event: any, clientWs: WSContext) => {
 			logger().debug({ msg: "client websocket connected", targetUrl });
 
 			if (clientWs.readyState !== 1) {
@@ -68,6 +68,11 @@ export async function createWebSocketProxy(
 					reject(error);
 				});
 			});
+			// Attach a no-op rejection handler so Node.js does not treat this as
+			// an unhandled rejection if onMessage never runs (e.g. the client
+			// disconnects before sending a message). The rejection still propagates
+			// to any caller that awaits connectPromise directly.
+			state.connectPromise.catch(() => {});
 
 			// Setup bidirectional forwarding
 			state.targetWs.addEventListener("message", (event) => {
@@ -137,7 +142,7 @@ export async function createWebSocketProxy(
 			}
 		},
 
-		onClose: (event: any, clientWs: WSContext) => {
+		onClose: (event: any, _clientWs: WSContext) => {
 			logger().debug({
 				msg: "client websocket closed",
 				targetUrl,
@@ -159,7 +164,7 @@ export async function createWebSocketProxy(
 			}
 		},
 
-		onError: (event: any, clientWs: WSContext) => {
+		onError: (event: any, _clientWs: WSContext) => {
 			logger().error({ msg: "client websocket error", targetUrl, event });
 
 			if (state.targetWs) {

package/src/inspector/client.browser.ts

@@ -198,7 +198,9 @@ const v3ToServerToV4 = (v3Data: v3.ToServer): v4.ToServer =>
 
 const v4ToServerToV3 = (v4Data: v4.ToServer): v3.ToServer => {
 	if (v4Data.body.tag === "WorkflowReplayRequest") {
-		throw new Error("Cannot convert v4-only workflow replay requests to v3");
+		throw new Error(
+			"Cannot convert v4-only workflow replay requests to v3",
+		);
 	}
 
 	return v4Data as unknown as v3.ToServer;
@@ -238,11 +240,7 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v4.ToServer>({
 		v2ToServerToV3,
 		v3ToServerToV4,
 	],
-	serializeConverters: () => [
-		v4ToServerToV3,
-		v3ToServerToV2,
-		v2ToServerToV1,
-	],
+	serializeConverters: () => [v4ToServerToV3, v3ToServerToV2, v2ToServerToV1],
 });
 
 export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v4.ToClient>({
@@ -279,9 +277,5 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v4.ToClient>({
 		v2ToClientToV3,
 		v3ToClientToV4,
 	],
-	serializeConverters: () => [
-		v4ToClientToV3,
-		v3ToClientToV2,
-		v2ToClientToV1,
-	],
+	serializeConverters: () => [v4ToClientToV3, v3ToClientToV2, v2ToClientToV1],
 });