rivetkit 2.0.27 → 2.0.28

package/src/actor/protocol/serde.ts

@@ -1,7 +1,7 @@
 import * as cbor from "cbor-x";
 import { z } from "zod";
 import * as errors from "@/actor/errors";
-import type { VersionedDataHandler } from "@/common/versioned-data";
+import type { VersionedDataHandler } from "vbare";
 import { serializeWithEncoding } from "@/serde";
 import { loggerWithoutContext } from "../log";
 import { assertUnreachable } from "../utils";
@@ -26,6 +26,7 @@ export class CachedSerializer<TBare, TJson, T = TBare> {
 	#data: T;
 	#cache = new Map<Encoding, OutputData>();
 	#versionedDataHandler: VersionedDataHandler<TBare>;
+	#version: number;
 	#zodSchema: z.ZodType<TJson>;
 	#toJson: (value: T) => TJson;
 	#toBare: (value: T) => TBare;
@@ -33,12 +34,14 @@ export class CachedSerializer<TBare, TJson, T = TBare> {
 	constructor(
 		data: T,
 		versionedDataHandler: VersionedDataHandler<TBare>,
+		version: number,
 		zodSchema: z.ZodType<TJson>,
 		toJson: (value: T) => TJson,
 		toBare: (value: T) => TBare,
 	) {
 		this.#data = data;
 		this.#versionedDataHandler = versionedDataHandler;
+		this.#version = version;
 		this.#zodSchema = zodSchema;
 		this.#toJson = toJson;
 		this.#toBare = toBare;
@@ -57,6 +60,7 @@ export class CachedSerializer<TBare, TJson, T = TBare> {
 				encoding,
 				this.#data,
 				this.#versionedDataHandler,
+				this.#version,
 				this.#zodSchema,
 				this.#toJson,
 				this.#toBare,

package/src/actor/router-endpoints.ts

@@ -16,6 +16,7 @@ import { stringifyError } from "@/common/utils";
 import type { RunnerConfig } from "@/registry/run-config";
 import type * as protocol from "@/schemas/client-protocol/mod";
 import {
+	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
 	HTTP_ACTION_REQUEST_VERSIONED,
 	HTTP_ACTION_RESPONSE_VERSIONED,
 } from "@/schemas/client-protocol/versioned";
@@ -120,6 +121,7 @@ export async function handleAction(
 		encoding,
 		output,
 		HTTP_ACTION_RESPONSE_VERSIONED,
+		CLIENT_PROTOCOL_CURRENT_VERSION,
 		HttpActionResponseSchema,
 		// JSON: output is the raw value (will be serialized by jsonStringifyCompat)
 		(value): HttpActionResponseJson => ({ output: value }),

package/src/client/actor-conn.ts

@@ -22,6 +22,7 @@ import type { ManagerDriver } from "@/driver-helpers/mod";
 import type { ActorQuery } from "@/manager/protocol/query";
 import type * as protocol from "@/schemas/client-protocol/mod";
 import {
+	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
 	TO_CLIENT_VERSIONED,
 	TO_SERVER_VERSIONED,
 } from "@/schemas/client-protocol/versioned";
@@ -749,6 +750,7 @@ enc
 						this.#encoding,
 						message,
 						TO_SERVER_VERSIONED,
+					CLIENT_PROTOCOL_CURRENT_VERSION,
 						ToServerSchema,
 						// JSON: args is the raw value
 						(msg): ToServerJson => msg as ToServerJson,

package/src/client/actor-handle.ts

@@ -12,6 +12,7 @@ import {
 import type { ActorQuery } from "@/manager/protocol/query";
 import type * as protocol from "@/schemas/client-protocol/mod";
 import {
+	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
 	HTTP_ACTION_REQUEST_VERSIONED,
 	HTTP_ACTION_RESPONSE_VERSIONED,
 } from "@/schemas/client-protocol/versioned";
@@ -128,7 +129,9 @@ export class ActorHandleRaw {
 					actorId,
 				),
 				signal: opts?.signal,
+				requestVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
 				requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
+				responseVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
 				responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,
 				requestZodSchema: HttpActionRequestSchema,
 				responseZodSchema: HttpActionResponseSchema,

package/src/client/config.ts

@@ -32,7 +32,7 @@ export const ClientConfigSchema = z.object({
 
 	encoding: EncodingSchema.default("bare"),
 
-	headers: z.record(z.string()).optional().default({}),
+	headers: z.record(z.string(), z.string()).optional().default(() => ({})),
 
 	// See RunConfig.getUpgradeWebSocket
 	getUpgradeWebSocket: z.custom<GetUpgradeWebSocket>().optional(),

package/src/client/utils.ts

@@ -3,7 +3,7 @@ import invariant from "invariant";
 import type { z } from "zod";
 import type { Encoding } from "@/actor/protocol/serde";
 import { assertUnreachable } from "@/common/utils";
-import type { VersionedDataHandler } from "@/common/versioned-data";
+import type { VersionedDataHandler } from "vbare";
 import type { HttpResponseError } from "@/schemas/client-protocol/mod";
 import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/schemas/client-protocol/versioned";
 import {
@@ -55,9 +55,11 @@ export interface HttpRequestOpts<
 	signal?: AbortSignal;
 	customFetch?: (req: globalThis.Request) => Promise<globalThis.Response>;
 	requestVersionedDataHandler: VersionedDataHandler<RequestBare> | undefined;
+	requestVersion: number | undefined;
 	responseVersionedDataHandler:
 		| VersionedDataHandler<ResponseBare>
 		| undefined;
+	responseVersion: number | undefined;
 	requestZodSchema: z.ZodType<RequestJson>;
 	responseZodSchema: z.ZodType<ResponseJson>;
 	requestToJson: (value: Request) => RequestJson;
@@ -99,6 +101,7 @@ export async function sendHttpRequest<
 			opts.encoding,
 			opts.body,
 			opts.requestVersionedDataHandler,
+			opts.requestVersion,
 			opts.requestZodSchema,
 			opts.requestToJson,
 			opts.requestToBare,

package/src/common/router.ts

@@ -8,7 +8,10 @@ import {
 import { buildActorNames, type RegistryConfig } from "@/registry/config";
 import type { RunnerConfig } from "@/registry/run-config";
 import type * as protocol from "@/schemas/client-protocol/mod";
-import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/schemas/client-protocol/versioned";
+import {
+	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
+	HTTP_RESPONSE_ERROR_VERSIONED,
+} from "@/schemas/client-protocol/versioned";
 import {
 	type HttpResponseError as HttpResponseErrorJson,
 	HttpResponseErrorSchema,
@@ -76,6 +79,7 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 		encoding,
 		errorData,
 		HTTP_RESPONSE_ERROR_VERSIONED,
+		CLIENT_PROTOCOL_CURRENT_VERSION,
 		HttpResponseErrorSchema,
 		// JSON: metadata is the raw value (will be serialized by jsonStringifyCompat)
 		(value): HttpResponseErrorJson => ({

package/src/driver-helpers/utils.ts

@@ -1,7 +1,10 @@
 import * as cbor from "cbor-x";
 import { KEYS } from "@/actor/instance/kv";
 import type * as persistSchema from "@/schemas/actor-persist/mod";
-import { ACTOR_VERSIONED } from "@/schemas/actor-persist/versioned";
+import {
+	ACTOR_VERSIONED,
+	CURRENT_VERSION,
+} from "@/schemas/actor-persist/versioned";
 import { bufferToArrayBuffer } from "@/utils";
 import type { ActorDriver } from "./mod";
 
@@ -15,7 +18,10 @@ function serializeEmptyPersistData(input: unknown | undefined): Uint8Array {
 		state: bufferToArrayBuffer(cbor.encode(undefined)),
 		scheduledEvents: [],
 	};
-	return ACTOR_VERSIONED.serializeWithEmbeddedVersion(persistData);
+	return ACTOR_VERSIONED.serializeWithEmbeddedVersion(
+		persistData,
+		CURRENT_VERSION,
+	);
 }
 
 /**

package/src/drivers/engine/config.ts

@@ -2,7 +2,7 @@ import { z } from "zod";
 import { ClientConfigSchema } from "@/client/config";
 import { getEnvUniversal } from "@/utils";
 
-export const EngingConfigSchema = z
+const EngineConfigSchemaBase = z
 	.object({
 		/** Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
 		runnerKey: z
@@ -14,8 +14,11 @@ export const EngingConfigSchema = z
 		totalSlots: z.number().default(100_000),
 	})
 	// We include the client config since this includes the common properties like endpoint, namespace, etc.
-	.merge(ClientConfigSchema)
-	.default({});
+	.merge(ClientConfigSchema);
+
+export const EngingConfigSchema = EngineConfigSchemaBase.default(() =>
+	EngineConfigSchemaBase.parse({}),
+);
 
 export type EngineConfig = z.infer<typeof EngingConfigSchema>;
 export type EngineConfigInput = z.input<typeof EngingConfigSchema>;

package/src/drivers/file-system/global-state.ts

@@ -12,6 +12,7 @@ import type * as schema from "@/schemas/file-system-driver/mod";
 import {
 	ACTOR_ALARM_VERSIONED,
 	ACTOR_STATE_VERSIONED,
+	CURRENT_VERSION as FILE_SYSTEM_DRIVER_CURRENT_VERSION,
 } from "@/schemas/file-system-driver/versioned";
 import {
 	arrayBuffersEqual,
@@ -263,6 +264,10 @@ export class FileSystemGlobalState {
 			key,
 			createdAt: BigInt(Date.now()),
 			kvStorage,
+			startTs: null,
+			connectableTs: null,
+			sleepTs: null,
+			destroyTs: null,
 		};
 		entry.lifecycleState = ActorLifecycleState.AWAKE;
 
@@ -369,6 +374,10 @@ export class FileSystemGlobalState {
 				key: key as readonly string[],
 				createdAt: BigInt(Date.now()),
 				kvStorage,
+				startTs: null,
+				connectableTs: null,
+				sleepTs: null,
+				destroyTs: null,
 			};
 			await this.writeActor(actorId, entry.generation, entry.state);
 		}
@@ -396,6 +405,15 @@ export class FileSystemGlobalState {
 		if (actor.startPromise?.promise)
 			await actor.startPromise.promise.catch();
 
+		// Update state with sleep timestamp
+		if (actor.state) {
+			actor.state = {
+				...actor.state,
+				sleepTs: BigInt(Date.now()),
+			};
+			await this.writeActor(actorId, actor.generation, actor.state);
+		}
+
 		// Stop actor
 		invariant(actor.actor, "actor should be loaded");
 		await actor.actor.onStop("sleep");
@@ -420,6 +438,15 @@ export class FileSystemGlobalState {
 		if (actor.startPromise?.promise)
 			await actor.startPromise.promise.catch();
 
+		// Update state with destroy timestamp
+		if (actor.state) {
+			actor.state = {
+				...actor.state,
+				destroyTs: BigInt(Date.now()),
+			};
+			await this.writeActor(actorId, actor.generation, actor.state);
+		}
+
 		// Stop actor if it's running
 		if (actor.actor) {
 			await actor.actor.onStop("destroy");
@@ -561,6 +588,7 @@ export class FileSystemGlobalState {
 				const data =
 					ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
 						alarmData,
+						FILE_SYSTEM_DRIVER_CURRENT_VERSION,
 					);
 				const fs = getNodeFs();
 				await fs.writeFile(tempPath, data);
@@ -621,11 +649,18 @@ export class FileSystemGlobalState {
 				key: state.key,
 				createdAt: state.createdAt,
 				kvStorage: state.kvStorage,
+				startTs: state.startTs,
+				connectableTs: state.connectableTs,
+				sleepTs: state.sleepTs,
+				destroyTs: state.destroyTs,
 			};
 
 			// Perform atomic write
 			const serializedState =
-				ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);
+				ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(
+					bareState,
+					FILE_SYSTEM_DRIVER_CURRENT_VERSION,
+				);
 			const fs = getNodeFs();
 			await fs.writeFile(tempPath, serializedState);
 
@@ -738,6 +773,16 @@ export class FileSystemGlobalState {
 				"unknown",
 			);
 
+			// Update state with start timestamp
+			// NOTE: connectableTs is always in sync with startTs since actors become connectable immediately after starting
+			const now = BigInt(Date.now());
+			entry.state = {
+				...entry.state,
+				startTs: now,
+				connectableTs: now,
+			};
+			await this.writeActor(actorId, entry.generation, entry.state);
+
 			// Finish
 			entry.startPromise.resolve();
 			entry.startPromise = undefined;

package/src/drivers/file-system/manager.ts

@@ -315,6 +315,10 @@ export class FileSystemManagerDriver implements ManagerDriver {
 					name: actor.name,
 					key: actor.key as string[],
 					createTs: Number(actor.createdAt),
+					startTs: actor.startTs !== null ? Number(actor.startTs) : null,
+					connectableTs: actor.connectableTs !== null ? Number(actor.connectableTs) : null,
+					sleepTs: actor.sleepTs !== null ? Number(actor.sleepTs) : null,
+					destroyTs: actor.destroyTs !== null ? Number(actor.destroyTs) : null,
 				});
 			}
 		}

package/src/inspector/config.ts

@@ -35,8 +35,7 @@ export const InspectorConfigSchema = z
 		 * Token used to access the Inspector.
 		 */
 		token: z
-			.function()
-			.returns(z.string())
+			.custom<() => string>()
 			.optional()
 			.default(() => defaultTokenFn),
 

package/src/manager/driver.ts

@@ -105,4 +105,8 @@ export interface ActorOutput {
 	name: string;
 	key: ActorKey;
 	createTs?: number;
+	startTs?: number | null;
+	connectableTs?: number | null;
+	sleepTs?: number | null;
+	destroyTs?: number | null;
 }

package/src/manager/router-schema.ts

@@ -2,21 +2,21 @@ import { z } from "zod";
 
 export const ServerlessStartHeadersSchema = z.object({
 	endpoint: z.string({
-		required_error: "x-rivet-endpoint header is required",
+		error: "x-rivet-endpoint header is required",
 	}),
 	token: z
-		.string({ invalid_type_error: "x-rivet-token header must be a string" })
+		.string({ error: "x-rivet-token header must be a string" })
 		.optional(),
 	totalSlots: z.coerce
 		.number({
-			invalid_type_error: "x-rivet-total-slots header must be a number",
+			error: "x-rivet-total-slots header must be a number",
 		})
-		.int("x-rivet-total-slots header must be an integer")
-		.gte(1, "x-rivet-total-slots header must be positive"),
+		.int({ error: "x-rivet-total-slots header must be an integer" })
+		.gte(1, { error: "x-rivet-total-slots header must be positive" }),
 	runnerName: z.string({
-		required_error: "x-rivet-runner-name header is required",
+		error: "x-rivet-runner-name header is required",
 	}),
 	namespace: z.string({
-		required_error: "x-rivet-namespace-name header is required",
+		error: "x-rivet-namespace-name header is required",
 	}),
 });

package/src/manager/router.ts

@@ -731,9 +731,9 @@ function createApiActor(
 		namespace_id: "default", // Assert default namespace
 		runner_name_selector: runnerName,
 		create_ts: actor.createTs ?? Date.now(),
-		connectable_ts: null,
-		destroy_ts: null,
-		sleep_ts: null,
-		start_ts: null,
+		connectable_ts: actor.connectableTs ?? null,
+		destroy_ts: actor.destroyTs ?? null,
+		sleep_ts: actor.sleepTs ?? null,
+		start_ts: actor.startTs ?? null,
 	};
 }

package/src/registry/run-config.ts

@@ -18,7 +18,7 @@ export const DriverConfigSchema = z.object({
 export type DriverConfig = z.infer<typeof DriverConfigSchema>;
 
 /** Base config used for the actor config across all platforms. */
-export const RunnerConfigSchema = z
+const RunnerConfigSchemaUnmerged = z
 	.object({
 		driver: DriverConfigSchema.optional(),
 
@@ -95,7 +95,7 @@ export const RunnerConfigSchema = z
 				level: LogLevelSchema.optional(),
 			})
 			.optional()
-			.default({}),
+			.default(() => ({})),
 
 		/**
 		 * @experimental
@@ -115,7 +115,7 @@ export const RunnerConfigSchema = z
 					requestLifespan: z.number().optional(),
 					runnersMargin: z.number().optional(),
 					slotsPerRunner: z.number().optional(),
-					metadata: z.record(z.unknown()).optional(),
+					metadata: z.record(z.string(), z.unknown()).optional(),
 				}),
 			])
 			.optional(),
@@ -126,8 +126,12 @@ export const RunnerConfigSchema = z
 		// created or must be imported async using `await import(...)`
 		getUpgradeWebSocket: z.custom<GetUpgradeWebSocket>().optional(),
 	})
-	.merge(EngineConfigSchema.removeDefault())
-	.default({});
+	.merge(EngineConfigSchema.removeDefault());
+
+const RunnerConfigSchemaBase = RunnerConfigSchemaUnmerged;
+export const RunnerConfigSchema = RunnerConfigSchemaBase.default(() =>
+	RunnerConfigSchemaBase.parse({}),
+);
 
 export type RunnerConfig = z.infer<typeof RunnerConfigSchema>;
 export type RunnerConfigInput = z.input<typeof RunnerConfigSchema>;

package/src/remote-manager-driver/actor-http-client.ts

@@ -72,7 +72,7 @@ function buildGuardHeadersForHttp(
 	}
 	// Add extra headers from config
 	for (const [key, value] of Object.entries(runConfig.headers)) {
-		headers.set(key, value);
+		headers.set(key, value as string);
 	}
 	// Add guard-specific headers
 	if (runConfig.token) {

package/src/remote-manager-driver/api-utils.ts

@@ -51,7 +51,9 @@ export async function apiCall<TInput = unknown, TOutput = unknown>(
 		encoding: "json",
 		skipParseResponse: false,
 		requestVersionedDataHandler: undefined,
+		requestVersion: undefined,
 		responseVersionedDataHandler: undefined,
+		responseVersion: undefined,
 		requestZodSchema: z.any() as z.ZodType<TInput>,
 		responseZodSchema: z.any() as z.ZodType<TOutput>,
 		// Identity conversions (passthrough for generic API calls)

package/src/schemas/actor-persist/versioned.ts

@@ -1,66 +1,138 @@
-import {
-	createVersionedDataHandler,
-	type MigrationFn,
-} from "@/common/versioned-data";
-import type * as v1 from "../../../dist/schemas/actor-persist/v1";
-import type * as v2 from "../../../dist/schemas/actor-persist/v2";
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/actor-persist/v1";
+import * as v2 from "../../../dist/schemas/actor-persist/v2";
 import * as v3 from "../../../dist/schemas/actor-persist/v3";
 
 export const CURRENT_VERSION = 3;
 
-const migrations = new Map<number, MigrationFn<any, any>>([
-	[
-		1,
-		(v1Data: v1.PersistedActor): v2.PersistedActor => ({
-			...v1Data,
-			connections: v1Data.connections.map((conn) => ({
-				...conn,
-				hibernatableRequestId: null,
-			})),
-			hibernatableWebSockets: [],
-		}),
-	],
-	[
-		2,
-		(v2Data: v2.PersistedActor): v3.Actor => {
-			// Transform scheduled events from nested structure to flat structure
-			const scheduledEvents: v3.ScheduleEvent[] =
-				v2Data.scheduledEvents.map((event) => {
-					// Extract action and args from the kind wrapper
-					if (event.kind.tag === "GenericPersistedScheduleEvent") {
-						return {
-							eventId: event.eventId,
-							timestamp: event.timestamp,
-							action: event.kind.val.action,
-							args: event.kind.val.args,
-						};
-					}
-					// Fallback for unknown kinds
-					throw new Error(
-						`Unknown schedule event kind: ${event.kind.tag}`,
-					);
-				});
+// Converter from v1 to v2
+const v1ToV2 = (v1Data: v1.PersistedActor): v2.PersistedActor => ({
+	...v1Data,
+	connections: v1Data.connections.map((conn) => ({
+		...conn,
+		hibernatableRequestId: null,
+	})),
+	hibernatableWebSockets: [],
+});
 
-			return {
-				input: v2Data.input,
-				hasInitialized: v2Data.hasInitialized,
-				state: v2Data.state,
-				scheduledEvents,
-			};
+// Converter from v2 to v3
+const v2ToV3 = (v2Data: v2.PersistedActor): v3.Actor => {
+	// Transform scheduled events from nested structure to flat structure
+	const scheduledEvents: v3.ScheduleEvent[] = v2Data.scheduledEvents.map(
+		(event) => {
+			// Extract action and args from the kind wrapper
+			if (event.kind.tag === "GenericPersistedScheduleEvent") {
+				return {
+					eventId: event.eventId,
+					timestamp: event.timestamp,
+					action: event.kind.val.action,
+					args: event.kind.val.args,
+				};
+			}
+			// Fallback for unknown kinds
+			throw new Error(`Unknown schedule event kind: ${event.kind.tag}`);
 		},
-	],
-]);
+	);
+
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents,
+	};
+};
+
+// Converter from v3 to v2
+const v3ToV2 = (v3Data: v3.Actor): v2.PersistedActor => {
+	// Transform scheduled events from flat structure back to nested structure
+	const scheduledEvents: v2.PersistedScheduleEvent[] = v3Data.scheduledEvents.map(
+		(event) => ({
+			eventId: event.eventId,
+			timestamp: event.timestamp,
+			kind: {
+				tag: "GenericPersistedScheduleEvent" as const,
+				val: {
+					action: event.action,
+					args: event.args,
+				},
+			},
+		}),
+	);
+
+	return {
+		input: v3Data.input,
+		hasInitialized: v3Data.hasInitialized,
+		state: v3Data.state,
+		scheduledEvents,
+		connections: [],
+		hibernatableWebSockets: [],
+	};
+};
+
+// Converter from v2 to v1
+const v2ToV1 = (v2Data: v2.PersistedActor): v1.PersistedActor => {
+	return {
+		input: v2Data.input,
+		hasInitialized: v2Data.hasInitialized,
+		state: v2Data.state,
+		scheduledEvents: v2Data.scheduledEvents,
+		connections: v2Data.connections.map((conn) => {
+			const { hibernatableRequestId, ...rest } = conn;
+			return rest;
+		}),
+	};
+};
 
 export const ACTOR_VERSIONED = createVersionedDataHandler<v3.Actor>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v3.encodeActor(data),
-	deserializeVersion: (bytes) => v3.decodeActor(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodePersistedActor(bytes);
+			case 2:
+				return v2.decodePersistedActor(bytes);
+			case 3:
+				return v3.decodeActor(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodePersistedActor(data as v1.PersistedActor);
+			case 2:
+				return v2.encodePersistedActor(data as v2.PersistedActor);
+			case 3:
+				return v3.encodeActor(data as v3.Actor);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2, v2ToV3],
+	serializeConverters: () => [v3ToV2, v2ToV1],
 });
 
 export const CONN_VERSIONED = createVersionedDataHandler<v3.Conn>({
-	currentVersion: CURRENT_VERSION,
-	migrations: new Map(),
-	serializeVersion: (data) => v3.encodeConn(data),
-	deserializeVersion: (bytes) => v3.decodeConn(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 3:
+				return v3.decodeConn(bytes);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 3:
+				return v3.encodeConn(data as v3.Conn);
+			default:
+				throw new Error(
+					`Conn type only exists in version 3+, got version ${version}`,
+				);
+		}
+	},
+	deserializeConverters: () => [],
+	serializeConverters: () => [],
 });