rivetkit 2.0.26 → 2.0.28

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/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/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.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/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: () => [],
 });

package/src/schemas/client-protocol/versioned.ts

@@ -1,16 +1,11 @@
-import {
-	createVersionedDataHandler,
-	type MigrationFn,
-} from "@/common/versioned-data";
-import type * as v1 from "../../../dist/schemas/client-protocol/v1";
+import { createVersionedDataHandler } from "vbare";
+import * as v1 from "../../../dist/schemas/client-protocol/v1";
 import * as v2 from "../../../dist/schemas/client-protocol/v2";
 
 export const CURRENT_VERSION = 2;
 
-const migrations = new Map<number, MigrationFn<any, any>>();
-
-// Migration from v1 to v2: Remove connectionToken from Init message
-migrations.set(1, (v1Data: v1.ToClient): v2.ToClient => {
+// Converter from v1 to v2: Remove connectionToken from Init message
+const v1ToV2 = (v1Data: v1.ToClient): v2.ToClient => {
 	// Handle Init message specifically to remove connectionToken
 	if (v1Data.body.tag === "Init") {
 		const { actorId, connectionId } = v1Data.body.val as v1.Init;
@@ -26,58 +21,194 @@ migrations.set(1, (v1Data: v1.ToClient): v2.ToClient => {
 	}
 	// All other messages are unchanged
 	return v1Data as unknown as v2.ToClient;
-});
+};
+
+// Converter from v2 to v1: Add empty connectionToken to Init message
+const v2ToV1 = (v2Data: v2.ToClient): v1.ToClient => {
+	// Handle Init message specifically to add connectionToken
+	if (v2Data.body.tag === "Init") {
+		const { actorId, connectionId } = v2Data.body.val;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					actorId,
+					connectionId,
+					connectionToken: "", // Add empty connectionToken for v1 compatibility
+				},
+			},
+		};
+	}
+	// All other messages are unchanged
+	return v2Data as unknown as v1.ToClient;
+};
 
 export const TO_SERVER_VERSIONED = createVersionedDataHandler<v2.ToServer>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeToServer(data),
-	deserializeVersion: (bytes) => v2.decodeToServer(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToServer(bytes);
+			case 2:
+				return v2.decodeToServer(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeToServer(data as v1.ToServer);
+			case 2:
+				return v2.encodeToServer(data as v2.ToServer);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2],
+	serializeConverters: () => [v2ToV1],
 });
 
 export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v2.ToClient>({
-	currentVersion: CURRENT_VERSION,
-	migrations,
-	serializeVersion: (data) => v2.encodeToClient(data),
-	deserializeVersion: (bytes) => v2.decodeToClient(bytes),
+	deserializeVersion: (bytes, version) => {
+		switch (version) {
+			case 1:
+				return v1.decodeToClient(bytes);
+			case 2:
+				return v2.decodeToClient(bytes);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	serializeVersion: (data, version) => {
+		switch (version) {
+			case 1:
+				return v1.encodeToClient(data as v1.ToClient);
+			case 2:
+				return v2.encodeToClient(data as v2.ToClient);
+			default:
+				throw new Error(`Unknown version ${version}`);
+		}
+	},
+	deserializeConverters: () => [v1ToV2],
+	serializeConverters: () => [v2ToV1],
 });
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
 	createVersionedDataHandler<v2.HttpActionRequest>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpActionRequest(data),
-		deserializeVersion: (bytes) => v2.decodeHttpActionRequest(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionRequest(bytes);
+				case 2:
+					return v2.decodeHttpActionRequest(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpActionRequest(
+						data as v1.HttpActionRequest,
+					);
+				case 2:
+					return v2.encodeHttpActionRequest(
+						data as v2.HttpActionRequest,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_ACTION_RESPONSE_VERSIONED =
 	createVersionedDataHandler<v2.HttpActionResponse>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpActionResponse(data),
-		deserializeVersion: (bytes) => v2.decodeHttpActionResponse(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpActionResponse(bytes);
+				case 2:
+					return v2.decodeHttpActionResponse(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpActionResponse(
+						data as v1.HttpActionResponse,
+					);
+				case 2:
+					return v2.encodeHttpActionResponse(
+						data as v2.HttpActionResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_RESPONSE_ERROR_VERSIONED =
 	createVersionedDataHandler<v2.HttpResponseError>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpResponseError(data),
-		deserializeVersion: (bytes) => v2.decodeHttpResponseError(bytes),
-	});
-
-export const HTTP_RESOLVE_REQUEST_VERSIONED =
-	createVersionedDataHandler<v2.HttpResolveRequest>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (_) => new Uint8Array(),
-		deserializeVersion: (bytes) => null,
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResponseError(bytes);
+				case 2:
+					return v2.decodeHttpResponseError(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpResponseError(
+						data as v1.HttpResponseError,
+					);
+				case 2:
+					return v2.encodeHttpResponseError(
+						data as v2.HttpResponseError,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});
 
 export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 	createVersionedDataHandler<v2.HttpResolveResponse>({
-		currentVersion: CURRENT_VERSION,
-		migrations,
-		serializeVersion: (data) => v2.encodeHttpResolveResponse(data),
-		deserializeVersion: (bytes) => v2.decodeHttpResolveResponse(bytes),
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeHttpResolveResponse(bytes);
+				case 2:
+					return v2.decodeHttpResolveResponse(bytes);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 1:
+					return v1.encodeHttpResolveResponse(
+						data as v1.HttpResolveResponse,
+					);
+				case 2:
+					return v2.encodeHttpResolveResponse(
+						data as v2.HttpResolveResponse,
+					);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
 	});

package/src/schemas/file-system-driver/mod.ts

@@ -1 +1 @@
-export * from "../../../dist/schemas/file-system-driver/v2";
+export * from "../../../dist/schemas/file-system-driver/v3";