rivetkit 2.0.42 → 2.1.0-rc.1

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

@@ -1,13 +1,188 @@
 import { createVersionedDataHandler } from "vbare";
 
 import * as v1 from "../../../dist/schemas/actor-inspector/v1";
+import * as v2 from "../../../dist/schemas/actor-inspector/v2";
+import * as v3 from "../../../dist/schemas/actor-inspector/v3";
 
+export const CURRENT_VERSION = 3;
 
-export const TO_SERVER_VERSIONED = createVersionedDataHandler<v1.ToServer>({
+const EVENTS_DROPPED_ERROR = "inspector.events_dropped";
+const WORKFLOW_HISTORY_DROPPED_ERROR = "inspector.workflow_history_dropped";
+const QUEUE_DROPPED_ERROR = "inspector.queue_dropped";
+const TRACE_DROPPED_ERROR = "inspector.trace_dropped";
+const DATABASE_DROPPED_ERROR = "inspector.database_dropped";
+
+// Converter from v1 to v2: Drop events in Init and add new fields
+const v1ToClientToV2 = (v1Data: v1.ToClient): v2.ToClient => {
+	if (v1Data.body.tag === "Init") {
+		const init = v1Data.body.val as v1.Init;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					connections: init.connections,
+					state: init.state,
+					isStateEnabled: init.isStateEnabled,
+					rpcs: init.rpcs,
+					isDatabaseEnabled: init.isDatabaseEnabled,
+					queueSize: 0n,
+					workflowHistory: null,
+					isWorkflowEnabled: false,
+				},
+			},
+		};
+	}
+	if (
+		v1Data.body.tag === "EventsUpdated" ||
+		v1Data.body.tag === "EventsResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: EVENTS_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v1Data as unknown as v2.ToClient;
+};
+
+// Converter from v2 to v1: Add empty events to Init, drop newer updates
+const v2ToClientToV1 = (v2Data: v2.ToClient): v1.ToClient => {
+	if (v2Data.body.tag === "Init") {
+		const init = v2Data.body.val;
+		return {
+			body: {
+				tag: "Init",
+				val: {
+					connections: init.connections,
+					events: [],
+					state: init.state,
+					isStateEnabled: init.isStateEnabled,
+					rpcs: init.rpcs,
+					isDatabaseEnabled: init.isDatabaseEnabled,
+				},
+			},
+		};
+	}
+	if (
+		v2Data.body.tag === "WorkflowHistoryUpdated" ||
+		v2Data.body.tag === "WorkflowHistoryResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: WORKFLOW_HISTORY_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "QueueUpdated") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: QUEUE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "QueueResponse") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: QUEUE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	if (v2Data.body.tag === "TraceQueryResponse") {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: TRACE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v2Data as unknown as v1.ToClient;
+};
+
+// Converter from v2 to v3: v2 messages are a subset of v3
+const v2ToClientToV3 = (v2Data: v2.ToClient): v3.ToClient => {
+	return v2Data as unknown as v3.ToClient;
+};
+
+// Converter from v3 to v2: Drop database responses
+const v3ToClientToV2 = (v3Data: v3.ToClient): v2.ToClient => {
+	if (
+		v3Data.body.tag === "DatabaseSchemaResponse" ||
+		v3Data.body.tag === "DatabaseTableRowsResponse"
+	) {
+		return {
+			body: {
+				tag: "Error",
+				val: {
+					message: DATABASE_DROPPED_ERROR,
+				},
+			},
+		};
+	}
+	return v3Data as unknown as v2.ToClient;
+};
+
+// Converter from v1 to v2: Drop events requests
+const v1ToServerToV2 = (v1Data: v1.ToServer): v2.ToServer => {
+	if (
+		v1Data.body.tag === "EventsRequest" ||
+		v1Data.body.tag === "ClearEventsRequest"
+	) {
+		throw new Error("Cannot convert events requests to v2");
+	}
+	return v1Data as unknown as v2.ToServer;
+};
+
+// Converter from v2 to v1: Drop newer requests
+const v2ToServerToV1 = (v2Data: v2.ToServer): v1.ToServer => {
+	if (
+		v2Data.body.tag === "TraceQueryRequest" ||
+		v2Data.body.tag === "QueueRequest" ||
+		v2Data.body.tag === "WorkflowHistoryRequest"
+	) {
+		throw new Error("Cannot convert v2-only requests to v1");
+	}
+	return v2Data as unknown as v1.ToServer;
+};
+
+// Converter from v2 to v3: v2 messages are a subset of v3
+const v2ToServerToV3 = (v2Data: v2.ToServer): v3.ToServer => {
+	return v2Data as unknown as v3.ToServer;
+};
+
+// Converter from v3 to v2: Drop database requests
+const v3ToServerToV2 = (v3Data: v3.ToServer): v2.ToServer => {
+	if (
+		v3Data.body.tag === "DatabaseSchemaRequest" ||
+		v3Data.body.tag === "DatabaseTableRowsRequest"
+	) {
+		throw new Error("Cannot convert v3-only database requests to v2");
+	}
+	return v3Data as unknown as v2.ToServer;
+};
+
+export const TO_SERVER_VERSIONED = createVersionedDataHandler<v3.ToServer>({
 	serializeVersion: (data, version) => {
 		switch (version) {
 			case 1:
-				return v1.encodeToServer(data);
+				return v1.encodeToServer(data as v1.ToServer);
+			case 2:
+				return v2.encodeToServer(data as v2.ToServer);
+			case 3:
+				return v3.encodeToServer(data as v3.ToServer);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -16,19 +191,27 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v1.ToServer>({
 		switch (version) {
 			case 1:
 				return v1.decodeToServer(bytes);
+			case 2:
+				return v2.decodeToServer(bytes);
+			case 3:
+				return v3.decodeToServer(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [],
-	serializeConverters: () => [],
+	deserializeConverters: () => [v1ToServerToV2, v2ToServerToV3],
+	serializeConverters: () => [v3ToServerToV2, v2ToServerToV1],
 });
 
-export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v1.ToClient>({
+export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v3.ToClient>({
 	serializeVersion: (data, version) => {
 		switch (version) {
 			case 1:
-				return v1.encodeToClient(data);
+				return v1.encodeToClient(data as v1.ToClient);
+			case 2:
+				return v2.encodeToClient(data as v2.ToClient);
+			case 3:
+				return v3.encodeToClient(data as v3.ToClient);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -37,10 +220,14 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v1.ToClient>({
 		switch (version) {
 			case 1:
 				return v1.decodeToClient(bytes);
+			case 2:
+				return v2.decodeToClient(bytes);
+			case 3:
+				return v3.decodeToClient(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [],
-	serializeConverters: () => [],
+	deserializeConverters: () => [v1ToClientToV2, v2ToClientToV3],
+	serializeConverters: () => [v3ToClientToV2, v2ToClientToV1],
 });

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

@@ -2,8 +2,9 @@ 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";
+import * as v4 from "../../../dist/schemas/actor-persist/v4";
 
-export const CURRENT_VERSION = 3;
+export const CURRENT_VERSION = 4;
 
 // Converter from v1 to v2
 const v1ToV2 = (v1Data: v1.PersistedActor): v2.PersistedActor => ({
@@ -42,6 +43,16 @@ const v2ToV3 = (v2Data: v2.PersistedActor): v3.Actor => {
 	};
 };
 
+// Converter from v3 to v4: No changes to Actor structure
+const v3ToV4 = (v3Data: v3.Actor): v4.Actor => {
+	return v3Data as unknown as v4.Actor;
+};
+
+// Converter from v4 to v3: No changes to Actor structure
+const v4ToV3 = (v4Data: v4.Actor): v3.Actor => {
+	return v4Data as unknown as v3.Actor;
+};
+
 // Converter from v3 to v2
 const v3ToV2 = (v3Data: v3.Actor): v2.PersistedActor => {
 	// Transform scheduled events from flat structure back to nested structure
@@ -82,7 +93,7 @@ const v2ToV1 = (v2Data: v2.PersistedActor): v1.PersistedActor => {
 	};
 };
 
-export const ACTOR_VERSIONED = createVersionedDataHandler<v3.Actor>({
+export const ACTOR_VERSIONED = createVersionedDataHandler<v4.Actor>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
@@ -91,6 +102,8 @@ export const ACTOR_VERSIONED = createVersionedDataHandler<v3.Actor>({
 				return v2.decodePersistedActor(bytes);
 			case 3:
 				return v3.decodeActor(bytes);
+			case 4:
+				return v4.decodeActor(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -103,19 +116,32 @@ export const ACTOR_VERSIONED = createVersionedDataHandler<v3.Actor>({
 				return v2.encodePersistedActor(data as v2.PersistedActor);
 			case 3:
 				return v3.encodeActor(data as v3.Actor);
+			case 4:
+				return v4.encodeActor(data as v4.Actor);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToV2, v2ToV3],
-	serializeConverters: () => [v3ToV2, v2ToV1],
+	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
 });
 
-export const CONN_VERSIONED = createVersionedDataHandler<v3.Conn>({
+// Conn identity converters (Conn is identical between v3 and v4)
+const v3ConnToV4 = (v3Data: v3.Conn): v4.Conn => {
+	return v3Data as unknown as v4.Conn;
+};
+
+const v4ConnToV3 = (v4Data: v4.Conn): v3.Conn => {
+	return v4Data as unknown as v3.Conn;
+};
+
+export const CONN_VERSIONED = createVersionedDataHandler<v4.Conn>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 3:
 				return v3.decodeConn(bytes);
+			case 4:
+				return v4.decodeConn(bytes);
 			default:
 				throw new Error(
 					`Conn type only exists in version 3+, got version ${version}`,
@@ -126,12 +152,66 @@ export const CONN_VERSIONED = createVersionedDataHandler<v3.Conn>({
 		switch (version) {
 			case 3:
 				return v3.encodeConn(data as v3.Conn);
+			case 4:
+				return v4.encodeConn(data as v4.Conn);
 			default:
 				throw new Error(
 					`Conn type only exists in version 3+, got version ${version}`,
 				);
 		}
 	},
-	deserializeConverters: () => [],
-	serializeConverters: () => [],
+	deserializeConverters: () => [v3ConnToV4],
+	serializeConverters: () => [v4ConnToV3],
 });
+
+export const QUEUE_METADATA_VERSIONED =
+	createVersionedDataHandler<v4.QueueMetadata>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 4:
+					return v4.decodeQueueMetadata(bytes);
+				default:
+					throw new Error(
+						`QueueMetadata type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 4:
+					return v4.encodeQueueMetadata(data as v4.QueueMetadata);
+				default:
+					throw new Error(
+						`QueueMetadata type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const QUEUE_MESSAGE_VERSIONED =
+	createVersionedDataHandler<v4.QueueMessage>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 4:
+					return v4.decodeQueueMessage(bytes);
+				default:
+					throw new Error(
+						`QueueMessage type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 4:
+					return v4.encodeQueueMessage(data as v4.QueueMessage);
+				default:
+					throw new Error(
+						`QueueMessage type only exists in version 4+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});

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

@@ -1 +1 @@
-export * from "../../../dist/schemas/client-protocol/v2";
+export * from "../../../dist/schemas/client-protocol/v3";

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

@@ -1,8 +1,9 @@
 import { createVersionedDataHandler } from "vbare";
 import * as v1 from "../../../dist/schemas/client-protocol/v1";
 import * as v2 from "../../../dist/schemas/client-protocol/v2";
+import * as v3 from "../../../dist/schemas/client-protocol/v3";
 
-export const CURRENT_VERSION = 2;
+export const CURRENT_VERSION = 3;
 
 // Converter from v1 to v2: Remove connectionToken from Init message
 const v1ToV2 = (v1Data: v1.ToClient): v2.ToClient => {
@@ -43,13 +44,42 @@ const v2ToV1 = (v2Data: v2.ToClient): v1.ToClient => {
 	return v2Data as unknown as v1.ToClient;
 };
 
-export const TO_SERVER_VERSIONED = createVersionedDataHandler<v2.ToServer>({
+// Converter from v2 to v3: No changes needed for ToClient
+const v2ToV3 = (v2Data: v2.ToClient): v3.ToClient => {
+	return v2Data as unknown as v3.ToClient;
+};
+
+// Converter from v3 to v2: No changes needed for ToClient
+const v3ToV2 = (v3Data: v3.ToClient): v2.ToClient => {
+	return v3Data as unknown as v2.ToClient;
+};
+
+// ToServer identity converters (ToServer is identical across v1, v2, and v3)
+const v1ToServerV2 = (v1Data: v1.ToServer): v2.ToServer => {
+	return v1Data as unknown as v2.ToServer;
+};
+
+const v2ToServerV3 = (v2Data: v2.ToServer): v3.ToServer => {
+	return v2Data as unknown as v3.ToServer;
+};
+
+const v3ToServerV2 = (v3Data: v3.ToServer): v2.ToServer => {
+	return v3Data as unknown as v2.ToServer;
+};
+
+const v2ToServerV1 = (v2Data: v2.ToServer): v1.ToServer => {
+	return v2Data as unknown as v1.ToServer;
+};
+
+export const TO_SERVER_VERSIONED = createVersionedDataHandler<v3.ToServer>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
 				return v1.decodeToServer(bytes);
 			case 2:
 				return v2.decodeToServer(bytes);
+			case 3:
+				return v3.decodeToServer(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -60,21 +90,25 @@ export const TO_SERVER_VERSIONED = createVersionedDataHandler<v2.ToServer>({
 				return v1.encodeToServer(data as v1.ToServer);
 			case 2:
 				return v2.encodeToServer(data as v2.ToServer);
+			case 3:
+				return v3.encodeToServer(data as v3.ToServer);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToV2],
-	serializeConverters: () => [v2ToV1],
+	deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
+	serializeConverters: () => [v3ToServerV2, v2ToServerV1],
 });
 
-export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v2.ToClient>({
+export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v3.ToClient>({
 	deserializeVersion: (bytes, version) => {
 		switch (version) {
 			case 1:
 				return v1.decodeToClient(bytes);
 			case 2:
 				return v2.decodeToClient(bytes);
+			case 3:
+				return v3.decodeToClient(bytes);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
@@ -85,22 +119,26 @@ export const TO_CLIENT_VERSIONED = createVersionedDataHandler<v2.ToClient>({
 				return v1.encodeToClient(data as v1.ToClient);
 			case 2:
 				return v2.encodeToClient(data as v2.ToClient);
+			case 3:
+				return v3.encodeToClient(data as v3.ToClient);
 			default:
 				throw new Error(`Unknown version ${version}`);
 		}
 	},
-	deserializeConverters: () => [v1ToV2],
-	serializeConverters: () => [v2ToV1],
+	deserializeConverters: () => [v1ToV2, v2ToV3],
+	serializeConverters: () => [v3ToV2, v2ToV1],
 });
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
-	createVersionedDataHandler<v2.HttpActionRequest>({
+	createVersionedDataHandler<v3.HttpActionRequest>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
 					return v1.decodeHttpActionRequest(bytes);
 				case 2:
 					return v2.decodeHttpActionRequest(bytes);
+				case 3:
+					return v3.decodeHttpActionRequest(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -115,6 +153,10 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 					return v2.encodeHttpActionRequest(
 						data as v2.HttpActionRequest,
 					);
+				case 3:
+					return v3.encodeHttpActionRequest(
+						data as v3.HttpActionRequest,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -124,13 +166,15 @@ export const HTTP_ACTION_REQUEST_VERSIONED =
 	});
 
 export const HTTP_ACTION_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v2.HttpActionResponse>({
+	createVersionedDataHandler<v3.HttpActionResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
 					return v1.decodeHttpActionResponse(bytes);
 				case 2:
 					return v2.decodeHttpActionResponse(bytes);
+				case 3:
+					return v3.decodeHttpActionResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -145,6 +189,10 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 					return v2.encodeHttpActionResponse(
 						data as v2.HttpActionResponse,
 					);
+				case 3:
+					return v3.encodeHttpActionResponse(
+						data as v3.HttpActionResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -153,14 +201,72 @@ export const HTTP_ACTION_RESPONSE_VERSIONED =
 		serializeConverters: () => [],
 	});
 
+export const HTTP_QUEUE_SEND_REQUEST_VERSIONED =
+	createVersionedDataHandler<v3.HttpQueueSendRequest>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 3:
+					return v3.decodeHttpQueueSendRequest(bytes);
+				default:
+					throw new Error(
+						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 3:
+					return v3.encodeHttpQueueSendRequest(
+						data as v3.HttpQueueSendRequest,
+					);
+				default:
+					throw new Error(
+						`HttpQueueSendRequest only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
+export const HTTP_QUEUE_SEND_RESPONSE_VERSIONED =
+	createVersionedDataHandler<v3.HttpQueueSendResponse>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 3:
+					return v3.decodeHttpQueueSendResponse(bytes);
+				default:
+					throw new Error(
+						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		serializeVersion: (data, version) => {
+			switch (version) {
+				case 3:
+					return v3.encodeHttpQueueSendResponse(
+						data as v3.HttpQueueSendResponse,
+					);
+				default:
+					throw new Error(
+						`HttpQueueSendResponse only exists in version 3+, got version ${version}`,
+					);
+			}
+		},
+		deserializeConverters: () => [],
+		serializeConverters: () => [],
+	});
+
 export const HTTP_RESPONSE_ERROR_VERSIONED =
-	createVersionedDataHandler<v2.HttpResponseError>({
+	createVersionedDataHandler<v3.HttpResponseError>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
 					return v1.decodeHttpResponseError(bytes);
 				case 2:
 					return v2.decodeHttpResponseError(bytes);
+				case 3:
+					return v3.decodeHttpResponseError(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -175,6 +281,10 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 					return v2.encodeHttpResponseError(
 						data as v2.HttpResponseError,
 					);
+				case 3:
+					return v3.encodeHttpResponseError(
+						data as v3.HttpResponseError,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -184,13 +294,15 @@ export const HTTP_RESPONSE_ERROR_VERSIONED =
 	});
 
 export const HTTP_RESOLVE_RESPONSE_VERSIONED =
-	createVersionedDataHandler<v2.HttpResolveResponse>({
+	createVersionedDataHandler<v3.HttpResolveResponse>({
 		deserializeVersion: (bytes, version) => {
 			switch (version) {
 				case 1:
 					return v1.decodeHttpResolveResponse(bytes);
 				case 2:
 					return v2.decodeHttpResolveResponse(bytes);
+				case 3:
+					return v3.decodeHttpResolveResponse(bytes);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}
@@ -205,6 +317,10 @@ export const HTTP_RESOLVE_RESPONSE_VERSIONED =
 					return v2.encodeHttpResolveResponse(
 						data as v2.HttpResolveResponse,
 					);
+				case 3:
+					return v3.encodeHttpResolveResponse(
+						data as v3.HttpResolveResponse,
+					);
 				default:
 					throw new Error(`Unknown version ${version}`);
 			}

package/src/schemas/client-protocol-zod/mod.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from "zod/v4";
 
 // Helper schemas
 const UintSchema = z.bigint();
@@ -84,6 +84,21 @@ export const HttpActionResponseSchema = z.object({
 });
 export type HttpActionResponse = z.infer<typeof HttpActionResponseSchema>;
 
+// MARK: HTTP Queue
+export const HttpQueueSendRequestSchema = z.object({
+	body: z.unknown(),
+	name: z.string().optional(),
+	wait: z.boolean().optional(),
+	timeout: z.number().optional(),
+});
+export type HttpQueueSendRequest = z.infer<typeof HttpQueueSendRequestSchema>;
+
+export const HttpQueueSendResponseSchema = z.object({
+	status: z.enum(["completed", "timedOut"]),
+	response: z.unknown().optional(),
+});
+export type HttpQueueSendResponse = z.infer<typeof HttpQueueSendResponseSchema>;
+
 // MARK: HTTP Error
 export const HttpResponseErrorSchema = z.object({
 	group: z.string(),

package/src/schemas/persist/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/persist/v1";

package/src/schemas/transport/mod.ts

@@ -0,0 +1 @@
+export * from "../../../dist/schemas/transport/v1";

package/src/serde.ts

@@ -1,7 +1,7 @@
 import * as cbor from "cbor-x";
 import invariant from "invariant";
 import type { VersionedDataHandler } from "vbare";
-import type { z } from "zod";
+import type { z } from "zod/v4";
 import { assertUnreachable } from "@/common/utils";
 import type { Encoding } from "@/mod";
 import { jsonParseCompat, jsonStringifyCompat } from "./actor/protocol/serde";