rivetkit 2.3.0-rc.9 → 2.3.0

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,23 +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 { 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 {
@@ -302,7 +303,7 @@ function pushInputQueryParam(
 		return;
 	}
 
-	const encodedInput = encodeCborCompat(input);
+	const encodedInput = encodeCborCompat(input as JsonCompatValue);
 	if (encodedInput.byteLength > maxInputSize) {
 		throw new Error(
 			`Actor query input exceeds maxInputSize (${encodedInput.byteLength} > ${maxInputSize} bytes). Increase client maxInputSize to allow larger query payloads.`,

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,6 +22,7 @@ import type {
 	ListActorsInput,
 	RuntimeDisplayInformation,
 } from "@/engine-client/driver";
+import { shouldSkipReadyWait } from "@/engine-client/driver";
 import type { Encoding, UniversalWebSocket } from "@/mod";
 import { encodeCborCompat, uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath, type GetUpgradeWebSocket } from "@/utils";
@@ -181,7 +182,9 @@ export class RemoteEngineControlClient implements EngineControlClient {
 			key: serializeActorKey(key),
 			runner_name_selector: this.#config.poolName,
 			input: actorInput
-				? uint8ArrayToBase64(encodeCborCompat(actorInput))
+				? uint8ArrayToBase64(
+						encodeCborCompat(actorInput as JsonCompatValue),
+					)
 				: undefined,
 			crash_policy: crashPolicy ?? "sleep",
 		});
@@ -215,7 +218,7 @@ export class RemoteEngineControlClient implements EngineControlClient {
 			runner_name_selector: this.#config.poolName,
 			key: serializeActorKey(key),
 			input: input
-				? uint8ArrayToBase64(encodeCborCompat(input))
+				? uint8ArrayToBase64(encodeCborCompat(input 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],
 });

package/src/inspector/mod.ts

@@ -1,4 +1,5 @@
 export * from "@/common/bare/generated/inspector/v4";
+export type { WorkflowHistory as TransportWorkflowHistory } from "@/common/bare/transport/v1";
 export {
 	decodeWorkflowHistoryTransport,
 	encodeWorkflowHistoryTransport,
@@ -7,6 +8,3 @@ export {
 	createWorkflowInspectorAdapter,
 	type WorkflowInspectorAdapter,
 } from "@/workflow/inspector";
-export type {
-	WorkflowHistory as TransportWorkflowHistory,
-} from "@/common/bare/transport/v1";