rivetkit 2.0.5 → 2.0.7-rc.1

package/src/actor/router.ts

@@ -10,17 +10,26 @@ import {
 	type ConnectWebSocketOpts,
 	type ConnectWebSocketOutput,
 	type ConnsMessageOpts,
-	HEADER_AUTH_DATA,
-	HEADER_CONN_ID,
-	HEADER_CONN_PARAMS,
-	HEADER_CONN_TOKEN,
-	HEADER_ENCODING,
 	handleAction,
+	handleConnectionClose,
 	handleConnectionMessage,
 	handleRawWebSocketHandler,
 	handleSseConnect,
 	handleWebSocketConnect,
 } from "@/actor/router-endpoints";
+import {
+	HEADER_CONN_ID,
+	HEADER_CONN_PARAMS,
+	HEADER_CONN_TOKEN,
+	HEADER_ENCODING,
+	PATH_CONNECT_WEBSOCKET,
+	PATH_RAW_WEBSOCKET_PREFIX,
+	WS_PROTOCOL_CONN_ID,
+	WS_PROTOCOL_CONN_PARAMS,
+	WS_PROTOCOL_CONN_TOKEN,
+	WS_PROTOCOL_ENCODING,
+	WS_PROTOCOL_TOKEN,
+} from "@/common/actor-router-consts";
 import {
 	handleRouteError,
 	handleRouteNotFound,
@@ -31,15 +40,13 @@ import {
 	type ActorInspectorRouterEnv,
 	createActorInspectorRouter,
 } from "@/inspector/actor";
-import { secureInspector } from "@/inspector/utils";
+import { isInspectorEnabled, secureInspector } from "@/inspector/utils";
 import type { RunConfig } from "@/registry/run-config";
+import { ConnDriverKind } from "./conn-drivers";
 import type { ActorDriver } from "./driver";
 import { InternalError } from "./errors";
 import { loggerWithoutContext } from "./log";
 
-export const PATH_CONNECT_WEBSOCKET = "/connect/websocket";
-export const PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
-
 export type {
 	ConnectWebSocketOpts,
 	ConnectWebSocketOutput,
@@ -77,19 +84,70 @@ export function createActorRouter(
 		return c.text("ok");
 	});
 
+	// Test endpoint to force disconnect a connection non-cleanly
+	router.post("/.test/force-disconnect", async (c) => {
+		const connId = c.req.query("conn");
+
+		if (!connId) {
+			return c.text("Missing conn query parameter", 400);
+		}
+
+		const actor = await actorDriver.loadActor(c.env.actorId);
+		const conn = actor.__getConnForId(connId);
+
+		if (!conn) {
+			return c.text(`Connection not found: ${connId}`, 404);
+		}
+
+		// Force close the websocket/SSE connection without clean shutdown
+		const driverState = conn.__driverState;
+		if (driverState && ConnDriverKind.WEBSOCKET in driverState) {
+			const ws = driverState[ConnDriverKind.WEBSOCKET].websocket;
+
+			// Force close without sending close frame
+			(ws.raw as any).terminate();
+		} else if (driverState && ConnDriverKind.SSE in driverState) {
+			const stream = driverState[ConnDriverKind.SSE].stream;
+
+			// Force close the SSE stream
+			stream.abort();
+		}
+
+		return c.json({ success: true });
+	});
+
 	router.get(PATH_CONNECT_WEBSOCKET, async (c) => {
 		const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
 		if (upgradeWebSocket) {
 			return upgradeWebSocket(async (c) => {
-				const encodingRaw = c.req.header(HEADER_ENCODING);
-				const connParamsRaw = c.req.header(HEADER_CONN_PARAMS);
-				const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+				// Parse configuration from Sec-WebSocket-Protocol header
+				const protocols = c.req.header("sec-websocket-protocol");
+				let encodingRaw: string | undefined;
+				let connParamsRaw: string | undefined;
+				let connIdRaw: string | undefined;
+				let connTokenRaw: string | undefined;
+
+				if (protocols) {
+					const protocolList = protocols.split(",").map((p) => p.trim());
+					for (const protocol of protocolList) {
+						if (protocol.startsWith(WS_PROTOCOL_ENCODING)) {
+							encodingRaw = protocol.substring(WS_PROTOCOL_ENCODING.length);
+						} else if (protocol.startsWith(WS_PROTOCOL_CONN_PARAMS)) {
+							connParamsRaw = decodeURIComponent(
+								protocol.substring(WS_PROTOCOL_CONN_PARAMS.length),
+							);
+						} else if (protocol.startsWith(WS_PROTOCOL_CONN_ID)) {
+							connIdRaw = protocol.substring(WS_PROTOCOL_CONN_ID.length);
+						} else if (protocol.startsWith(WS_PROTOCOL_CONN_TOKEN)) {
+							connTokenRaw = protocol.substring(WS_PROTOCOL_CONN_TOKEN.length);
+						}
+					}
+				}
 
 				const encoding = EncodingSchema.parse(encodingRaw);
 				const connParams = connParamsRaw
 					? JSON.parse(connParamsRaw)
 					: undefined;
-				const authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;
 
 				return await handleWebSocketConnect(
 					c.req.raw,
@@ -98,7 +156,8 @@ export function createActorRouter(
 					c.env.actorId,
 					encoding,
 					connParams,
-					authData,
+					connIdRaw,
+					connTokenRaw,
 				);
 			})(c, noopNext());
 		} else {
@@ -110,41 +169,38 @@ export function createActorRouter(
 	});
 
 	router.get("/connect/sse", async (c) => {
-		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-		let authData: unknown;
-		if (authDataRaw) {
-			authData = JSON.parse(authDataRaw);
-		}
-
-		return handleSseConnect(c, runConfig, actorDriver, c.env.actorId, authData);
+		return handleSseConnect(c, runConfig, actorDriver, c.env.actorId);
 	});
 
 	router.post("/action/:action", async (c) => {
 		const actionName = c.req.param("action");
 
-		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-		let authData: unknown;
-		if (authDataRaw) {
-			authData = JSON.parse(authDataRaw);
-		}
+		return handleAction(c, runConfig, actorDriver, actionName, c.env.actorId);
+	});
 
-		return handleAction(
+	router.post("/connections/message", async (c) => {
+		const connId = c.req.header(HEADER_CONN_ID);
+		const connToken = c.req.header(HEADER_CONN_TOKEN);
+		if (!connId || !connToken) {
+			throw new Error("Missing required parameters");
+		}
+		return handleConnectionMessage(
 			c,
 			runConfig,
 			actorDriver,
-			actionName,
+			connId,
+			connToken,
 			c.env.actorId,
-			authData,
 		);
 	});
 
-	router.post("/connections/message", async (c) => {
+	router.post("/connections/close", async (c) => {
 		const connId = c.req.header(HEADER_CONN_ID);
 		const connToken = c.req.header(HEADER_CONN_TOKEN);
 		if (!connId || !connToken) {
 			throw new Error("Missing required parameters");
 		}
-		return handleConnectionMessage(
+		return handleConnectionClose(
 			c,
 			runConfig,
 			actorDriver,
@@ -156,12 +212,6 @@ export function createActorRouter(
 
 	// Raw HTTP endpoints - /http/*
 	router.all("/raw/http/*", async (c) => {
-		const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-		let authData: unknown;
-		if (authDataRaw) {
-			authData = JSON.parse(authDataRaw);
-		}
-
 		const actor = await actorDriver.loadActor(c.env.actorId);
 
 		// TODO: This is not a clean way of doing this since `/http/` might exist mid-path
@@ -185,9 +235,7 @@ export function createActorRouter(
 		});
 
 		// Call the actor's onFetch handler - it will throw appropriate errors
-		const response = await actor.handleFetch(correctedRequest, {
-			auth: authData,
-		});
+		const response = await actor.handleFetch(correctedRequest, {});
 
 		// This should never happen now since handleFetch throws errors
 		if (!response) {
@@ -202,16 +250,6 @@ export function createActorRouter(
 		const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
 		if (upgradeWebSocket) {
 			return upgradeWebSocket(async (c) => {
-				const encodingRaw = c.req.header(HEADER_ENCODING);
-				const connParamsRaw = c.req.header(HEADER_CONN_PARAMS);
-				const authDataRaw = c.req.header(HEADER_AUTH_DATA);
-
-				const encoding = EncodingSchema.parse(encodingRaw);
-				const connParams = connParamsRaw
-					? JSON.parse(connParamsRaw)
-					: undefined;
-				const authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;
-
 				const url = new URL(c.req.url);
 				const pathWithQuery = c.req.path + url.search;
 
@@ -228,7 +266,6 @@ export function createActorRouter(
 					pathWithQuery,
 					actorDriver,
 					c.env.actorId,
-					authData,
 				);
 			})(c, noopNext());
 		} else {
@@ -239,7 +276,7 @@ export function createActorRouter(
 		}
 	});
 
-	if (runConfig.inspector.enabled) {
+	if (isInspectorEnabled(runConfig, "actor")) {
 		router.route(
 			"/inspect",
 			new Hono<ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }>()

package/src/actor/utils.ts

@@ -87,7 +87,11 @@ export class Lock<T> {
 export function generateSecureToken(length = 32) {
 	const array = new Uint8Array(length);
 	crypto.getRandomValues(array);
-	return btoa(String.fromCharCode(...array));
+	// Replace base64 chars that are not URL safe with URL-safe chars and strip padding
+	return btoa(String.fromCharCode(...array))
+		.replace(/\+/g, "-")
+		.replace(/\//g, "_")
+		.replace(/=/g, "");
 }
 
 export function generateRandomString(length = 32) {

package/src/client/actor-conn.ts

@@ -5,6 +5,13 @@ import type { CloseEvent } from "ws";
 import type { AnyActorDefinition } from "@/actor/definition";
 import { inputDataToBuffer } from "@/actor/protocol/old";
 import { type Encoding, jsonStringifyCompat } from "@/actor/protocol/serde";
+import {
+	HEADER_CONN_ID,
+	HEADER_CONN_PARAMS,
+	HEADER_CONN_TOKEN,
+	HEADER_ENCODING,
+	PATH_CONNECT_WEBSOCKET,
+} from "@/common/actor-router-consts";
 import { importEventSource } from "@/common/eventsource";
 import type {
 	UniversalErrorEvent,
@@ -12,15 +19,9 @@ import type {
 	UniversalMessageEvent,
 } from "@/common/eventsource-interface";
 import { assertUnreachable, stringifyError } from "@/common/utils";
-import {
-	HEADER_CONN_ID,
-	HEADER_CONN_PARAMS,
-	HEADER_CONN_TOKEN,
-	HEADER_ENCODING,
-	type ManagerDriver,
-} from "@/driver-helpers/mod";
+import type { UniversalWebSocket } from "@/common/websocket-interface";
+import type { ManagerDriver } from "@/driver-helpers/mod";
 import type { ActorQuery } from "@/manager/protocol/query";
-import { PATH_CONNECT_WEBSOCKET, type UniversalWebSocket } from "@/mod";
 import type * as protocol from "@/schemas/client-protocol/mod";
 import {
 	TO_CLIENT_VERSIONED,
@@ -31,7 +32,12 @@ import {
 	encodingIsBinary,
 	serializeWithEncoding,
 } from "@/serde";
-import { bufferToArrayBuffer, getEnvUniversal, httpUserAgent } from "@/utils";
+import {
+	bufferToArrayBuffer,
+	getEnvUniversal,
+	httpUserAgent,
+	promiseWithResolvers,
+} from "@/utils";
 import type { ActorDefinitionActions } from "./actor-common";
 import { queryActor } from "./actor-query";
 import { ACTOR_CONNS_SYMBOL, type ClientRaw, TRANSPORT_SYMBOL } from "./client";
@@ -93,7 +99,7 @@ export class ActorConnRaw {
 	/** If attempting to connect. Helpful for knowing if in a retry loop when reconnecting. */
 	#connecting = false;
 
-	// These will only be set on SSE driver
+	// Connection info, used for reconnection and HTTP requests
 	#actorId?: string;
 	#connectionId?: string;
 	#connectionToken?: string;
@@ -118,7 +124,7 @@ export class ActorConnRaw {
 	#keepNodeAliveInterval: NodeJS.Timeout;
 
 	/** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
-	#onOpenPromise?: PromiseWithResolvers<undefined>;
+	#onOpenPromise?: ReturnType<typeof promiseWithResolvers<undefined>>;
 
 	#client: ClientRaw;
 	#driver: ManagerDriver;
@@ -176,7 +182,7 @@ export class ActorConnRaw {
 		this.#actionIdCounter += 1;
 
 		const { promise, resolve, reject } =
-			Promise.withResolvers<protocol.ActionResponse>();
+			promiseWithResolvers<protocol.ActionResponse>();
 		this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
 
 		this.#sendMessage({
@@ -252,7 +258,7 @@ enc
 			// Create promise for open
 			if (this.#onOpenPromise)
 				throw new Error("#onOpenPromise already defined");
-			this.#onOpenPromise = Promise.withResolvers();
+			this.#onOpenPromise = promiseWithResolvers();
 
 			// Connect transport
 			if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
@@ -276,15 +282,37 @@ enc
 			this.#actorQuery,
 			this.#driver,
 		);
+
+		// Check if we have connection info for reconnection
+		const isReconnection = this.#connectionId && this.#connectionToken;
+		if (isReconnection) {
+			logger().debug({
+				msg: "attempting websocket reconnection",
+				connectionId: this.#connectionId,
+			});
+		}
+
 		const ws = await this.#driver.openWebSocket(
 			PATH_CONNECT_WEBSOCKET,
 			actorId,
 			this.#encoding,
 			this.#params,
+			// Pass connection ID and token for reconnection if available
+			isReconnection ? this.#connectionId : undefined,
+			isReconnection ? this.#connectionToken : undefined,
 		);
+		logger().debug({
+			msg: "transport set to new websocket",
+			connectionId: this.#connectionId,
+			readyState: ws.readyState,
+			messageQueueLength: this.#messageQueue.length,
+		});
 		this.#transport = { websocket: ws };
 		ws.addEventListener("open", () => {
-			logger().debug({ msg: "websocket open" });
+			logger().debug({
+				msg: "client websocket open",
+				connectionId: this.#connectionId,
+			});
 		});
 		ws.addEventListener("message", async (ev) => {
 			this.#handleOnMessage(ev.data);
@@ -315,6 +343,8 @@ enc
 			encoding: this.#encoding,
 		});
 
+		const isReconnection = this.#connectionId && this.#connectionToken;
+
 		const eventSource = new EventSource("http://actor/connect/sse", {
 			fetch: (input, init) => {
 				return this.#driver.sendRequest(
@@ -328,6 +358,12 @@ enc
 							...(this.#params !== undefined
 								? { [HEADER_CONN_PARAMS]: JSON.stringify(this.#params) }
 								: {}),
+							...(isReconnection
+								? {
+										[HEADER_CONN_ID]: this.#connectionId,
+										[HEADER_CONN_TOKEN]: this.#connectionToken,
+									}
+								: {}),
 						},
 					}),
 				);
@@ -337,6 +373,9 @@ enc
 		this.#transport = { sse: eventSource };
 
 		eventSource.addEventListener("message", (ev: UniversalMessageEvent) => {
+			// Ignore pings
+			if (ev.type === "ping") return;
+
 			this.#handleOnMessage(ev.data);
 		});
 
@@ -350,6 +389,7 @@ enc
 		logger().debug({
 			msg: "socket open",
 			messageQueueLength: this.#messageQueue.length,
+			connectionId: this.#connectionId,
 		});
 
 		// Resolve open promise
@@ -369,6 +409,10 @@ enc
 		// If the message fails to send, the message will be re-queued
 		const queue = this.#messageQueue;
 		this.#messageQueue = [];
+		logger().debug({
+			msg: "flushing message queue",
+			queueLength: queue.length,
+		});
 		for (const msg of queue) {
 			this.#sendMessage(msg);
 		}
@@ -394,7 +438,7 @@ enc
 		);
 
 		if (response.body.tag === "Init") {
-			// This is only called for SSE
+			// Store connection info for reconnection
 			this.#actorId = response.body.val.actorId;
 			this.#connectionId = response.body.val.connectionId;
 			this.#connectionToken = response.body.val.connectionToken;
@@ -490,26 +534,46 @@ enc
 		//
 		// These properties will be undefined
 		const closeEvent = event as CloseEvent;
-		if (closeEvent.wasClean) {
-			logger().info({
-				msg: "socket closed",
-				code: closeEvent.code,
-				reason: closeEvent.reason,
-				wasClean: closeEvent.wasClean,
-			});
-		} else {
-			logger().warn({
-				msg: "socket closed",
-				code: closeEvent.code,
-				reason: closeEvent.reason,
-				wasClean: closeEvent.wasClean,
+		const wasClean = closeEvent.wasClean;
+
+		logger().info({
+			msg: "socket closed",
+			code: closeEvent.code,
+			reason: closeEvent.reason,
+			wasClean: wasClean,
+			connectionId: this.#connectionId,
+			messageQueueLength: this.#messageQueue.length,
+			actionsInFlight: this.#actionsInFlight.size,
+		});
+
+		// Reject all in-flight actions
+		if (this.#actionsInFlight.size > 0) {
+			logger().debug({
+				msg: "rejecting in-flight actions after disconnect",
+				count: this.#actionsInFlight.size,
+				connectionId: this.#connectionId,
+				wasClean,
 			});
+
+			const disconnectError = new Error(
+				wasClean ? "Connection closed" : "Connection lost",
+			);
+
+			for (const actionInfo of this.#actionsInFlight.values()) {
+				actionInfo.reject(disconnectError);
+			}
+			this.#actionsInFlight.clear();
 		}
 
 		this.#transport = undefined;
 
 		// Automatically reconnect. Skip if already attempting to connect.
 		if (!this.#disposed && !this.#connecting) {
+			logger().debug({
+				msg: "triggering reconnect",
+				connectionId: this.#connectionId,
+				messageQueueLength: this.#messageQueue.length,
+			});
 			// TODO: Fetch actor to check if it's destroyed
 			// TODO: Add backoff for reconnect
 			// TODO: Add a way of preserving connection ID for connection state
@@ -659,9 +723,26 @@ enc
 		let queueMessage = false;
 		if (!this.#transport) {
 			// No transport connected yet
+			logger().debug({ msg: "no transport, queueing message" });
 			queueMessage = true;
 		} else if ("websocket" in this.#transport) {
-			if (this.#transport.websocket.readyState === 1) {
+			const readyState = this.#transport.websocket.readyState;
+			logger().debug({
+				msg: "websocket send attempt",
+				readyState,
+				readyStateString:
+					readyState === 0
+						? "CONNECTING"
+						: readyState === 1
+							? "OPEN"
+							: readyState === 2
+								? "CLOSING"
+								: "CLOSED",
+				connectionId: this.#connectionId,
+				messageType: (message.body as any).tag,
+				actionName: (message.body as any).val?.name,
+			});
+			if (readyState === 1) {
 				try {
 					const messageSerialized = serializeWithEncoding(
 						this.#encoding,
@@ -677,12 +758,17 @@ enc
 					logger().warn({
 						msg: "failed to send message, added to queue",
 						error,
+						connectionId: this.#connectionId,
 					});
 
 					// Assuming the socket is disconnected and will be reconnected soon
 					queueMessage = true;
 				}
 			} else {
+				logger().debug({
+					msg: "websocket not open, queueing message",
+					readyState,
+				});
 				queueMessage = true;
 			}
 		} else if ("sse" in this.#transport) {
@@ -698,7 +784,13 @@ enc
 
 		if (!opts?.ephemeral && queueMessage) {
 			this.#messageQueue.push(message);
-			logger().debug({ msg: "queued connection message" });
+			logger().debug({
+				msg: "queued connection message",
+				queueLength: this.#messageQueue.length,
+				connectionId: this.#connectionId,
+				messageType: (message.body as any).tag,
+				actionName: (message.body as any).val?.name,
+			});
 		}
 	}
 
@@ -777,6 +869,22 @@ enc
 		return deserializeWithEncoding(this.#encoding, buffer, TO_CLIENT_VERSIONED);
 	}
 
+	/**
+	 * Get the actor ID (for testing purposes).
+	 * @internal
+	 */
+	get actorId(): string | undefined {
+		return this.#actorId;
+	}
+
+	/**
+	 * Get the connection ID (for testing purposes).
+	 * @internal
+	 */
+	get connectionId(): string | undefined {
+		return this.#connectionId;
+	}
+
 	/**
 	 * Disconnects from the actor.
 	 *
@@ -814,7 +922,7 @@ enc
 			) {
 				logger().debug({ msg: "ws already closed or closing" });
 			} else {
-				const { promise, resolve } = Promise.withResolvers();
+				const { promise, resolve } = promiseWithResolvers();
 				ws.addEventListener("close", () => {
 					logger().debug({ msg: "ws closed" });
 					resolve(undefined);
@@ -823,6 +931,30 @@ enc
 				await promise;
 			}
 		} else if ("sse" in this.#transport) {
+			// Send close request to server for SSE connections
+			if (this.#connectionId && this.#connectionToken) {
+				try {
+					await sendHttpRequest({
+						url: "http://actor/connections/close",
+						method: "POST",
+						headers: {
+							[HEADER_CONN_ID]: this.#connectionId,
+							[HEADER_CONN_TOKEN]: this.#connectionToken,
+						},
+						encoding: this.#encoding,
+						skipParseResponse: true,
+						customFetch: this.#driver.sendRequest.bind(
+							this.#driver,
+							this.#actorId!,
+						),
+						requestVersionedDataHandler: TO_SERVER_VERSIONED,
+						responseVersionedDataHandler: TO_CLIENT_VERSIONED,
+					});
+				} catch (error) {
+					// Ignore errors when closing - connection may already be closed
+					logger().warn({ msg: "failed to send close request", error });
+				}
+			}
 			this.#transport.sse.close();
 		} else {
 			assertUnreachable(this.#transport);

package/src/client/actor-handle.ts

@@ -4,7 +4,6 @@ import type { AnyActorDefinition } from "@/actor/definition";
 import type { Encoding } from "@/actor/protocol/serde";
 import { assertUnreachable } from "@/actor/utils";
 import { deconstructError } from "@/common/utils";
-import { importWebSocket } from "@/common/websocket";
 import {
 	HEADER_CONN_PARAMS,
 	HEADER_ENCODING,

package/src/client/client.ts

@@ -3,7 +3,7 @@ import type { Transport } from "@/actor/protocol/old";
 import type { Encoding } from "@/actor/protocol/serde";
 import type { ManagerDriver } from "@/driver-helpers/mod";
 import type { ActorQuery } from "@/manager/protocol/query";
-import type { Registry } from "@/mod";
+import type { Registry } from "@/registry/mod";
 import type { ActorActionFunction } from "./actor-common";
 import {
 	type ActorConn,
@@ -491,7 +491,7 @@ function createActorProxy<AD extends AnyActorDefinition>(
 
 			// Handle built-in Promise methods and existing properties
 			if (prop === "constructor" || prop in target) {
-				const value = Reflect.get(target, prop, receiver);
+				const value = Reflect.get(target, prop, target);
 				// Preserve method binding
 				if (typeof value === "function") {
 					return value.bind(target);

package/src/client/config.ts

@@ -14,6 +14,13 @@ export const ClientConfigSchema = z.object({
 		})
 		.default({}),
 
+	token: z
+		.string()
+		.optional()
+		.transform((x) => x ?? getEnvUniversal("RIVET_TOKEN")),
+
+	headers: z.record(z.string()).optional().default({}),
+
 	/** Endpoint to connect to the Rivet engine. Can be configured via RIVET_ENGINE env var. */
 	endpoint: z
 		.string()

package/src/client/raw-utils.ts

@@ -1,5 +1,5 @@
 import invariant from "invariant";
-import { PATH_RAW_WEBSOCKET_PREFIX } from "@/actor/router";
+import { PATH_RAW_WEBSOCKET_PREFIX } from "@/common/actor-router-consts";
 import { deconstructError } from "@/common/utils";
 import { HEADER_CONN_PARAMS, type ManagerDriver } from "@/driver-helpers/mod";
 import type { ActorQuery } from "@/manager/protocol/query";

package/src/client/utils.ts

@@ -1,8 +1,8 @@
 import * as cbor from "cbor-x";
 import invariant from "invariant";
+import type { Encoding } from "@/actor/protocol/serde";
 import { assertUnreachable } from "@/common/utils";
 import type { VersionedDataHandler } from "@/common/versioned-data";
-import type { Encoding } from "@/mod";
 import type { HttpResponseError } from "@/schemas/client-protocol/mod";
 import { HTTP_RESPONSE_ERROR_VERSIONED } from "@/schemas/client-protocol/versioned";
 import {