rivetkit 2.3.0-rc.9 → 2.3.0

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

@@ -122,71 +122,73 @@ const v4HttpResponseErrorToV3 = (
 	return rest;
 };
 
-export const CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler<v4.ToServer>({
-	deserializeVersion: (bytes, version) => {
-		switch (version) {
-			case 1:
-				return v1.decodeToServer(bytes);
-			case 2:
-				return v2.decodeToServer(bytes);
-			case 3:
-				return v3.decodeToServer(bytes);
-			case 4:
-				return v4.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);
-			case 3:
-				return v3.encodeToServer(data as v3.ToServer);
-			case 4:
-				return v4.encodeToServer(data as v4.ToServer);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
-	serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
-});
+export const CLIENT_PROTOCOL_TO_SERVER =
+	createVersionedDataHandler<v4.ToServer>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeToServer(bytes);
+				case 2:
+					return v2.decodeToServer(bytes);
+				case 3:
+					return v3.decodeToServer(bytes);
+				case 4:
+					return v4.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);
+				case 3:
+					return v3.encodeToServer(data as v3.ToServer);
+				case 4:
+					return v4.encodeToServer(data as v4.ToServer);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+		serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1],
+	});
 
-export const CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler<v4.ToClient>({
-	deserializeVersion: (bytes, version) => {
-		switch (version) {
-			case 1:
-				return v1.decodeToClient(bytes);
-			case 2:
-				return v2.decodeToClient(bytes);
-			case 3:
-				return v3.decodeToClient(bytes);
-			case 4:
-				return v4.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);
-			case 3:
-				return v3.encodeToClient(data as v3.ToClient);
-			case 4:
-				return v4.encodeToClient(data as v4.ToClient);
-			default:
-				throw new Error(`Unknown version ${version}`);
-		}
-	},
-	deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
-	serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
-});
+export const CLIENT_PROTOCOL_TO_CLIENT =
+	createVersionedDataHandler<v4.ToClient>({
+		deserializeVersion: (bytes, version) => {
+			switch (version) {
+				case 1:
+					return v1.decodeToClient(bytes);
+				case 2:
+					return v2.decodeToClient(bytes);
+				case 3:
+					return v3.decodeToClient(bytes);
+				case 4:
+					return v4.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);
+				case 3:
+					return v3.encodeToClient(data as v3.ToClient);
+				case 4:
+					return v4.encodeToClient(data as v4.ToClient);
+				default:
+					throw new Error(`Unknown version ${version}`);
+			}
+		},
+		deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+		serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1],
+	});
 
 export const HTTP_ACTION_REQUEST_VERSIONED =
 	createVersionedDataHandler<v4.HttpActionRequest>({

package/src/common/database/config.ts

@@ -42,10 +42,7 @@ export interface SqliteDatabase {
 		sql: string,
 		callback?: (row: unknown[], columns: string[]) => void,
 	): Promise<void>;
-	execute(
-		sql: string,
-		params?: SqliteBindings,
-	): Promise<SqliteExecuteResult>;
+	execute(sql: string, params?: SqliteBindings): Promise<SqliteExecuteResult>;
 	run(sql: string, params?: SqliteBindings): Promise<void>;
 	query(sql: string, params?: SqliteBindings): Promise<SqliteQueryResult>;
 	nativeMetrics?():
@@ -132,10 +129,7 @@ export interface RawDatabaseClient {
 /**
  * Drizzle database client interface (will be extended by drizzle-orm types)
  */
-export interface DrizzleDatabaseClient {
-	// This will be extended by BaseSQLiteDatabase from drizzle-orm
-	// For now, just a marker interface
-}
+export type DrizzleDatabaseClient = {};
 
 type ExecuteFunction = <
 	TRow extends Record<string, unknown> = Record<string, unknown>,

package/src/common/database/native-database.ts

@@ -97,7 +97,7 @@ function enrichNativeDatabaseError(
 			? error
 			: error instanceof Error
 				? error.message
-			: undefined;
+				: undefined;
 	const bridged =
 		bridgeReason === undefined
 			? undefined

package/src/common/database/shared.ts

@@ -1,4 +1,5 @@
 import type { SqliteBindings } from "./config";
+
 type SqliteBindingObject = Record<string, unknown>;
 
 function isSqliteBindingValue(value: unknown): boolean {

package/src/common/encoding.ts

@@ -1,5 +1,5 @@
-import { z } from "zod/v4";
 import type { VersionedDataHandler } from "vbare";
+import { z } from "zod/v4";
 import { serializeWithEncoding } from "@/serde";
 import { assertUnreachable } from "./utils";
 
@@ -13,6 +13,171 @@ const JSON_COMPAT_BIGINT = "$BigInt";
 const JSON_COMPAT_ARRAY_BUFFER = "$ArrayBuffer";
 const JSON_COMPAT_UINT8_ARRAY = "$Uint8Array";
 const JSON_COMPAT_UNDEFINED = "$Undefined";
+const JSON_COMPAT_SET = "$Set";
+
+/**
+ * Types that cbor-x encodes natively without any compat transforms.
+ */
+export type CborSerializable =
+	| string
+	| number
+	| boolean
+	| null
+	| undefined
+	| bigint
+	| Date
+	| RegExp
+	| Error
+	| ArrayBuffer
+	| Uint8Array
+	| Uint8ClampedArray
+	| Uint16Array
+	| Uint32Array
+	| BigUint64Array
+	| Int8Array
+	| Int16Array
+	| Int32Array
+	| BigInt64Array
+	| Float32Array
+	| Float64Array
+	| CborSerializable[]
+	| Map<CborSerializable, CborSerializable>
+	| { [key: string]: CborSerializable };
+
+/**
+ * User-facing serializable type. Extends CborSerializable with Set (encoded
+ * as a `$Set` tagged array by the JSON compat layer).
+ */
+export type JsonCompatValue =
+	| CborSerializable
+	| Set<JsonCompatValue>
+	| JsonCompatValue[]
+	| Map<JsonCompatValue, JsonCompatValue>
+	| { [key: string]: JsonCompatValue };
+
+function isTypedArray(value: unknown): boolean {
+	return (
+		value instanceof Uint8ClampedArray ||
+		value instanceof Uint16Array ||
+		value instanceof Uint32Array ||
+		value instanceof BigUint64Array ||
+		value instanceof Int8Array ||
+		value instanceof Int16Array ||
+		value instanceof Int32Array ||
+		value instanceof BigInt64Array ||
+		value instanceof Float32Array ||
+		value instanceof Float64Array
+	);
+}
+
+/**
+ * Recursively validates that a value is CBOR serializable. Throws TypeError
+ * with a descriptive message for non-serializable values.
+ */
+export function assertJsonCompatValue(
+	value: unknown,
+	path = "",
+): asserts value is JsonCompatValue {
+	if (
+		value === null ||
+		value === undefined ||
+		typeof value === "string" ||
+		typeof value === "number" ||
+		typeof value === "boolean" ||
+		typeof value === "bigint"
+	) {
+		return;
+	}
+
+	if (typeof value === "function") {
+		throw new TypeError(
+			`Value at ${path || "root"} is a function and is not CBOR serializable`,
+		);
+	}
+
+	if (typeof value === "symbol") {
+		throw new TypeError(
+			`Value at ${path || "root"} is a symbol and is not CBOR serializable`,
+		);
+	}
+
+	if (
+		value instanceof Date ||
+		value instanceof RegExp ||
+		value instanceof Error ||
+		value instanceof ArrayBuffer ||
+		value instanceof Uint8Array ||
+		isTypedArray(value)
+	) {
+		return;
+	}
+
+	if (value instanceof WeakMap) {
+		throw new TypeError(
+			`Value at ${path || "root"} is a WeakMap and is not CBOR serializable`,
+		);
+	}
+
+	if (value instanceof WeakSet) {
+		throw new TypeError(
+			`Value at ${path || "root"} is a WeakSet and is not CBOR serializable`,
+		);
+	}
+
+	if (value instanceof WeakRef) {
+		throw new TypeError(
+			`Value at ${path || "root"} is a WeakRef and is not CBOR serializable`,
+		);
+	}
+
+	if (value instanceof Promise) {
+		throw new TypeError(
+			`Value at ${path || "root"} is a Promise and is not CBOR serializable`,
+		);
+	}
+
+	if (value instanceof Map) {
+		for (const [k, v] of value.entries()) {
+			assertJsonCompatValue(k, `${path || "root"}.key(${String(k)})`);
+			assertJsonCompatValue(v, `${path || "root"}.value(${String(k)})`);
+		}
+		return;
+	}
+
+	if (value instanceof Set) {
+		let index = 0;
+		for (const item of value.values()) {
+			assertJsonCompatValue(item, `${path || "root"}.set[${index}]`);
+			index++;
+		}
+		return;
+	}
+
+	if (Array.isArray(value)) {
+		for (let i = 0; i < value.length; i++) {
+			assertJsonCompatValue(value[i], `${path || "root"}[${i}]`);
+		}
+		return;
+	}
+
+	if (isPlainObject(value)) {
+		for (const key in value) {
+			assertJsonCompatValue(
+				value[key as keyof typeof value],
+				path ? `${path}.${key}` : key,
+			);
+		}
+		return;
+	}
+
+	const typeName =
+		typeof value === "object" && value !== null
+			? (value.constructor?.name ?? typeof value)
+			: typeof value;
+	throw new TypeError(
+		`Value at ${path || "root"} of type "${typeName}" is not CBOR serializable`,
+	);
+}
 
 export const EncodingSchema = z.enum(["json", "cbor", "bare"]);
 
@@ -112,38 +277,97 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return proto === Object.prototype || proto === null;
 }
 
-export function encodeJsonCompatValue(input: any): any {
+export function encodeJsonCompatValue(input: JsonCompatValue): unknown {
+	// Primitives
+	if (input === null) {
+		return input;
+	}
 	if (input === undefined) {
 		return [JSON_COMPAT_UNDEFINED, 0];
 	}
+	if (
+		typeof input === "string" ||
+		typeof input === "number" ||
+		typeof input === "boolean"
+	) {
+		return input;
+	}
 	if (typeof input === "bigint") {
 		return [JSON_COMPAT_BIGINT, input.toString()];
 	}
+
+	// Binary types with custom encoding
 	if (input instanceof ArrayBuffer) {
 		return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(input)];
 	}
 	if (input instanceof Uint8Array) {
 		return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(input)];
 	}
+
+	// TypedArrays pass through for cbor-x native handling
+	if (isTypedArray(input)) {
+		return input;
+	}
+
+	// Date, RegExp, and Error pass through for cbor-x native handling
+	if (
+		input instanceof Date ||
+		input instanceof RegExp ||
+		input instanceof Error
+	) {
+		return input;
+	}
+
+	// Set uses custom tag encoding
+	if (input instanceof Set) {
+		const encoded = [...input.values()].map((v) =>
+			encodeJsonCompatValue(v as JsonCompatValue),
+		);
+		return [JSON_COMPAT_SET, encoded];
+	}
+
+	// Map recurses into keys and values
+	if (input instanceof Map) {
+		const encoded = new Map<unknown, unknown>();
+		for (const [k, v] of input.entries()) {
+			encoded.set(
+				encodeJsonCompatValue(k as JsonCompatValue),
+				encodeJsonCompatValue(v as JsonCompatValue),
+			);
+		}
+		return encoded;
+	}
+
+	// Arrays
 	if (Array.isArray(input)) {
-		const encoded = input.map((value) => encodeJsonCompatValue(value));
+		const encoded = input.map((value) =>
+			encodeJsonCompatValue(value as JsonCompatValue),
+		);
 		if (
 			encoded.length === 2 &&
 			typeof encoded[0] === "string" &&
-			encoded[0].startsWith("$")
+			(encoded[0] as string).startsWith("$")
 		) {
-			return ["$" + encoded[0], encoded[1]];
+			return [`$${encoded[0]}`, encoded[1]];
 		}
 		return encoded;
 	}
+
+	// Plain objects
 	if (isPlainObject(input)) {
 		const encoded: Record<string, unknown> = {};
 		for (const [key, value] of Object.entries(input)) {
-			encoded[key] = encodeJsonCompatValue(value);
+			encoded[key] = encodeJsonCompatValue(value as JsonCompatValue);
 		}
 		return encoded;
 	}
-	return input;
+
+	// Not serializable
+	const typeName =
+		typeof input === "object" && input !== null
+			? ((input as object).constructor?.name ?? typeof input)
+			: typeof input;
+	throw new TypeError(`Value of type "${typeName}" is not CBOR serializable`);
 }
 
 export interface JsonCompatReviveOptions {
@@ -164,6 +388,16 @@ export function reviveJsonCompatValue(
 		}
 		return input;
 	}
+	if (input instanceof Map) {
+		const revived = new Map();
+		for (const [k, v] of input.entries()) {
+			revived.set(
+				reviveJsonCompatValue(k, options),
+				reviveJsonCompatValue(v, options),
+			);
+		}
+		return revived;
+	}
 	if (Array.isArray(input)) {
 		if (
 			input.length === 2 &&
@@ -182,6 +416,12 @@ export function reviveJsonCompatValue(
 			if (input[0] === JSON_COMPAT_UNDEFINED) {
 				return undefined;
 			}
+			if (input[0] === JSON_COMPAT_SET) {
+				const items = (input[1] as unknown[]).map((v) =>
+					reviveJsonCompatValue(v, options),
+				);
+				return new Set(items);
+			}
 			if (input[0].startsWith("$$")) {
 				return [
 					input[0].substring(1),
@@ -239,16 +479,10 @@ export function jsonStringifyCompat(input: any): string {
 			return [JSON_COMPAT_BIGINT, value.toString()];
 		}
 		if (value instanceof ArrayBuffer) {
-			return [
-				JSON_COMPAT_ARRAY_BUFFER,
-				base64EncodeArrayBuffer(value),
-			];
+			return [JSON_COMPAT_ARRAY_BUFFER, base64EncodeArrayBuffer(value)];
 		}
 		if (value instanceof Uint8Array) {
-			return [
-				JSON_COMPAT_UINT8_ARRAY,
-				base64EncodeUint8Array(value),
-			];
+			return [JSON_COMPAT_UINT8_ARRAY, base64EncodeUint8Array(value)];
 		}
 		if (
 			Array.isArray(value) &&
@@ -256,7 +490,7 @@ export function jsonStringifyCompat(input: any): string {
 			typeof value[0] === "string" &&
 			value[0].startsWith("$")
 		) {
-			return ["$" + value[0], value[1]];
+			return [`$${value[0]}`, value[1]];
 		}
 		return value;
 	});

package/src/common/engine.ts

@@ -1,2 +1,29 @@
+export const ENGINE_HOST = "127.0.0.1";
 export const ENGINE_PORT = 6420;
-export const ENGINE_ENDPOINT = `http://127.0.0.1:${ENGINE_PORT}`;
+export const ENGINE_ENDPOINT = buildEngineEndpoint(ENGINE_HOST, ENGINE_PORT);
+
+export function buildEngineEndpoint(host: string, port: number): string {
+	const urlHost =
+		host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+	return `http://${urlHost}:${port}`;
+}
+
+export function isLocalEngineEndpoint(endpoint: string): boolean {
+	let url: URL;
+	try {
+		url = new URL(endpoint);
+	} catch {
+		return false;
+	}
+
+	const hostname = url.hostname.toLowerCase();
+	return (
+		hostname === "localhost" ||
+		hostname === "0.0.0.0" ||
+		hostname === "::" ||
+		hostname === "[::]" ||
+		hostname === "::1" ||
+		hostname === "[::1]" ||
+		/^127(?:\.\d{1,3}){0,3}$/.test(hostname)
+	);
+}

package/src/common/eventsource.ts

@@ -25,7 +25,7 @@ export async function importEventSource(): Promise<typeof EventSource> {
 			const es = await import(/* webpackIgnore: true */ moduleName);
 			_EventSource = es.EventSource;
 			logger().debug("using eventsource from npm");
-		} catch (err) {
+		} catch (_err) {
 			// EventSource not available
 			_EventSource = class MockEventSource {
 				constructor() {

package/src/common/inline-websocket-adapter.ts

@@ -1,7 +1,7 @@
+import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import { WSContext } from "hono/ws";
 import type { UpgradeWebSocketArgs } from "@/common/actor-websocket";
 import type { UniversalWebSocket } from "@/common/websocket-interface";
-import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import { getLogger } from "./log";
 
 function logger() {
@@ -161,28 +161,29 @@ export class InlineWebSocketAdapter {
 		}
 	}
 
-	#handleError(err: unknown): void {
-		console.error("INLINE_WEBSOCKET_ADAPTER_ERROR", err);
+	#handleError(error: unknown): void {
+		console.error("INLINE_WEBSOCKET_ADAPTER_ERROR", error);
 		logger().error({
 			msg: "error in websocket",
-			error: err,
-			errorMessage: err instanceof Error ? err.message : String(err),
-			stack: err instanceof Error ? err.stack : undefined,
+			error,
+			errorMessage:
+				error instanceof Error ? error.message : String(error),
+			stack: error instanceof Error ? error.stack : undefined,
 		});
 
 		// Call handler.onError
 		try {
-			this.#handler.onError(err, this.#wsContext);
-		} catch (handlerErr) {
+			this.#handler.onError(error, this.#wsContext);
+		} catch (error) {
 			logger().error({
 				msg: "error in onError handler",
-				error: handlerErr,
+				error,
 			});
 		}
 
 		// Fire error event to both sides
-		this.#clientWs.triggerError(err);
-		this.#actorWs.triggerError(err);
+		this.#clientWs.triggerError(error);
+		this.#actorWs.triggerError(error);
 	}
 
 	#close(code: number, reason: string): void {
@@ -199,8 +200,8 @@ export class InlineWebSocketAdapter {
 				{ code, reason, wasClean: true },
 				this.#wsContext,
 			);
-		} catch (err) {
-			logger().error({ msg: "error closing websocket", error: err });
+		} catch (error) {
+			logger().error({ msg: "error closing websocket", error });
 		} finally {
 			this.#readyState = 3; // CLOSED
 

package/src/common/log.ts

@@ -76,6 +76,7 @@ export function configureDefaultLogger(logLevel?: LogLevel) {
 			messageKey: "msg",
 			// Do not include pid/hostname in output
 			base: {},
+			errorKey: "error",
 			// Keep the numeric level so the logfmt sink can match Pino's levels.
 			formatters: {
 				level(_label: string, number: number) {