rivetkit 2.3.0-rc.7 → 2.3.0-rc.9

package/src/common/encoding.ts

@@ -13,171 +13,6 @@ 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"]);
 
@@ -277,95 +112,38 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
 	return proto === Object.prototype || proto === null;
 }
 
-export function encodeJsonCompatValue(input: JsonCompatValue): unknown {
-	// Primitives
-	if (input === null) {
-		return input;
-	}
+export function encodeJsonCompatValue(input: any): any {
 	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 as JsonCompatValue),
-		);
+		const encoded = input.map((value) => encodeJsonCompatValue(value));
 		if (
 			encoded.length === 2 &&
 			typeof encoded[0] === "string" &&
-			(encoded[0] as string).startsWith("$")
+			encoded[0].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 as JsonCompatValue);
+			encoded[key] = encodeJsonCompatValue(value);
 		}
 		return encoded;
 	}
-
-	// 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`,
-	);
+	return input;
 }
 
 export interface JsonCompatReviveOptions {
@@ -386,16 +164,6 @@ 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 &&
@@ -414,12 +182,6 @@ 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(error: unknown): void {
-		console.error("INLINE_WEBSOCKET_ADAPTER_ERROR", error);
+	#handleError(err: unknown): void {
+		console.error("INLINE_WEBSOCKET_ADAPTER_ERROR", err);
 		logger().error({
 			msg: "error in websocket",
-			error,
-			errorMessage: error instanceof Error ? error.message : String(error),
-			stack: error instanceof Error ? error.stack : undefined,
+			error: err,
+			errorMessage: err instanceof Error ? err.message : String(err),
+			stack: err instanceof Error ? err.stack : undefined,
 		});
 
 		// Call handler.onError
 		try {
-			this.#handler.onError(error, this.#wsContext);
-		} catch (error) {
+			this.#handler.onError(err, this.#wsContext);
+		} catch (handlerErr) {
 			logger().error({
 				msg: "error in onError handler",
-				error,
+				error: handlerErr,
 			});
 		}
 
 		// Fire error event to both sides
-		this.#clientWs.triggerError(error);
-		this.#actorWs.triggerError(error);
+		this.#clientWs.triggerError(err);
+		this.#actorWs.triggerError(err);
 	}
 
 	#close(code: number, reason: string): void {
@@ -199,8 +199,8 @@ export class InlineWebSocketAdapter {
 				{ code, reason, wasClean: true },
 				this.#wsContext,
 			);
-		} catch (error) {
-			logger().error({ msg: "error closing websocket", error });
+		} catch (err) {
+			logger().error({ msg: "error closing websocket", error: err });
 		} finally {
 			this.#readyState = 3; // CLOSED
 

package/src/common/log.ts

@@ -76,7 +76,6 @@ 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 { JsonCompatValue, Encoding } from "@/common/encoding";
+import type { 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 as JsonCompatValue))
+				? bufferToArrayBuffer(encodeCborCompat(value.metadata))
 				: null,
 			actor: value.actor
 				? {

package/src/common/utils.ts

@@ -36,6 +36,154 @@ 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,
-					error: stringifyError(err),
+					err: stringifyError(err),
 				});
 			}
 		}
@@ -1357,7 +1357,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().warn({
 					msg: "failed to rebind dynamic hibernatable runner websocket",
 					actorId,
-					error: stringifyError(result.reason),
+					err: stringifyError(result.reason),
 				});
 			}
 		}
@@ -1380,7 +1380,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().warn({
 					msg: "failed to rebind hibernatable connect socket",
 					actorId,
-					error: stringifyError(result.reason),
+					err: 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,
-						error: stringifyError(error),
+						err: 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,
-						error: stringifyError(disposeError),
+						err: stringifyError(disposeError),
 					});
 				}
 				this.#dynamicRuntimes.delete(actorId);
@@ -1730,7 +1730,7 @@ export class EngineActorDriver implements ActorDriver {
 				actorId,
 				name,
 				key,
-				error: stringifyError(error),
+				err: stringifyError(error),
 			});
 
 			try {
@@ -1739,7 +1739,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().debug({
 					msg: "failed to stop actor after start failure",
 					actorId,
-					error: stringifyError(stopError),
+					err: stringifyError(stopError),
 				});
 			}
 		}
@@ -1786,7 +1786,7 @@ export class EngineActorDriver implements ActorDriver {
 				logger().debug({
 					msg: "actor start failed during stop, cleaning up handler",
 					actorId,
-					error: stringifyError(err),
+					err: stringifyError(err),
 				});
 			}
 		}
@@ -1804,7 +1804,7 @@ export class EngineActorDriver implements ActorDriver {
 			} catch (err) {
 				logger().error({
 					msg: "error in onStop, proceeding with removing actor",
-					error: stringifyError(err),
+					err: stringifyError(err),
 				});
 			}
 		}
@@ -1989,8 +1989,8 @@ export class EngineActorDriver implements ActorDriver {
 				isHibernatable,
 				isRestoringHibernatable,
 			);
-		} catch (error) {
-			logger().error({ msg: "building websocket handlers errored", error });
+		} catch (err) {
+			logger().error({ msg: "building websocket handlers errored", err });
 			websocketRaw.close(1011, "ws.route_error");
 			return;
 		}

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

@@ -16,7 +16,6 @@ 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";
@@ -303,7 +302,7 @@ function pushInputQueryParam(
 		return;
 	}
 
-	const encodedInput = encodeCborCompat(input as JsonCompatValue);
+	const encodedInput = encodeCborCompat(input);
 	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,7 +23,6 @@ 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";
@@ -182,7 +181,7 @@ export class RemoteEngineControlClient implements EngineControlClient {
 			key: serializeActorKey(key),
 			runner_name_selector: this.#config.poolName,
 			input: actorInput
-				? uint8ArrayToBase64(encodeCborCompat(actorInput as JsonCompatValue))
+				? uint8ArrayToBase64(encodeCborCompat(actorInput))
 				: undefined,
 			crash_policy: crashPolicy ?? "sleep",
 		});
@@ -216,7 +215,7 @@ export class RemoteEngineControlClient implements EngineControlClient {
 			runner_name_selector: this.#config.poolName,
 			key: serializeActorKey(key),
 			input: input
-				? uint8ArrayToBase64(encodeCborCompat(input as JsonCompatValue))
+				? uint8ArrayToBase64(encodeCborCompat(input))
 				: undefined,
 			crash_policy: crashPolicy ?? "sleep",
 		});