rivetkit 2.3.0-rc.6 → 2.3.0-rc.7

package/src/common/encoding.ts

@@ -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,95 @@ 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;
 	}
+
+	// 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 +386,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 +414,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),

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

@@ -161,28 +161,28 @@ 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 +199,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) {

package/src/common/router.ts

@@ -6,7 +6,7 @@ import {
 	HEADER_ACTOR_ID,
 	HEADER_ACTOR_KEY,
 } from "@/common/actor-router-consts";
-import type { Encoding } from "@/common/encoding";
+import type { JsonCompatValue, Encoding } from "@/common/encoding";
 import {
 	getRequestEncoding,
 	getRequestExposeInternalError,
@@ -111,7 +111,7 @@ export function handleRouteError(error: unknown, c: HonoContext) {
 			code: value.code,
 			message: value.message,
 			metadata: value.metadata
-				? bufferToArrayBuffer(encodeCborCompat(value.metadata))
+				? bufferToArrayBuffer(encodeCborCompat(value.metadata as JsonCompatValue))
 				: null,
 			actor: value.actor
 				? {

package/src/common/utils.ts

@@ -36,154 +36,6 @@ export function safeStringify(obj: unknown, maxSize: number) {
 	return JSON.stringify(obj, replacer);
 }
 
-// TODO: Instead of doing this, use a temp var for state and attempt to write
-// it. Roll back state if fails to serialize.
-
-/**
- * Check if a value is CBOR serializable.
- * Optionally pass an onInvalid callback to receive the path to invalid values.
- *
- * For a complete list of supported CBOR tags, see:
- * https://github.com/kriszyp/cbor-x/blob/cc1cf9df8ba72288c7842af1dd374d73e34cdbc1/README.md#list-of-supported-tags-for-decoding
- */
-export function isCborSerializable(
-	value: unknown,
-	onInvalid?: (path: string) => void,
-	currentPath = "",
-): boolean {
-	// Handle primitive types directly
-	if (value === null || value === undefined) {
-		return true;
-	}
-
-	if (typeof value === "number") {
-		if (!Number.isFinite(value)) {
-			onInvalid?.(currentPath);
-			return false;
-		}
-		return true;
-	}
-
-	if (typeof value === "boolean" || typeof value === "string") {
-		return true;
-	}
-
-	// Handle BigInt (CBOR tags 2 and 3)
-	if (typeof value === "bigint") {
-		return true;
-	}
-
-	// Handle Date objects (CBOR tags 0 and 1)
-	if (value instanceof Date) {
-		return true;
-	}
-
-	// Handle typed arrays (CBOR tags 64-82)
-	if (
-		value instanceof Uint8Array ||
-		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
-	) {
-		return true;
-	}
-
-	// Handle Map (CBOR tag 259)
-	if (value instanceof Map) {
-		for (const [key, val] of value.entries()) {
-			const keyPath = currentPath
-				? `${currentPath}.key(${String(key)})`
-				: `key(${String(key)})`;
-			const valPath = currentPath
-				? `${currentPath}.value(${String(key)})`
-				: `value(${String(key)})`;
-			if (
-				!isCborSerializable(key, onInvalid, keyPath) ||
-				!isCborSerializable(val, onInvalid, valPath)
-			) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	// Handle Set (CBOR tag 258)
-	if (value instanceof Set) {
-		let index = 0;
-		for (const item of value.values()) {
-			const itemPath = currentPath
-				? `${currentPath}.set[${index}]`
-				: `set[${index}]`;
-			if (!isCborSerializable(item, onInvalid, itemPath)) {
-				return false;
-			}
-			index++;
-		}
-		return true;
-	}
-
-	// Handle RegExp (CBOR tag 27)
-	if (value instanceof RegExp) {
-		return true;
-	}
-
-	// Handle Error objects (CBOR tag 27)
-	if (value instanceof Error) {
-		return true;
-	}
-
-	// Handle arrays
-	if (Array.isArray(value)) {
-		for (let i = 0; i < value.length; i++) {
-			const itemPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;
-			if (!isCborSerializable(value[i], onInvalid, itemPath)) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	// Handle plain objects and records (CBOR tags 105, 51, 57344-57599)
-	if (typeof value === "object") {
-		// Allow plain objects and objects with prototypes (for records and named objects)
-		const proto = Object.getPrototypeOf(value);
-		if (proto !== null && proto !== Object.prototype) {
-			// Check if it's a known serializable object type
-			const protoConstructor = value.constructor;
-			if (protoConstructor && typeof protoConstructor.name === "string") {
-				// Allow objects with named constructors (records, named objects)
-				// This includes user-defined classes and built-in objects
-				// that CBOR can serialize with tag 27 or record tags
-			}
-		}
-
-		// Check all properties recursively
-		for (const key in value) {
-			const propPath = currentPath ? `${currentPath}.${key}` : key;
-			if (
-				!isCborSerializable(
-					value[key as keyof typeof value],
-					onInvalid,
-					propPath,
-				)
-			) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	// Not serializable
-	onInvalid?.(currentPath);
-	return false;
-}
 
 export interface DeconstructedError {
 	__type: "ActorError";

package/src/drivers/engine/actor-driver.ts

@@ -284,7 +284,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().debug({
 					msg: "actor crash cleanup errored",
 					actorId,
-					err: stringifyError(err),
+					error: stringifyError(err),
 				});
 			}
 		}
@@ -1357,7 +1357,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().warn({
 					msg: "failed to rebind dynamic hibernatable runner websocket",
 					actorId,
-					err: stringifyError(result.reason),
+					error: stringifyError(result.reason),
 				});
 			}
 		}
@@ -1380,7 +1380,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().warn({
 					msg: "failed to rebind hibernatable connect socket",
 					actorId,
-					err: stringifyError(result.reason),
+					error: stringifyError(result.reason),
 				});
 			}
 		}
@@ -1640,7 +1640,7 @@ export class EngineActorDriver implements ActorDriver {
 					logger().warn({
 						msg: "failed to restore dynamic hibernating requests after actor start",
 						actorId,
-						err: stringifyError(error),
+						error: stringifyError(error),
 					});
 				}
 			} else if (isStaticActorDefinition(definition)) {
@@ -1707,7 +1707,7 @@ export class EngineActorDriver implements ActorDriver {
 					logger().debug({
 						msg: "failed to dispose dynamic runtime after actor start failure",
 						actorId,
-						err: stringifyError(disposeError),
+						error: stringifyError(disposeError),
 					});
 				}
 				this.#dynamicRuntimes.delete(actorId);
@@ -1730,7 +1730,7 @@ export class EngineActorDriver implements ActorDriver {
 				actorId,
 				name,
 				key,
-				err: stringifyError(error),
+				error: stringifyError(error),
 			});
 
 			try {
@@ -1739,7 +1739,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().debug({
 					msg: "failed to stop actor after start failure",
 					actorId,
-					err: stringifyError(stopError),
+					error: stringifyError(stopError),
 				});
 			}
 		}
@@ -1786,7 +1786,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().debug({
 					msg: "actor start failed during stop, cleaning up handler",
 					actorId,
-					err: stringifyError(err),
+					error: stringifyError(err),
 				});
 			}
 		}
@@ -1804,7 +1804,7 @@ export class EngineActorDriver implements ActorDriver {
 			} catch (err) {
 				logger().error({
 					msg: "error in onStop, proceeding with removing actor",
-					err: stringifyError(err),
+					error: stringifyError(err),
 				});
 			}
 		}
@@ -1989,8 +1989,8 @@ export class EngineActorDriver implements ActorDriver {
 				isHibernatable,
 				isRestoringHibernatable,
 			);
-		} catch (err) {
-			logger().error({ msg: "building websocket handlers errored", err });
+		} catch (error) {
+			logger().error({ msg: "building websocket handlers errored", error });
 			websocketRaw.close(1011, "ws.route_error");
 			return;
 		}

package/src/engine-client/actor-websocket-client.ts

@@ -16,6 +16,7 @@ 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 type { JsonCompatValue } from "@/common/encoding";
 import { encodeCborCompat, uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath } from "@/utils";
 import { shouldSkipReadyWait, type GatewayRequestOptions } from "./driver";
@@ -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/mod.ts

@@ -23,6 +23,7 @@ import type {
 	RuntimeDisplayInformation,
 } from "@/engine-client/driver";
 import type { Encoding, UniversalWebSocket } from "@/mod";
+import type { JsonCompatValue } from "@/common/encoding";
 import { encodeCborCompat, uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath, type GetUpgradeWebSocket } from "@/utils";
 import { getNextPhase } from "@/utils/env-vars";
@@ -181,7 +182,7 @@ 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 +216,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",
 		});