rivetkit 2.3.0-rc.9 → 2.3.0

package/src/client/actor-handle.ts

@@ -1,6 +1,5 @@
 import type { AnyActorDefinition } from "@/actor/definition";
 import type { ActorSpecifier } from "@/actor/errors";
-import type { Encoding } from "@/common/encoding";
 import {
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
@@ -12,7 +11,6 @@ import {
 	HTTP_ACTION_RESPONSE_VERSIONED,
 	HTTP_RESPONSE_ERROR_VERSIONED,
 } from "@/common/client-protocol-versioned";
-import { AsyncMutex } from "@/common/database/shared";
 import {
 	type HttpActionRequest as HttpActionRequestJson,
 	HttpActionRequestSchema,
@@ -21,16 +19,22 @@ import {
 	type HttpResponseError as HttpResponseErrorJson,
 	HttpResponseErrorSchema,
 } from "@/common/client-protocol-zod";
+import { AsyncMutex } from "@/common/database/shared";
+import type { Encoding, JsonCompatValue } from "@/common/encoding";
 import { deconstructError } from "@/common/utils";
 import type { EngineControlClient } from "@/engine-client/driver";
-import { decodeCborCompat, deserializeWithEncoding, encodeCborCompat } from "@/serde";
+import {
+	decodeCborCompat,
+	deserializeWithEncoding,
+	encodeCborCompat,
+} from "@/serde";
 import { bufferToArrayBuffer } from "@/utils";
 import type {
 	ActorActionOptions,
 	ActorConnectOptions,
 	ActorDefinitionActions,
-	ActorFetchInit,
 	ActorDefinitionQueueSend,
+	ActorFetchInit,
 	ActorGatewayOptions,
 	ActorWebSocketOptions,
 } from "./actor-common";
@@ -147,7 +151,8 @@ export class ActorHandleRaw {
 						useQueryTarget,
 						gatewayOptions,
 					);
-					actorId = "directId" in target ? target.directId : undefined;
+					actorId =
+						"directId" in target ? target.directId : undefined;
 
 					return await createQueueSender({
 						encoding: this.#encoding,
@@ -161,10 +166,8 @@ export class ActorHandleRaw {
 						},
 					}).send(name, body, options as any);
 				} catch (err) {
-					const { group, code, message, metadata, actor } = deconstructError(
-						err,
-						true,
-					);
+					const { group, code, message, metadata, actor } =
+						deconstructError(err, true);
 
 					if (
 						this.#shouldRetryQueueDispatchOverload(
@@ -207,19 +210,25 @@ export class ActorHandleRaw {
 						continue;
 					}
 
-					const invalidated = this.#invalidateResolvedActorId(group, code);
+					const invalidated = this.#invalidateResolvedActorId(
+						group,
+						code,
+					);
 					if (invalidated && attempt < maxAttempts - 1) {
 						useQueryTarget =
-							(code === "starting" ||
-								code === "stopping" ||
-								code.startsWith("destroyed_"));
+							code === "starting" ||
+							code === "stopping" ||
+							code.startsWith("destroyed_");
 						if (useQueryTarget) {
 							await this.#waitForRetryWindow();
 						}
 						continue;
 					}
 
-					throw new ActorError(group, code, message, { metadata, actor });
+					throw new ActorError(group, code, message, {
+						metadata,
+						actor,
+					});
 				}
 			}
 
@@ -234,13 +243,12 @@ export class ActorHandleRaw {
 	 * @template Args - The type of arguments to pass to the action function.
 	 * @template Response - The type of the response returned by the action function.
 	 */
-	async action<
-		Args extends Array<unknown> = unknown[],
-		Response = unknown,
-	>(opts: {
-		name: string;
-		args: Args;
-	} & ActorActionOptions): Promise<Response> {
+	async action<Args extends Array<unknown> = unknown[], Response = unknown>(
+		opts: {
+			name: string;
+			args: Args;
+		} & ActorActionOptions,
+	): Promise<Response> {
 		if (
 			typeof opts === "string" ||
 			typeof opts !== "object" ||
@@ -259,10 +267,12 @@ export class ActorHandleRaw {
 		return await retryOnLifecycleBoundary(run, { signal: opts.signal });
 	}
 
-	async #sendActionNow(opts: {
-		name: string;
-		args: unknown[];
-	} & ActorActionOptions): Promise<unknown> {
+	async #sendActionNow(
+		opts: {
+			name: string;
+			args: unknown[];
+		} & ActorActionOptions,
+	): Promise<unknown> {
 		const maxAttempts = this.#getDynamicQueryMaxAttempts();
 		let useQueryTarget = false;
 		const gatewayOptions = resolveActorGatewayOptions(
@@ -325,16 +335,20 @@ export class ActorHandleRaw {
 					requestVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
 					requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
 					responseVersion: CLIENT_PROTOCOL_CURRENT_VERSION,
-					responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,
+					responseVersionedDataHandler:
+						HTTP_ACTION_RESPONSE_VERSIONED,
 					requestZodSchema: HttpActionRequestSchema,
 					responseZodSchema: HttpActionResponseSchema,
 					requestToJson: (args): HttpActionRequestJson => ({
 						args,
 					}),
 					requestToBare: (args): protocol.HttpActionRequest => ({
-						args: bufferToArrayBuffer(encodeCborCompat(args)),
+						args: bufferToArrayBuffer(
+							encodeCborCompat(args as JsonCompatValue),
+						),
 					}),
-					responseFromJson: (json): Response => json.output as Response,
+					responseFromJson: (json): Response =>
+						json.output as Response,
 					responseFromBare: (bare): Response =>
 						decodeCborCompat(new Uint8Array(bare.output)),
 				});
@@ -343,10 +357,8 @@ export class ActorHandleRaw {
 				}
 				return output;
 			} catch (err) {
-				const { group, code, message, metadata, actor } = deconstructError(
-					err,
-					true,
-				);
+				const { group, code, message, metadata, actor } =
+					deconstructError(err, true);
 
 				if (
 					await this.#shouldRetrySchedulingError(
@@ -390,14 +402,19 @@ export class ActorHandleRaw {
 					);
 				}
 
-				const invalidated = this.#invalidateResolvedActorId(group, code);
+				const invalidated = this.#invalidateResolvedActorId(
+					group,
+					code,
+				);
 				if (invalidated && attempt < maxAttempts - 1) {
 					if (
 						group === "actor" &&
 						(code === "starting" || code === "stopping")
 					) {
 						useQueryTarget = true;
-						await new Promise((resolve) => setTimeout(resolve, 100));
+						await new Promise((resolve) =>
+							setTimeout(resolve, 100),
+						);
 					}
 					continue;
 				}
@@ -662,10 +679,8 @@ export class ActorHandleRaw {
 				}
 				return response;
 			} catch (err) {
-				const { group, code, message, metadata, actor } = deconstructError(
-					err,
-					true,
-				);
+				const { group, code, message, metadata, actor } =
+					deconstructError(err, true);
 
 				if (
 					await this.#shouldRetrySchedulingError(
@@ -695,12 +710,15 @@ export class ActorHandleRaw {
 					continue;
 				}
 
-				const invalidated = this.#invalidateResolvedActorId(group, code);
+				const invalidated = this.#invalidateResolvedActorId(
+					group,
+					code,
+				);
 				if (invalidated && attempt < maxAttempts - 1) {
 					useQueryTarget =
-						(code === "starting" ||
-							code === "stopping" ||
-							code.startsWith("destroyed_"));
+						code === "starting" ||
+						code === "stopping" ||
+						code.startsWith("destroyed_");
 					if (useQueryTarget) {
 						await this.#waitForRetryWindow();
 					}
@@ -719,13 +737,10 @@ export class ActorHandleRaw {
 		actorId: string | undefined,
 		attempt: number,
 		maxAttempts: number,
-	): Promise<
-		| {
-				useQueryTarget: boolean;
-				waitForRetryWindow: boolean;
-		  }
-		| null
-	> {
+	): Promise<{
+		useQueryTarget: boolean;
+		waitForRetryWindow: boolean;
+	} | null> {
 		if (response.ok || !isDynamicActorQuery(this.#actorResolutionState)) {
 			return null;
 		}
@@ -857,8 +872,9 @@ export class ActorHandleRaw {
 			this.#gatewayOptions,
 			options,
 		);
+		const useQueryTarget = isDynamicActorQuery(this.#actorResolutionState);
 		const target = await this.#resolveGatewayRequestTarget(
-			false,
+			useQueryTarget,
 			gatewayOptions,
 		);
 		return await rawWebSocket(
@@ -884,7 +900,9 @@ export class ActorHandleRaw {
 			return target.directId;
 		}
 
-		throw new Error("dynamic actor resolution did not produce a direct actor id");
+		throw new Error(
+			"dynamic actor resolution did not produce a direct actor id",
+		);
 	}
 
 	/**

package/src/client/actor-query.ts

@@ -1,11 +1,11 @@
 import * as errors from "@/actor/errors";
+import type { ActorQuery } from "@/client/query";
 import { stringifyError } from "@/common/utils";
-import {
-	type GatewayTarget,
-	type EngineControlClient,
+import type {
+	EngineControlClient,
+	GatewayTarget,
 } from "@/engine-client/driver";
-import type { ActorQuery } from "@/client/query";
-import { actorSchedulingError, type ActorSchedulingError } from "./errors";
+import { type ActorSchedulingError, actorSchedulingError } from "./errors";
 import { logger } from "./log";
 
 /**

package/src/client/errors.ts

@@ -1,7 +1,7 @@
 import {
+	type ActorSpecifier,
 	INTERNAL_ERROR_CODE,
 	RivetError,
-	type ActorSpecifier,
 	type RivetErrorLike,
 	UserError,
 } from "@/actor/errors";

package/src/client/lifecycle-errors.ts

@@ -162,6 +162,7 @@ function classifyActorError(
 function isRetryableGuardGatewayHttpError(code: string): boolean {
 	return (
 		code === "service_unavailable" ||
+		code === "actor_wake_retries_exceeded" ||
 		code === "actor_stopped_while_waiting" ||
 		code === "tunnel_request_aborted" ||
 		code === "tunnel_message_timeout" ||
@@ -299,10 +300,7 @@ export async function retryOnLifecycleBoundary<T>(
 				break;
 			}
 
-			const delayMs = Math.min(
-				initialDelayMs * 2 ** attempt,
-				maxDelayMs,
-			);
+			const delayMs = Math.min(initialDelayMs * 2 ** attempt, maxDelayMs);
 			await waitWithSignal(delayMs, opts?.signal);
 		}
 	}

package/src/client/query.ts

@@ -1,11 +1,11 @@
 import { z } from "zod/v4";
-import { EncodingSchema } from "@/common/encoding";
 import {
 	HEADER_ACTOR_ID,
 	HEADER_ACTOR_QUERY,
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,
 } from "@/common/actor-router-consts";
+import { EncodingSchema } from "@/common/encoding";
 
 // Maximum size of a key component in bytes
 // Set to 128 bytes to allow for separators and escape characters in the full key

package/src/client/queue.ts

@@ -1,5 +1,7 @@
-import type { Encoding } from "@/common/encoding";
-import { HEADER_CONN_PARAMS, HEADER_ENCODING } from "@/common/actor-router-consts";
+import {
+	HEADER_CONN_PARAMS,
+	HEADER_ENCODING,
+} from "@/common/actor-router-consts";
 import type * as protocol from "@/common/client-protocol";
 import {
 	CURRENT_VERSION as CLIENT_PROTOCOL_CURRENT_VERSION,
@@ -12,6 +14,7 @@ import {
 	type HttpQueueSendResponse as HttpQueueSendResponseJson,
 	HttpQueueSendResponseSchema,
 } from "@/common/client-protocol-zod";
+import type { Encoding, JsonCompatValue } from "@/common/encoding";
 import { decodeCborCompat, encodeCborCompat } from "@/serde";
 import { bufferToArrayBuffer } from "@/utils";
 import { sendHttpRequest } from "./utils";
@@ -111,7 +114,9 @@ export function createQueueSender(
 			}),
 			requestToBare: (value): protocol.HttpQueueSendRequest => ({
 				name: value.name ?? name,
-				body: bufferToArrayBuffer(encodeCborCompat(value.body)),
+				body: bufferToArrayBuffer(
+					encodeCborCompat(value.body as JsonCompatValue),
+				),
 				wait: value.wait ?? false,
 				timeout:
 					value.timeout !== undefined ? BigInt(value.timeout) : null,

package/src/client/raw-utils.ts

@@ -1,11 +1,13 @@
-import { PATH_WEBSOCKET_PREFIX } from "@/common/actor-router-consts";
-import { deconstructError } from "@/common/utils";
 import {
-	type GatewayTarget,
-	type EngineControlClient,
-	type GatewayRequestOptions,
+	HEADER_CONN_PARAMS,
+	PATH_WEBSOCKET_PREFIX,
+} from "@/common/actor-router-consts";
+import { deconstructError } from "@/common/utils";
+import type {
+	EngineControlClient,
+	GatewayRequestOptions,
+	GatewayTarget,
 } from "@/engine-client/driver";
-import { HEADER_CONN_PARAMS } from "@/common/actor-router-consts";
 import { ActorError } from "./errors";
 import { logger } from "./log";
 

package/src/client/resolve-gateway-target.ts

@@ -1,7 +1,7 @@
 import { actorNotFound, invalidRequest } from "@/actor/errors";
 import type {
-	GatewayTarget,
 	EngineControlClient,
+	GatewayTarget,
 } from "@/engine-client/driver";
 
 /**

package/src/client/utils.ts

@@ -1,19 +1,14 @@
 import invariant from "invariant";
 import type { VersionedDataHandler } from "vbare";
 import type { z } from "zod/v4";
+import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/common/client-protocol-versioned";
+import { HttpResponseErrorSchema } from "@/common/client-protocol-zod";
 import type { Encoding } from "@/common/encoding";
 import { assertUnreachable } from "@/common/utils";
-import type { HttpResponseError } from "@/common/client-protocol";
-import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/common/client-protocol-versioned";
-import {
-	type HttpResponseError as HttpResponseErrorJson,
-	HttpResponseErrorSchema,
-} from "@/common/client-protocol-zod";
 import {
 	contentTypeForEncoding,
 	decodeCborCompat,
 	deserializeWithEncoding,
-	encodingIsBinary,
 	serializeWithEncoding,
 } from "@/serde";
 import { httpUserAgent } from "@/utils";

package/src/common/actor-websocket.ts

@@ -30,7 +30,9 @@ export function parseWebSocketProtocols(
 	let ackHookTokenRaw: string | undefined;
 
 	if (protocols) {
-		for (const protocol of protocols.split(",").map((value) => value.trim())) {
+		for (const protocol of protocols
+			.split(",")
+			.map((value) => value.trim())) {
 			if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
 				encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
 			} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {