rivetkit 2.1.4 → 2.1.6-rc.1

package/src/inspector/config.ts

@@ -16,10 +16,7 @@ const defaultTokenFn = () => {
 };
 
 const defaultEnabled = () => {
-	return (
-		isDev() ||
-		!getRivetkitInspectorDisable()
-	);
+	return isDev() || !getRivetkitInspectorDisable();
 };
 
 export const InspectorConfigSchema = z

package/src/inspector/mod.browser.ts

@@ -3,6 +3,6 @@ export * from "../schemas/actor-inspector/mod";
 export * from "../schemas/actor-inspector/versioned";
 export type { WorkflowHistory as TransportWorkflowHistory } from "../schemas/transport/mod";
 export {
-    decodeWorkflowHistoryTransport,
-    encodeWorkflowHistoryTransport,
+	decodeWorkflowHistoryTransport,
+	encodeWorkflowHistoryTransport,
 } from "./transport";

package/src/inspector/mod.ts

@@ -1,4 +1,7 @@
 export * from "../schemas/actor-inspector/mod";
 export * from "../schemas/actor-inspector/versioned";
-export { decodeWorkflowHistoryTransport, encodeWorkflowHistoryTransport } from "./transport";
+export {
+	decodeWorkflowHistoryTransport,
+	encodeWorkflowHistoryTransport,
+} from "./transport";
 export type { WorkflowHistory as TransportWorkflowHistory } from "../schemas/transport/mod";

package/src/inspector/serve-ui.ts

@@ -1,4 +1,3 @@
-
 import { extract } from "tar";
 import { getNodeFs, getNodeOs, getNodePath, getNodeUrl } from "@/utils/node";
 

package/src/inspector/workflow-history-json.ts

@@ -0,0 +1,309 @@
+import * as cbor from "cbor-x";
+import { decodeWorkflowHistoryTransport } from "@/inspector/transport";
+import type * as transport from "@/schemas/transport/mod";
+
+function decodeWorkflowCbor(data: ArrayBuffer | null): unknown | null {
+	if (data === null) {
+		return null;
+	}
+
+	try {
+		return cbor.decode(new Uint8Array(data));
+	} catch {
+		return null;
+	}
+}
+
+function serializeWorkflowLocation(
+	location: transport.WorkflowLocation,
+): Array<
+	| { tag: "WorkflowNameIndex"; val: number }
+	| {
+			tag: "WorkflowLoopIterationMarker";
+			val: { loop: number; iteration: number };
+	  }
+> {
+	return location.map((segment) => {
+		if (segment.tag === "WorkflowNameIndex") {
+			return {
+				tag: segment.tag,
+				val: segment.val,
+			};
+		}
+
+		return {
+			tag: segment.tag,
+			val: {
+				loop: segment.val.loop,
+				iteration: segment.val.iteration,
+			},
+		};
+	});
+}
+
+function serializeWorkflowBranches(
+	branches: ReadonlyMap<string, transport.WorkflowBranchStatus>,
+): Record<
+	string,
+	{ status: string; output: unknown | null; error: string | null }
+> {
+	return Object.fromEntries(
+		Array.from(branches.entries()).map(([name, branch]) => [
+			name,
+			{
+				status: branch.status,
+				output: decodeWorkflowCbor(branch.output),
+				error: branch.error,
+			},
+		]),
+	);
+}
+
+function serializeWorkflowEntryKind(kind: transport.WorkflowEntryKind):
+	| {
+			tag: "WorkflowStepEntry";
+			val: { output: unknown | null; error: string | null };
+	  }
+	| {
+			tag: "WorkflowLoopEntry";
+			val: {
+				state: unknown | null;
+				iteration: number;
+				output: unknown | null;
+			};
+	  }
+	| {
+			tag: "WorkflowSleepEntry";
+			val: { deadline: number; state: string };
+	  }
+	| {
+			tag: "WorkflowMessageEntry";
+			val: { name: string; messageData: unknown | null };
+	  }
+	| {
+			tag: "WorkflowRollbackCheckpointEntry";
+			val: { name: string };
+	  }
+	| {
+			tag: "WorkflowJoinEntry";
+			val: {
+				branches: Record<
+					string,
+					{
+						status: string;
+						output: unknown | null;
+						error: string | null;
+					}
+				>;
+			};
+	  }
+	| {
+			tag: "WorkflowRaceEntry";
+			val: {
+				winner: string | null;
+				branches: Record<
+					string,
+					{
+						status: string;
+						output: unknown | null;
+						error: string | null;
+					}
+				>;
+			};
+	  }
+	| {
+			tag: "WorkflowRemovedEntry";
+			val: { originalType: string; originalName: string | null };
+	  } {
+	switch (kind.tag) {
+		case "WorkflowStepEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					output: decodeWorkflowCbor(kind.val.output),
+					error: kind.val.error,
+				},
+			};
+		case "WorkflowLoopEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					state: decodeWorkflowCbor(kind.val.state),
+					iteration: kind.val.iteration,
+					output: decodeWorkflowCbor(kind.val.output),
+				},
+			};
+		case "WorkflowSleepEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					deadline: Number(kind.val.deadline),
+					state: kind.val.state,
+				},
+			};
+		case "WorkflowMessageEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					name: kind.val.name,
+					messageData: decodeWorkflowCbor(kind.val.messageData),
+				},
+			};
+		case "WorkflowRollbackCheckpointEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					name: kind.val.name,
+				},
+			};
+		case "WorkflowJoinEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					branches: serializeWorkflowBranches(kind.val.branches),
+				},
+			};
+		case "WorkflowRaceEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					winner: kind.val.winner,
+					branches: serializeWorkflowBranches(kind.val.branches),
+				},
+			};
+		case "WorkflowRemovedEntry":
+			return {
+				tag: kind.tag,
+				val: {
+					originalType: kind.val.originalType,
+					originalName: kind.val.originalName,
+				},
+			};
+	}
+}
+
+export function serializeWorkflowHistoryForJson(
+	data: ArrayBuffer | null,
+):
+	| {
+			nameRegistry: string[];
+			entries: Array<{
+				id: string;
+				location: Array<
+					| { tag: "WorkflowNameIndex"; val: number }
+					| {
+							tag: "WorkflowLoopIterationMarker";
+							val: { loop: number; iteration: number };
+					  }
+				>;
+				kind:
+					| {
+							tag: "WorkflowStepEntry";
+							val: { output: unknown | null; error: string | null };
+					  }
+					| {
+							tag: "WorkflowLoopEntry";
+							val: {
+								state: unknown | null;
+								iteration: number;
+								output: unknown | null;
+							};
+					  }
+					| {
+							tag: "WorkflowSleepEntry";
+							val: { deadline: number; state: string };
+					  }
+					| {
+							tag: "WorkflowMessageEntry";
+							val: { name: string; messageData: unknown | null };
+					  }
+					| {
+							tag: "WorkflowRollbackCheckpointEntry";
+							val: { name: string };
+					  }
+					| {
+							tag: "WorkflowJoinEntry";
+							val: {
+								branches: Record<
+									string,
+									{
+										status: string;
+										output: unknown | null;
+										error: string | null;
+									}
+								>;
+							};
+					  }
+					| {
+							tag: "WorkflowRaceEntry";
+							val: {
+								winner: string | null;
+								branches: Record<
+									string,
+									{
+										status: string;
+										output: unknown | null;
+										error: string | null;
+									}
+								>;
+							};
+					  }
+					| {
+							tag: "WorkflowRemovedEntry";
+							val: {
+								originalType: string;
+								originalName: string | null;
+							};
+					  };
+			}>;
+			entryMetadata: Record<
+				string,
+				{
+					status: string;
+					error: string | null;
+					attempts: number;
+					lastAttemptAt: number;
+					createdAt: number;
+					completedAt: number | null;
+					rollbackCompletedAt: number | null;
+					rollbackError: string | null;
+				}
+			>;
+	  }
+	| null {
+	if (data === null) {
+		return null;
+	}
+
+	const history = decodeWorkflowHistoryTransport(data);
+
+	return {
+		nameRegistry: [...history.nameRegistry],
+		entries: history.entries.map((entry) => ({
+			id: entry.id,
+			location: serializeWorkflowLocation(entry.location),
+			kind: serializeWorkflowEntryKind(entry.kind),
+		})),
+		entryMetadata: Object.fromEntries(
+			Array.from(history.entryMetadata.entries()).map(([entryId, meta]) => [
+				entryId,
+				{
+					status: meta.status,
+					error: meta.error,
+					attempts: meta.attempts,
+					lastAttemptAt: Number(meta.lastAttemptAt),
+					createdAt: Number(meta.createdAt),
+					completedAt:
+						meta.completedAt === null
+							? null
+							: Number(meta.completedAt),
+					rollbackCompletedAt:
+						meta.rollbackCompletedAt === null
+							? null
+							: Number(meta.rollbackCompletedAt),
+					rollbackError: meta.rollbackError,
+				},
+			]),
+		),
+	};
+}

package/src/manager/gateway.ts

@@ -122,7 +122,6 @@ export async function actorGateway(
 	c: HonoContext,
 	next: Next,
 ) {
-
 	// Skip test routes - let them be handled by their specific handlers
 	if (c.req.path.startsWith("/.test/")) {
 		return next();
@@ -425,7 +424,12 @@ export async function createTestWebSocketProxy(
 		promise: clientToProxyWsPromise,
 		resolve: clientToProxyWsResolve,
 		reject: clientToProxyWsReject,
-	} = promiseWithResolvers<WSContext>((reason) => logger().warn({ msg: "unhandled client websocket promise rejection", reason }));
+	} = promiseWithResolvers<WSContext>((reason) =>
+		logger().warn({
+			msg: "unhandled client websocket promise rejection",
+			reason,
+		}),
+	);
 	try {
 		// Resolve the client WebSocket promise
 		logger().debug({ msg: "awaiting client websocket promise" });

package/src/manager/router.ts

@@ -95,9 +95,9 @@ export function buildManagerRouter(
 
 				const actorIdsParsed = actor_ids
 					? actor_ids
-						.split(",")
-						.map((id) => id.trim())
-						.filter((id) => id.length > 0)
+							.split(",")
+							.map((id) => id.trim())
+							.filter((id) => id.length > 0)
 					: undefined;
 
 				const actors: ActorOutput[] = [];

package/src/registry/config/index.ts

@@ -58,6 +58,26 @@ export const RegistryConfigSchema = z
 			.optional()
 			.transform((val) => val ?? getRivetkitStoragePath()),
 
+		// MARK: Database
+		/**
+		 * @experimental
+		 *
+		 * Configuration for the SQLite VFS pool that shares WASM instances across actors.
+		 */
+		sqlitePool: z
+			.object({
+				/**
+				 * Number of actors per WASM SQLite instance.
+				 */
+				actorsPerInstance: z.number().int().min(1).optional().default(50),
+				/**
+				 * Milliseconds before an idle instance (no actors, no in-flight ops) is destroyed.
+				 */
+				idleDestroyMs: z.number().optional().default(30_000),
+			})
+			.optional()
+			.default(() => ({ actorsPerInstance: 50, idleDestroyMs: 30_000 })),
+
 		// MARK: Networking
 		/** @experimental */
 		maxIncomingMessageSize: z.number().optional().default(65_536),
@@ -125,6 +145,14 @@ export const RegistryConfigSchema = z
 		 * Auto-determined based on endpoint and NODE_ENV if not specified.
 		 */
 		serveManager: z.boolean().optional(),
+		/**
+		 * Directory to serve static files from.
+		 *
+		 * When set, the manager server will serve static files from this
+		 * directory. This is used by `registry.start()` to serve a frontend
+		 * alongside the actor API.
+		 */
+		publicDir: z.string().optional(),
 		/**
 		 * @experimental
 		 *
@@ -163,11 +191,11 @@ export const RegistryConfigSchema = z
 		// Parse endpoint string (env var fallback is applied via transform above)
 		const parsedEndpoint = config.endpoint
 			? tryParseEndpoint(ctx, {
-					endpoint: config.endpoint,
-					path: ["endpoint"],
-					namespace: config.namespace,
-					token: config.token,
-				})
+				endpoint: config.endpoint,
+				path: ["endpoint"],
+				namespace: config.namespace,
+				token: config.token,
+			})
 			: undefined;
 
 		if (parsedEndpoint && config.serveManager) {
@@ -212,9 +240,9 @@ export const RegistryConfigSchema = z
 		// Parse publicEndpoint string (env var fallback is applied via transform in serverless schema)
 		const parsedPublicEndpoint = config.serverless.publicEndpoint
 			? tryParseEndpoint(ctx, {
-					endpoint: config.serverless.publicEndpoint,
-					path: ["serverless", "publicEndpoint"],
-				})
+				endpoint: config.serverless.publicEndpoint,
+				path: ["serverless", "publicEndpoint"],
+			})
 			: undefined;
 
 		// Validate that publicEndpoint namespace matches backend namespace if specified
@@ -248,9 +276,9 @@ export const RegistryConfigSchema = z
 		const willUseEngine = !!endpoint || config.serverless.spawnEngine;
 		const inspector = willUseEngine
 			? {
-					...config.inspector,
-					enabled: { manager: false, actor: true },
-				}
+				...config.inspector,
+				enabled: { manager: false, actor: true },
+			}
 			: config.inspector;
 
 		return {
@@ -420,7 +448,7 @@ export const DocRunnerConfigSchema = z
 		runnerKey: z
 			.string()
 			.optional()
-			.describe("Authentication key for the runner."),
+			.describe("Deprecated. Authentication key for the runner."),
 		version: z
 			.number()
 			.optional()
@@ -441,6 +469,25 @@ export const DocRegistryConfigSchema = z
 			.describe(
 				"Storage path for RivetKit file-system state when using the default driver. Can also be set via RIVETKIT_STORAGE_PATH.",
 			),
+		sqlitePool: z
+			.object({
+				actorsPerInstance: z
+					.number()
+					.optional()
+					.describe(
+						"Number of actors per WASM SQLite instance. Default: 50",
+					),
+				idleDestroyMs: z
+					.number()
+					.optional()
+					.describe(
+						"Milliseconds before an idle WASM instance is destroyed. Default: 30000",
+					),
+			})
+			.optional()
+			.describe(
+				"Configuration for the SQLite VFS pool that shares WASM instances across actors.",
+			),
 		maxIncomingMessageSize: z
 			.number()
 			.optional()
@@ -495,6 +542,12 @@ export const DocRegistryConfigSchema = z
 			.describe(
 				"Whether to start the local manager server. Auto-determined based on endpoint and NODE_ENV if not specified.",
 			),
+		publicDir: z
+			.string()
+			.optional()
+			.describe(
+				"Directory to serve static files from. When set, the manager server serves static files alongside the actor API. Used by registry.start().",
+			),
 		managerBasePath: z
 			.string()
 			.optional()

package/src/registry/config/runner.ts

@@ -1,21 +1,36 @@
 import { z } from "zod/v4";
+import { getLogger } from "@/common/log";
 import {
 	isDev,
+	getNodeEnv,
 	getRivetTotalSlots,
 	getRivetRunner,
-	getRivetRunnerKey,
 	getRivetRunnerVersion,
 } from "@/utils/env-vars";
 
+let warnedMissingVersion = false;
+
 export const RunnerConfigSchema = z.object({
 	// MARK: Runner
 	totalSlots: z.number().default(() => getRivetTotalSlots() ?? 100000),
 	runnerName: z.string().default(() => getRivetRunner() ?? "default"),
+	// Deprecated.
 	runnerKey: z
 		.string()
-		.optional()
-		.transform((x) => x ?? getRivetRunnerKey()),
-	version: z.number().default(() => getRivetRunnerVersion() ?? 1),
+		.optional(),
+	version: z.number().default(() => {
+		const version = getRivetRunnerVersion();
+		if (version !== undefined) return version;
+
+		if (getNodeEnv() === "production" && !warnedMissingVersion) {
+			warnedMissingVersion = true;
+			getLogger("rivetkit").error(
+				"RIVET_RUNNER_VERSION is not set. Actors will not be versioned, which means they won't be drained on deploy. This is only needed when self-hosting or using a custom runner (not needed for Rivet Compute). Set this as a build arg in your Dockerfile. See https://rivet.dev/docs/actors/versions",
+			);
+		}
+
+		return 1;
+	}),
 });
 export type RunnerConfigInput = z.input<typeof RunnerConfigSchema>;
 export type RunnerConfig = z.infer<typeof RunnerConfigSchema>;