rivetkit 2.0.6 → 2.0.7

package/dist/tsup/utils.cjs

@@ -10,7 +10,8 @@
 
 
 
-var _chunk5JBFVV4Ccjs = require('./chunk-5JBFVV4C.cjs');
+
+var _chunkLXAVET4Acjs = require('./chunk-LXAVET4A.cjs');
 require('./chunk-5QGQK44L.cjs');
 
 
@@ -24,5 +25,6 @@ require('./chunk-5QGQK44L.cjs');
 
 
 
-exports.SinglePromiseQueue = _chunk5JBFVV4Ccjs.SinglePromiseQueue; exports.VERSION = _chunk5JBFVV4Ccjs.VERSION; exports.assertUnreachable = _chunk5JBFVV4Ccjs.assertUnreachable; exports.bufferToArrayBuffer = _chunk5JBFVV4Ccjs.bufferToArrayBuffer; exports.combineUrlPath = _chunk5JBFVV4Ccjs.combineUrlPath; exports.dbg = _chunk5JBFVV4Ccjs.dbg; exports.getEnvUniversal = _chunk5JBFVV4Ccjs.getEnvUniversal; exports.httpUserAgent = _chunk5JBFVV4Ccjs.httpUserAgent; exports.setLongTimeout = _chunk5JBFVV4Ccjs.setLongTimeout; exports.stringifyError = _chunk5JBFVV4Ccjs.stringifyError; exports.toUint8Array = _chunk5JBFVV4Ccjs.toUint8Array;
+
+exports.SinglePromiseQueue = _chunkLXAVET4Acjs.SinglePromiseQueue; exports.VERSION = _chunkLXAVET4Acjs.VERSION; exports.assertUnreachable = _chunkLXAVET4Acjs.assertUnreachable; exports.bufferToArrayBuffer = _chunkLXAVET4Acjs.bufferToArrayBuffer; exports.combineUrlPath = _chunkLXAVET4Acjs.combineUrlPath; exports.dbg = _chunkLXAVET4Acjs.dbg; exports.getEnvUniversal = _chunkLXAVET4Acjs.getEnvUniversal; exports.httpUserAgent = _chunkLXAVET4Acjs.httpUserAgent; exports.promiseWithResolvers = _chunkLXAVET4Acjs.promiseWithResolvers; exports.setLongTimeout = _chunkLXAVET4Acjs.setLongTimeout; exports.stringifyError = _chunkLXAVET4Acjs.stringifyError; exports.toUint8Array = _chunkLXAVET4Acjs.toUint8Array;
 //# sourceMappingURL=utils.cjs.map

package/dist/tsup/utils.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/utils.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wnBAAC","file":"/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/utils.cjs"}
+{"version":3,"sources":["/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/utils.cjs"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B,gCAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,+rBAAC","file":"/Users/nathan/rivetkit/packages/rivetkit/dist/tsup/utils.cjs"}

package/dist/tsup/utils.d.cts

@@ -18,6 +18,16 @@ declare function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array;
 type LongTimeoutHandle = {
     abort: () => void;
 };
+/**
+ * Polyfill for Promise.withResolvers().
+ *
+ * This is specifically for Cloudflare Workers. Their implementation of Promise.withResolvers does not work correctly.
+ */
+declare function promiseWithResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
 declare function setLongTimeout(listener: () => void, after: number): LongTimeoutHandle;
 /**
  * A tiny utility that coalesces/enqueues async operations so only the latest
@@ -50,4 +60,4 @@ declare function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer;
  */
 declare function combineUrlPath(endpoint: string, path: string, queryParams?: Record<string, string | undefined>): string;
 
-export { type LongTimeoutHandle, SinglePromiseQueue, type UpgradeWebSocket, VERSION, bufferToArrayBuffer, combineUrlPath, dbg, getEnvUniversal, httpUserAgent, setLongTimeout, toUint8Array };
+export { type LongTimeoutHandle, SinglePromiseQueue, type UpgradeWebSocket, VERSION, bufferToArrayBuffer, combineUrlPath, dbg, getEnvUniversal, httpUserAgent, promiseWithResolvers, setLongTimeout, toUint8Array };

package/dist/tsup/utils.d.ts

@@ -18,6 +18,16 @@ declare function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array;
 type LongTimeoutHandle = {
     abort: () => void;
 };
+/**
+ * Polyfill for Promise.withResolvers().
+ *
+ * This is specifically for Cloudflare Workers. Their implementation of Promise.withResolvers does not work correctly.
+ */
+declare function promiseWithResolvers<T>(): {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};
 declare function setLongTimeout(listener: () => void, after: number): LongTimeoutHandle;
 /**
  * A tiny utility that coalesces/enqueues async operations so only the latest
@@ -50,4 +60,4 @@ declare function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer;
  */
 declare function combineUrlPath(endpoint: string, path: string, queryParams?: Record<string, string | undefined>): string;
 
-export { type LongTimeoutHandle, SinglePromiseQueue, type UpgradeWebSocket, VERSION, bufferToArrayBuffer, combineUrlPath, dbg, getEnvUniversal, httpUserAgent, setLongTimeout, toUint8Array };
+export { type LongTimeoutHandle, SinglePromiseQueue, type UpgradeWebSocket, VERSION, bufferToArrayBuffer, combineUrlPath, dbg, getEnvUniversal, httpUserAgent, promiseWithResolvers, setLongTimeout, toUint8Array };

package/dist/tsup/utils.js

@@ -7,10 +7,11 @@ import {
   dbg,
   getEnvUniversal,
   httpUserAgent,
+  promiseWithResolvers,
   setLongTimeout,
   stringifyError,
   toUint8Array
-} from "./chunk-RGQR2J7S.js";
+} from "./chunk-RLBM6D4L.js";
 import "./chunk-YPZFLUO6.js";
 export {
   SinglePromiseQueue,
@@ -21,6 +22,7 @@ export {
   dbg,
   getEnvUniversal,
   httpUserAgent,
+  promiseWithResolvers,
   setLongTimeout,
   stringifyError,
   toUint8Array

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rivetkit",
-  "version": "2.0.6",
+  "version": "2.0.7",
   "description": "Lightweight libraries for building stateful actors on edge platforms",
   "license": "Apache-2.0",
   "keywords": [
@@ -147,12 +147,15 @@
   "engines": {
     "node": ">=22.0.0"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./dist/tsup/chunk-*.js",
+    "./dist/tsup/chunk-*.cjs"
+  ],
   "dependencies": {
     "@bare-ts/lib": "~0.3.0",
     "@hono/standard-validator": "^0.1.3",
     "@hono/zod-openapi": "^0.19.10",
-    "@rivetkit/engine-runner": "https://pkg.pr.new/rivet-dev/engine/@rivetkit/engine-runner@b72b232",
+    "@rivetkit/engine-runner": "https://pkg.pr.new/rivet-dev/engine/@rivetkit/engine-runner@3002",
     "@rivetkit/fast-json-patch": "^3.1.2",
     "cbor-x": "^1.6.0",
     "hono": "^4.7.0",
@@ -177,7 +180,8 @@
     "tsx": "^4.19.4",
     "typescript": "^5.7.3",
     "vitest": "^3.1.1",
-    "ws": "^8.18.1"
+    "ws": "^8.18.1",
+    "bufferutil": "^4.0.9"
   },
   "peerDependencies": {
     "@hono/node-server": "^1.14.0",

package/src/actor/action.ts

@@ -2,7 +2,7 @@ import type { ActorKey } from "@/actor/mod";
 import type { Client } from "@/client/client";
 import type { Logger } from "@/common/log";
 import type { Registry } from "@/registry/mod";
-import type { Conn, ConnId } from "./connection";
+import type { Conn, ConnId } from "./conn";
 import type { ActorContext } from "./context";
 import type { AnyDatabaseProvider, InferDatabaseClient } from "./database";
 import type { SaveStateOptions } from "./instance";

package/src/actor/config.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import type { UniversalWebSocket } from "@/common/websocket-interface";
 import type { ActionContext } from "./action";
-import type { Conn } from "./connection";
+import type { Conn } from "./conn";
 import type { ActorContext } from "./context";
 import type { AnyDatabaseProvider } from "./database";
 

package/src/actor/conn-drivers.ts

@@ -0,0 +1,205 @@
+import type { SSEStreamingApi } from "hono/streaming";
+import type { WSContext } from "hono/ws";
+import type { WebSocket } from "ws";
+import type { AnyConn } from "@/actor/conn";
+import type { AnyActorInstance } from "@/actor/instance";
+import type { CachedSerializer, Encoding } from "@/actor/protocol/serde";
+import { encodeDataToString } from "@/actor/protocol/serde";
+import type * as protocol from "@/schemas/client-protocol/mod";
+import { assertUnreachable, type promiseWithResolvers } from "@/utils";
+
+export enum ConnDriverKind {
+	WEBSOCKET = 0,
+	SSE = 1,
+	HTTP = 2,
+}
+
+export enum ConnReadyState {
+	UNKNOWN = -1,
+	CONNECTING = 0,
+	OPEN = 1,
+	CLOSING = 2,
+	CLOSED = 3,
+}
+
+export interface ConnDriverWebSocketState {
+	encoding: Encoding;
+	websocket: WSContext;
+	closePromise: ReturnType<typeof promiseWithResolvers<void>>;
+}
+
+export interface ConnDriverSseState {
+	encoding: Encoding;
+	stream: SSEStreamingApi;
+}
+
+export type ConnDriverHttpState = Record<never, never>;
+
+export type ConnDriverState =
+	| { [ConnDriverKind.WEBSOCKET]: ConnDriverWebSocketState }
+	| { [ConnDriverKind.SSE]: ConnDriverSseState }
+	| { [ConnDriverKind.HTTP]: ConnDriverHttpState };
+
+export interface ConnDriver<State> {
+	sendMessage?(
+		actor: AnyActorInstance,
+		conn: AnyConn,
+		state: State,
+		message: CachedSerializer<protocol.ToClient>,
+	): void;
+
+	/**
+	 * This returns a promise since we commonly disconnect at the end of a program, and not waiting will cause the socket to not close cleanly.
+	 */
+	disconnect(
+		actor: AnyActorInstance,
+		conn: AnyConn,
+		state: State,
+		reason?: string,
+	): Promise<void>;
+
+	/**
+	 * Returns the ready state of the connection.
+	 * This is used to determine if the connection is ready to send messages, or if the connection is stale.
+	 */
+	getConnectionReadyState(
+		actor: AnyActorInstance,
+		conn: AnyConn,
+		state: State,
+	): ConnReadyState | undefined;
+}
+
+// MARK: WebSocket
+const WEBSOCKET_DRIVER: ConnDriver<ConnDriverWebSocketState> = {
+	sendMessage: (
+		actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverWebSocketState,
+		message: CachedSerializer<protocol.ToClient>,
+	) => {
+		const serialized = message.serialize(state.encoding);
+
+		actor.rLog.debug({
+			msg: "sending websocket message",
+			encoding: state.encoding,
+			dataType: typeof serialized,
+			isUint8Array: serialized instanceof Uint8Array,
+			isArrayBuffer: serialized instanceof ArrayBuffer,
+			dataLength: (serialized as any).byteLength || (serialized as any).length,
+		});
+
+		// Convert Uint8Array to ArrayBuffer for proper transmission
+		if (serialized instanceof Uint8Array) {
+			const buffer = serialized.buffer.slice(
+				serialized.byteOffset,
+				serialized.byteOffset + serialized.byteLength,
+			);
+			// Handle SharedArrayBuffer case
+			if (buffer instanceof SharedArrayBuffer) {
+				const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+				new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+				actor.rLog.debug({
+					msg: "converted SharedArrayBuffer to ArrayBuffer",
+					byteLength: arrayBuffer.byteLength,
+				});
+				state.websocket.send(arrayBuffer);
+			} else {
+				actor.rLog.debug({
+					msg: "sending ArrayBuffer",
+					byteLength: buffer.byteLength,
+				});
+				state.websocket.send(buffer);
+			}
+		} else {
+			actor.rLog.debug({
+				msg: "sending string data",
+				length: (serialized as string).length,
+			});
+			state.websocket.send(serialized);
+		}
+	},
+
+	disconnect: async (
+		_actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverWebSocketState,
+		reason?: string,
+	) => {
+		// Close socket
+		state.websocket.close(1000, reason);
+
+		// Create promise to wait for socket to close gracefully
+		await state.closePromise.promise;
+	},
+
+	getConnectionReadyState: (
+		_actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverWebSocketState,
+	): ConnReadyState | undefined => {
+		return state.websocket.readyState;
+	},
+};
+
+// MARK: SSE
+const SSE_DRIVER: ConnDriver<ConnDriverSseState> = {
+	sendMessage: (
+		_actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverSseState,
+		message: CachedSerializer<protocol.ToClient>,
+	) => {
+		state.stream.writeSSE({
+			data: encodeDataToString(message.serialize(state.encoding)),
+		});
+	},
+
+	disconnect: async (
+		_actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverSseState,
+		_reason?: string,
+	) => {
+		state.stream.close();
+	},
+
+	getConnectionReadyState: (
+		_actor: AnyActorInstance,
+		_conn: AnyConn,
+		state: ConnDriverSseState,
+	): ConnReadyState | undefined => {
+		if (state.stream.aborted || state.stream.closed) {
+			return ConnReadyState.CLOSED;
+		}
+
+		return ConnReadyState.OPEN;
+	},
+};
+
+// MARK: HTTP
+const HTTP_DRIVER: ConnDriver<ConnDriverHttpState> = {
+	getConnectionReadyState(_actor, _conn) {
+		// TODO: This might not be the correct logic
+		return ConnReadyState.OPEN;
+	},
+	disconnect: async () => {
+		// Noop
+		// TODO: Abort the request
+	},
+};
+
+/** List of all connection drivers. */
+export const CONN_DRIVERS: Record<ConnDriverKind, ConnDriver<unknown>> = {
+	[ConnDriverKind.WEBSOCKET]: WEBSOCKET_DRIVER,
+	[ConnDriverKind.SSE]: SSE_DRIVER,
+	[ConnDriverKind.HTTP]: HTTP_DRIVER,
+};
+
+export function getConnDriverKindFromState(
+	state: ConnDriverState,
+): ConnDriverKind {
+	if (ConnDriverKind.WEBSOCKET in state) return ConnDriverKind.WEBSOCKET;
+	else if (ConnDriverKind.SSE in state) return ConnDriverKind.SSE;
+	else if (ConnDriverKind.HTTP in state) return ConnDriverKind.HTTP;
+	else assertUnreachable(state);
+}

package/src/actor/conn-socket.ts

@@ -0,0 +1,6 @@
+import type { ConnDriverState } from "./conn-drivers";
+
+export interface ConnSocket {
+	socketId: string;
+	driverState: ConnDriverState;
+}

package/src/actor/{connection.ts → conn.ts}

@@ -1,12 +1,19 @@
 import * as cbor from "cbor-x";
+import invariant from "invariant";
 import type * as protocol from "@/schemas/client-protocol/mod";
 import { TO_CLIENT_VERSIONED } from "@/schemas/client-protocol/versioned";
 import { bufferToArrayBuffer } from "@/utils";
+import {
+	CONN_DRIVERS,
+	ConnDriverKind,
+	type ConnDriverState,
+	ConnReadyState,
+	getConnDriverKindFromState,
+} from "./conn-drivers";
+import type { ConnSocket } from "./conn-socket";
 import type { AnyDatabaseProvider } from "./database";
-import { type ConnDriver, ConnectionReadyState } from "./driver";
 import * as errors from "./errors";
 import type { ActorInstance } from "./instance";
-import { loggerWithoutContext } from "./log";
 import type { PersistedConn } from "./persisted";
 import { CachedSerializer } from "./protocol/serde";
 import { generateSecureToken } from "./utils";
@@ -19,23 +26,16 @@ export function generateConnToken(): string {
 	return generateSecureToken(32);
 }
 
+export function generateConnSocketId(): string {
+	return crypto.randomUUID();
+}
+
 export type ConnId = string;
 
 export type AnyConn = Conn<any, any, any, any, any, any>;
 
-export const CONNECTION_DRIVER_WEBSOCKET = "webSocket";
-export const CONNECTION_DRIVER_SSE = "sse";
-export const CONNECTION_DRIVER_HTTP = "http";
-
-export type ConnectionDriver =
-	| typeof CONNECTION_DRIVER_WEBSOCKET
-	| typeof CONNECTION_DRIVER_SSE
-	| typeof CONNECTION_DRIVER_HTTP;
-
 export type ConnectionStatus = "connected" | "reconnecting";
 
-export const CONNECTION_CHECK_LIVENESS_SYMBOL = Symbol("checkLiveness");
-
 /**
  * Represents a client connection to a actor.
  *
@@ -46,13 +46,9 @@ export const CONNECTION_CHECK_LIVENESS_SYMBOL = Symbol("checkLiveness");
 export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	subscriptions: Set<string> = new Set<string>();
 
-	#stateEnabled: boolean;
-
 	// TODO: Remove this cyclical reference
 	#actor: ActorInstance<S, CP, CS, V, I, DB>;
 
-	#status: ConnectionStatus = "connected";
-
 	/**
 	 * The proxied state that notifies of changes automatically.
 	 *
@@ -60,23 +56,31 @@ export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	 */
 	__persist: PersistedConn<CP, CS>;
 
+	get __driverState(): ConnDriverState | undefined {
+		return this.__socket?.driverState;
+	}
+
 	/**
-	 * Driver used to manage realtime connection communication.
+	 * Socket connected to this connection.
 	 *
-	 * @protected
+	 * If undefined, then nothing is connected to this.
 	 */
-	#driver: ConnDriver;
+	__socket?: ConnSocket;
 
-	public get params(): CP {
-		return this.__persist.params;
+	get __status(): ConnectionStatus {
+		if (this.__socket) {
+			return "connected";
+		} else {
+			return "reconnecting";
+		}
 	}
 
-	public get driver(): ConnectionDriver {
-		return this.__persist.connDriver as ConnectionDriver;
+	public get params(): CP {
+		return this.__persist.params;
 	}
 
-	public get _stateEnabled() {
-		return this.#stateEnabled;
+	public get __stateEnabled() {
+		return this.#actor.connStateEnabled;
 	}
 
 	/**
@@ -118,7 +122,7 @@ export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	 * Status of the connection.
 	 */
 	public get status(): ConnectionStatus {
-		return this.#status;
+		return this.__status;
 	}
 
 	/**
@@ -138,17 +142,13 @@ export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	public constructor(
 		actor: ActorInstance<S, CP, CS, V, I, DB>,
 		persist: PersistedConn<CP, CS>,
-		driver: ConnDriver,
-		stateEnabled: boolean,
 	) {
 		this.#actor = actor;
 		this.__persist = persist;
-		this.#driver = driver;
-		this.#stateEnabled = stateEnabled;
 	}
 
 	#validateStateEnabled() {
-		if (!this.#stateEnabled) {
+		if (!this.__stateEnabled) {
 			throw new errors.ConnStateNotEnabled();
 		}
 	}
@@ -161,12 +161,28 @@ export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	 * @protected
 	 */
 	public _sendMessage(message: CachedSerializer<protocol.ToClient>) {
-		this.#driver.sendMessage?.(
-			this.#actor,
-			this,
-			this.__persist.connDriverState,
-			message,
-		);
+		if (this.__driverState) {
+			const driverKind = getConnDriverKindFromState(this.__driverState);
+			const driver = CONN_DRIVERS[driverKind];
+			if (driver.sendMessage) {
+				driver.sendMessage(
+					this.#actor,
+					this,
+					(this.__driverState as any)[driverKind],
+					message,
+				);
+			} else {
+				this.#actor.rLog.debug({
+					msg: "conn driver does not support sending messages",
+					conn: this.id,
+				});
+			}
+		} else {
+			this.#actor.rLog.warn({
+				msg: "missing connection driver state for send message",
+				conn: this.id,
+			});
+		}
 	}
 
 	/**
@@ -205,53 +221,31 @@ export class Conn<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	 * @param reason - The reason for disconnection.
 	 */
 	public async disconnect(reason?: string) {
-		this.#status = "reconnecting";
-		await this.#driver.disconnect(
-			this.#actor,
-			this,
-			this.__persist.connDriverState,
-			reason,
-		);
-	}
-
-	/**
-	 * This method checks the connection's liveness by querying the driver for its ready state.
-	 * If the connection is not closed, it updates the last liveness timestamp and returns `true`.
-	 * Otherwise, it returns `false`.
-	 * @internal
-	 */
-	[CONNECTION_CHECK_LIVENESS_SYMBOL]() {
-		const readyState = this.#driver.getConnectionReadyState(this.#actor, this);
-
-		const isConnectionClosed =
-			readyState === ConnectionReadyState.CLOSED ||
-			readyState === ConnectionReadyState.CLOSING ||
-			readyState === undefined;
-
-		const newLastSeen = Date.now();
-		const newStatus = isConnectionClosed ? "reconnecting" : "connected";
-
-		this.#actor.rLog.debug({
-			msg: "liveness probe for connection",
-			connId: this.id,
-			actorId: this.#actor.id,
-			readyState,
-
-			status: this.#status,
-			newStatus,
-
-			lastSeen: this.__persist.lastSeen,
-			currentTs: newLastSeen,
-		});
-
-		if (!isConnectionClosed) {
-			this.__persist.lastSeen = newLastSeen;
+		if (this.__socket && this.__driverState) {
+			const driverKind = getConnDriverKindFromState(this.__driverState);
+			const driver = CONN_DRIVERS[driverKind];
+			if (driver.disconnect) {
+				driver.disconnect(
+					this.#actor,
+					this,
+					(this.__driverState as any)[driverKind],
+					reason,
+				);
+			} else {
+				this.#actor.rLog.debug({
+					msg: "no disconnect handler for conn driver",
+					conn: this.id,
+				});
+			}
+
+			this.#actor.__connDisconnected(this, true, this.__socket.socketId);
+		} else {
+			this.#actor.rLog.warn({
+				msg: "missing connection driver state for disconnect",
+				conn: this.id,
+			});
 		}
 
-		this.#status = newStatus;
-		return {
-			status: this.#status,
-			lastSeen: this.__persist.lastSeen,
-		};
+		this.__socket = undefined;
 	}
 }

package/src/actor/context.ts

@@ -2,7 +2,7 @@ import type { ActorKey } from "@/actor/mod";
 import type { Client } from "@/client/client";
 import type { Logger } from "@/common/log";
 import type { Registry } from "@/registry/mod";
-import type { Conn, ConnId } from "./connection";
+import type { Conn, ConnId } from "./conn";
 import type { AnyDatabaseProvider, InferDatabaseClient } from "./database";
 import type { ActorInstance, SaveStateOptions } from "./instance";
 import type { Schedule } from "./schedule";

package/src/actor/driver.ts

@@ -1,15 +1,10 @@
-import type { CachedSerializer } from "@/actor/protocol/serde";
+import type { Context as HonoContext } from "hono";
 import type { AnyClient } from "@/client/client";
 import type { ManagerDriver } from "@/manager/driver";
 import type { RegistryConfig } from "@/registry/config";
 import type { RunConfig } from "@/registry/run-config";
-import type * as protocol from "@/schemas/client-protocol/mod";
-import type { AnyConn, ConnectionDriver } from "./connection";
-import type { GenericConnGlobalState } from "./generic-conn-driver";
 import type { AnyActorInstance } from "./instance";
 
-export type ConnectionDriversMap = Record<ConnectionDriver, ConnDriver>;
-
 export type ActorDriverBuilder = (
 	registryConfig: RegistryConfig,
 	runConfig: RunConfig,
@@ -22,8 +17,6 @@ export interface ActorDriver {
 
 	loadActor(actorId: string): Promise<AnyActorInstance>;
 
-	getGenericConnGlobalState(actorId: string): GenericConnGlobalState;
-
 	getContext(actorId: string): unknown;
 
 	readPersistedData(actorId: string): Promise<Uint8Array | undefined>;
@@ -45,40 +38,8 @@ export interface ActorDriver {
 	sleep?(actorId: string): Promise<void>;
 
 	shutdown?(immediate: boolean): Promise<void>;
-}
-
-export enum ConnectionReadyState {
-	UNKNOWN = -1,
-	CONNECTING = 0,
-	OPEN = 1,
-	CLOSING = 2,
-	CLOSED = 3,
-}
-
-export interface ConnDriver<ConnDriverState = unknown> {
-	sendMessage?(
-		actor: AnyActorInstance,
-		conn: AnyConn,
-		state: ConnDriverState,
-		message: CachedSerializer<protocol.ToClient>,
-	): void;
 
-	/**
-	 * This returns a promise since we commonly disconnect at the end of a program, and not waiting will cause the socket to not close cleanly.
-	 */
-	disconnect(
-		actor: AnyActorInstance,
-		conn: AnyConn,
-		state: ConnDriverState,
-		reason?: string,
-	): Promise<void>;
-
-	/**
-	 * Returns the ready state of the connection.
-	 * This is used to determine if the connection is ready to send messages, or if the connection is stale.
-	 */
-	getConnectionReadyState(
-		actor: AnyActorInstance,
-		conn: AnyConn,
-	): ConnectionReadyState | undefined;
+	// Serverless
+	/** This handles the serverless start request. This should manage the lifecycle of the runner tied to the request lifecycle. */
+	serverlessHandleStart?(c: HonoContext): Promise<Response>;
 }