rivetkit 2.0.7 → 2.0.9

package/src/driver-test-suite/tests/actor-schedule.ts

@@ -6,6 +6,8 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 	describe.skipIf(driverTestConfig.skip?.schedule)(
 		"Actor Schedule Tests",
 		() => {
+			// See alarm + actor sleeping test in actor-sleep.ts
+
 			describe("Scheduled Alarms", () => {
 				test("executes c.schedule.at() with specific timestamp", async (c) => {
 					const { client } = await setupDriverTest(c, driverTestConfig);
@@ -13,12 +15,12 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 					// Create instance
 					const scheduled = client.scheduled.getOrCreate();
 
-					// Schedule a task to run in 100ms using timestamp
-					const timestamp = Date.now() + 100;
+					// Schedule a task to run using timestamp
+					const timestamp = Date.now() + 250;
 					await scheduled.scheduleTaskAt(timestamp);
 
 					// Wait for longer than the scheduled time
-					await waitFor(driverTestConfig, 200);
+					await waitFor(driverTestConfig, 500);
 
 					// Verify the scheduled task ran
 					const lastRun = await scheduled.getLastRun();
@@ -34,11 +36,11 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 					// Create instance
 					const scheduled = client.scheduled.getOrCreate();
 
-					// Schedule a task to run in 100ms using delay
-					await scheduled.scheduleTaskAfter(100);
+					// Schedule a task to run using delay
+					await scheduled.scheduleTaskAfter(250);
 
 					// Wait for longer than the scheduled time
-					await waitFor(driverTestConfig, 200);
+					await waitFor(driverTestConfig, 500);
 
 					// Verify the scheduled task ran
 					const lastRun = await scheduled.getLastRun();
@@ -48,31 +50,6 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 					expect(scheduledCount).toBe(1);
 				});
 
-				test("scheduled tasks persist across actor restarts", async (c) => {
-					const { client } = await setupDriverTest(c, driverTestConfig);
-
-					// Create instance and schedule
-					const scheduled = client.scheduled.getOrCreate();
-					await scheduled.scheduleTaskAfter(200);
-
-					// Wait a little so the schedule is stored but hasn't triggered yet
-					await waitFor(driverTestConfig, 100);
-
-					// Get a new reference to simulate actor restart
-					const newInstance = client.scheduled.getOrCreate();
-
-					// Verify the schedule still exists but hasn't run yet
-					const initialCount = await newInstance.getScheduledCount();
-					expect(initialCount).toBe(0);
-
-					// Wait for the scheduled task to execute
-					await waitFor(driverTestConfig, 200);
-
-					// Verify the scheduled task ran after "restart"
-					const scheduledCount = await newInstance.getScheduledCount();
-					expect(scheduledCount).toBe(1);
-				});
-
 				test("multiple scheduled tasks execute in order", async (c) => {
 					const { client } = await setupDriverTest(c, driverTestConfig);
 
@@ -83,22 +60,22 @@ export function runActorScheduleTests(driverTestConfig: DriverTestConfig) {
 					await scheduled.clearHistory();
 
 					// Schedule multiple tasks with different delays
-					await scheduled.scheduleTaskAfterWithId("first", 100);
-					await scheduled.scheduleTaskAfterWithId("second", 300);
-					await scheduled.scheduleTaskAfterWithId("third", 500);
+					await scheduled.scheduleTaskAfterWithId("first", 250);
+					await scheduled.scheduleTaskAfterWithId("second", 750);
+					await scheduled.scheduleTaskAfterWithId("third", 1250);
 
 					// Wait for first task only
-					await waitFor(driverTestConfig, 200);
+					await waitFor(driverTestConfig, 500);
 					const history1 = await scheduled.getTaskHistory();
 					expect(history1).toEqual(["first"]);
 
 					// Wait for second task
-					await waitFor(driverTestConfig, 200);
+					await waitFor(driverTestConfig, 500);
 					const history2 = await scheduled.getTaskHistory();
 					expect(history2).toEqual(["first", "second"]);
 
 					// Wait for third task
-					await waitFor(driverTestConfig, 200);
+					await waitFor(driverTestConfig, 500);
 					const history3 = await scheduled.getTaskHistory();
 					expect(history3).toEqual(["first", "second", "third"]);
 				});

package/src/driver-test-suite/tests/actor-sleep.ts

@@ -29,7 +29,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			await sleepActor.triggerSleep();
 
 			// HACK: Wait for sleep to finish in background
-			await waitFor(driverTestConfig, 100);
+			await waitFor(driverTestConfig, 250);
 
 			// Get sleep count after restore
 			{
@@ -59,7 +59,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			await sleepActor.dispose();
 
 			// HACK: Wait for sleep to finish in background
-			await waitFor(driverTestConfig, 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Reconnect to get sleep count after restore
 			const sleepActor2 = client.sleep.getOrCreate();
@@ -84,7 +84,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait for sleep
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Get sleep count after restore
 			{
@@ -111,7 +111,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			await sleepActor.dispose();
 
 			// Wait for sleep
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Reconnect to get sleep count after restore
 			const sleepActor2 = client.sleep.getOrCreate();
@@ -136,7 +136,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait almost until sleep timeout, then make RPC call
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
 
 			// RPC call should reset the sleep timer
 			{
@@ -146,7 +146,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait another partial timeout period - actor should still be awake
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT - 250);
 
 			// Actor should still be awake
 			{
@@ -156,7 +156,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Now wait for full timeout without any RPC calls
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should have slept and restarted
 			{
@@ -180,10 +180,10 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Set an alarm to keep the actor awake
-			await sleepActor.setAlarm(SLEEP_TIMEOUT - 100);
+			await sleepActor.setAlarm(SLEEP_TIMEOUT - 250);
 
 			// Wait until after SLEEPT_IMEOUT to validate the actor did not sleep
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should not have slept
 			{
@@ -207,7 +207,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Set an alarm to keep the actor awake
-			await sleepActor.setAlarm(SLEEP_TIMEOUT + 100);
+			await sleepActor.setAlarm(SLEEP_TIMEOUT + 250);
 
 			// Wait until after SLEEPT_IMEOUT to validate the actor did not sleep
 			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 200);
@@ -239,7 +239,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			);
 			const longRunningPromise = sleepActor.longRunningRpc();
 			await waitPromise;
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 			await sleepActor.finishLongRunningRpc();
 			await longRunningPromise;
 
@@ -252,7 +252,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			await sleepActor.dispose();
 
 			// Now wait for the sleep timeout
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should have slept after the timeout
 			const sleepActor2 = client.sleepWithLongRpc.getOrCreate();
@@ -298,7 +298,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			});
 
 			// Wait longer than sleep timeout while keeping WebSocket connected
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Send a message to check if actor is still alive
 			ws.send(JSON.stringify({ type: "getCounts" }));
@@ -320,7 +320,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			ws.close();
 
 			// Wait for sleep timeout after WebSocket closed
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should have slept after WebSocket closed
 			{
@@ -347,7 +347,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Start a long-running fetch request
-			const fetchDuration = SLEEP_TIMEOUT + 100;
+			const fetchDuration = SLEEP_TIMEOUT + 250;
 			const fetchPromise = sleepActor.fetch(
 				`long-request?duration=${fetchDuration}`,
 			);
@@ -365,7 +365,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait for sleep timeout
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should have slept after timeout
 			{
@@ -389,7 +389,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait longer than sleep timeout
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should NOT have slept due to noSleep option
 			{
@@ -399,7 +399,7 @@ export function runActorSleepTests(driverTestConfig: DriverTestConfig) {
 			}
 
 			// Wait even longer to be sure
-			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 100);
+			await waitFor(driverTestConfig, SLEEP_TIMEOUT + 250);
 
 			// Actor should still not have slept
 			{

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

@@ -35,7 +35,11 @@ import {
 } from "@/driver-helpers/mod";
 import type { RegistryConfig } from "@/registry/config";
 import type { RunConfig } from "@/registry/run-config";
-import { promiseWithResolvers } from "@/utils";
+import {
+	type LongTimeoutHandle,
+	promiseWithResolvers,
+	setLongTimeout,
+} from "@/utils";
 import type { Config } from "./config";
 import { KEYS } from "./kv";
 import { logger } from "./log";
@@ -58,6 +62,7 @@ export class EngineActorDriver implements ActorDriver {
 	#actors: Map<string, ActorHandler> = new Map();
 	#actorRouter: ActorRouter;
 	#version: number = 1; // Version for the runner protocol
+	#alarmTimeout?: LongTimeoutHandle;
 
 	#runnerStarted: PromiseWithResolvers<undefined> = Promise.withResolvers();
 	#runnerStopped: PromiseWithResolvers<undefined> = Promise.withResolvers();
@@ -74,17 +79,21 @@ export class EngineActorDriver implements ActorDriver {
 		this.#managerDriver = managerDriver;
 		this.#inlineClient = inlineClient;
 		this.#config = config;
-		this.#actorRouter = createActorRouter(runConfig, this);
+		this.#actorRouter = createActorRouter(
+			runConfig,
+			this,
+			registryConfig.test.enabled,
+		);
 
 		// Create runner configuration
 		let hasDisconnected = false;
 		const runnerConfig: RunnerConfig = {
 			version: this.#version,
 			endpoint: config.endpoint,
-			token: config.token,
+			token: runConfig.token ?? config.token,
 			pegboardEndpoint: config.pegboardEndpoint,
 			namespace: config.namespace,
-			totalSlots: config.totalSlots,
+			totalSlots: runConfig.totalSlots ?? config.totalSlots,
 			runnerName: config.runnerName,
 			runnerKey: config.runnerKey,
 			metadata: {
@@ -186,9 +195,29 @@ export class EngineActorDriver implements ActorDriver {
 	}
 
 	async setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void> {
-		// TODO: Set timeout
-		// TODO: Use alarm on sleep
-		// TODO: Send alarm to runner
+		// Clear prev timeout
+		if (this.#alarmTimeout) {
+			this.#alarmTimeout.abort();
+			this.#alarmTimeout = undefined;
+		}
+
+		// Set alarm
+		const delay = Math.max(0, timestamp - Date.now());
+		this.#alarmTimeout = setLongTimeout(() => {
+			actor._onAlarm();
+			this.#alarmTimeout = undefined;
+		}, delay);
+
+		// TODO: This call may not be needed on ActorInstance.start, but it does help ensure that the local state is synced with the alarm state
+		// Set alarm on Rivet
+		//
+		// This does not call an "alarm" event like Durable Objects.
+		// Instead, it just wakes the actor on the alarm (if not
+		// already awake).
+		//
+		// _onAlarm is automatically called on `ActorInstance.start` when waking
+		// again.
+		this.#runner.setAlarm(actor.id, timestamp);
 	}
 
 	async getDatabase(_actorId: string): Promise<unknown | undefined> {
@@ -382,9 +411,9 @@ export class EngineActorDriver implements ActorDriver {
 
 		return streamSSE(c, async (stream) => {
 			// Runner id should be set if the runner started
-			const runnerId = this.#runner.runnerId;
-			invariant(runnerId, "runnerId not set");
-			stream.writeSSE({ data: runnerId });
+			const payload = this.#runner.getServerlessInitPacket();
+			invariant(payload, "runnerId not set");
+			stream.writeSSE({ data: payload });
 
 			return this.#runnerStopped.promise;
 		});

package/src/drivers/file-system/manager.ts

@@ -123,7 +123,11 @@ export class FileSystemManagerDriver implements ManagerDriver {
 			this,
 			inlineClient,
 		);
-		this.#actorRouter = createActorRouter(this.#runConfig, this.#actorDriver);
+		this.#actorRouter = createActorRouter(
+			this.#runConfig,
+			this.#actorDriver,
+			registryConfig.test.enabled,
+		);
 	}
 
 	async sendRequest(actorId: string, actorRequest: Request): Promise<Response> {

package/src/manager/driver.ts

@@ -52,7 +52,7 @@ export interface ManagerDriver {
 
 	/**
 	 * Get or create the inspector access token.
-	 * @internal
+	 * @experimental
 	 * @returns creates or returns existing inspector access token
 	 */
 	getOrCreateInspectorAccessToken: () => string;

package/src/manager/router.ts

@@ -2,9 +2,9 @@ import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
 import * as cbor from "cbor-x";
 import {
 	Hono,
-	Context as HonoContext,
+	type Context as HonoContext,
 	type MiddlewareHandler,
-	Next,
+	type Next,
 } from "hono";
 import { cors as corsMiddleware } from "hono/cors";
 import { createMiddleware } from "hono/factory";
@@ -80,45 +80,53 @@ export function createManagerRouter(
 	runConfig: RunConfig,
 	managerDriver: ManagerDriver,
 	serverlessActorDriverBuilder: (() => ActorDriver) | undefined,
-): { router: Hono; openapi: OpenAPIHono; cors: MiddlewareHandler } {
+): { router: Hono; openapi: OpenAPIHono } {
 	const router = new OpenAPIHono({ strict: false }).basePath(
 		runConfig.basePath,
 	);
 
 	router.use("*", loggerMiddleware(logger()));
 
-	const cors = runConfig.cors
-		? corsMiddleware(runConfig.cors)
-		: createMiddleware((_c, next) => next());
-
 	if (serverlessActorDriverBuilder) {
-		addServerlessRoutes(serverlessActorDriverBuilder, router, cors);
+		addServerlessRoutes(runConfig, serverlessActorDriverBuilder, router);
 	} else {
-		addManagerRoutes(registryConfig, runConfig, managerDriver, router, cors);
+		addManagerRoutes(registryConfig, runConfig, managerDriver, router);
 	}
 
 	// Error handling
 	router.notFound(handleRouteNotFound);
 	router.onError(handleRouteError);
 
-	return { router: router as Hono, openapi: router, cors };
+	return { router: router as Hono, openapi: router };
 }
 
 function addServerlessRoutes(
-	serverlessActorDriverBuilder: () => ActorDriver,
+	runConfig: RunConfig,
+	serverlessActorDriverBuilder: (
+		token: string | undefined,
+		totalSlots: number | undefined,
+	) => ActorDriver,
 	router: OpenAPIHono,
-	cors: MiddlewareHandler,
 ) {
+	// Apply CORS
+	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
+
 	// GET /
-	router.get("/", cors, (c) => {
+	router.get("/", (c) => {
 		return c.text(
 			"This is a RivetKit server.\n\nLearn more at https://rivetkit.org",
 		);
 	});
 
 	// Serverless start endpoint
-	router.get("/start", cors, async (c) => {
-		const actorDriver = serverlessActorDriverBuilder();
+	router.get("/start", async (c) => {
+		const token = c.req.header("x-rivet-token");
+		let totalSlots: number | undefined = parseInt(
+			c.req.header("x-rivetkit-total-slots") as any,
+		);
+		if (isNaN(totalSlots)) totalSlots = undefined;
+
+		const actorDriver = serverlessActorDriverBuilder(token, totalSlots);
 		invariant(
 			actorDriver.serverlessHandleStart,
 			"missing serverlessHandleStart on ActorDriver",
@@ -126,7 +134,7 @@ function addServerlessRoutes(
 		return await actorDriver.serverlessHandleStart(c);
 	});
 
-	router.get("/health", cors, (c) => {
+	router.get("/health", (c) => {
 		return c.text("ok");
 	});
 }
@@ -136,13 +144,34 @@ function addManagerRoutes(
 	runConfig: RunConfig,
 	managerDriver: ManagerDriver,
 	router: OpenAPIHono,
-	cors: MiddlewareHandler,
 ) {
+	// Serve inspector BEFORE the rest of the routes, since this has a special
+	// CORS config that should take precedence for the `/inspector` path
+	if (isInspectorEnabled(runConfig, "manager")) {
+		if (!managerDriver.inspector) {
+			throw new Unsupported("inspector");
+		}
+		router.route(
+			"/inspect",
+			new Hono<{ Variables: { inspector: any } }>()
+				.use(corsMiddleware(runConfig.inspector.cors))
+				.use(secureInspector(runConfig))
+				.use((c, next) => {
+					c.set("inspector", managerDriver.inspector!);
+					return next();
+				})
+				.route("/", createManagerInspectorRouter()),
+		);
+	}
+
+	// Apply CORS
+	if (runConfig.cors) router.use("*", corsMiddleware(runConfig.cors));
+
 	// Actor gateway
-	router.use("*", cors, actorGateway.bind(undefined, runConfig, managerDriver));
+	router.use("*", actorGateway.bind(undefined, runConfig, managerDriver));
 
 	// GET /
-	router.get("/", cors, (c) => {
+	router.get("/", (c) => {
 		return c.text(
 			"This is a RivetKit server.\n\nLearn more at https://rivetkit.org",
 		);
@@ -151,7 +180,6 @@ function addManagerRoutes(
 	// GET /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "get",
 			path: "/actors",
 			request: {
@@ -224,7 +252,6 @@ function addManagerRoutes(
 	// PUT /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "put",
 			path: "/actors",
 			request: {
@@ -277,7 +304,6 @@ function addManagerRoutes(
 	// POST /actors
 	{
 		const route = createRoute({
-			middleware: [cors],
 			method: "post",
 			path: "/actors",
 			request: {
@@ -317,7 +343,6 @@ function addManagerRoutes(
 	// // DELETE /actors/{actor_id}
 	// {
 	// 	const route = createRoute({
-	// 		middleware: [cors],
 	// 		method: "delete",
 	// 		path: "/actors/{actor_id}",
 	// 		request: {
@@ -538,7 +563,7 @@ function addManagerRoutes(
 		});
 	}
 
-	router.get("/health", cors, (c) => {
+	router.get("/health", (c) => {
 		return c.text("ok");
 	});
 
@@ -546,23 +571,6 @@ function addManagerRoutes(
 		registryConfig,
 		router as unknown as Hono,
 	);
-
-	if (isInspectorEnabled(runConfig, "manager")) {
-		if (!managerDriver.inspector) {
-			throw new Unsupported("inspector");
-		}
-		router.route(
-			"/inspect",
-			new Hono<{ Variables: { inspector: any } }>()
-				.use(corsMiddleware(runConfig.inspector.cors))
-				.use(secureInspector(runConfig))
-				.use((c, next) => {
-					c.set("inspector", managerDriver.inspector!);
-					return next();
-				})
-				.route("/", createManagerInspectorRouter()),
-		);
-	}
 }
 
 function createApiActor(actor: ActorOutput): ApiActor {

package/src/registry/mod.ts

@@ -108,7 +108,7 @@ export class Registry<A extends RegistryActors> {
 				console.log(`  - ${k}:${padding}${v}`);
 			}
 			if (isInspectorEnabled(config, "manager") && managerDriver.inspector) {
-				console.log(`  - Inspector:     ${getInspectorUrl(config)}`);
+				console.log(`  - Inspector:    ${getInspectorUrl(config)}`);
 			}
 			console.log();
 		}
@@ -215,7 +215,16 @@ export class Registry<A extends RegistryActors> {
 			console.log();
 		}
 
-		let serverlessActorDriverBuilder: (() => ActorDriver) | undefined = () => {
+		let serverlessActorDriverBuilder:
+			| ((token?: string, totalSlots?: number) => ActorDriver)
+			| undefined = (
+			token: string | undefined,
+			totalSlots: number | undefined,
+		) => {
+			// Override config
+			if (token) config.token = token;
+			if (totalSlots) config.totalSlots = totalSlots;
+
 			return driver.actor(this.#config, config, managerDriver, client);
 		};
 

package/src/remote-manager-driver/mod.ts

@@ -15,6 +15,7 @@ import type {
 	ManagerDriver,
 } from "@/driver-helpers/mod";
 import type { Encoding, UniversalWebSocket } from "@/mod";
+import { uint8ArrayToBase64 } from "@/serde";
 import { combineUrlPath } from "@/utils";
 import { sendHttpRequestToActor } from "./actor-http-client";
 import {
@@ -140,7 +141,7 @@ export class RemoteManagerDriver implements ManagerDriver {
 			key: serializeActorKey(key),
 			runner_name_selector: this.#config.runnerName,
 			input: actorInput
-				? cbor.encode(actorInput).toString("base64")
+				? uint8ArrayToBase64(cbor.encode(actorInput))
 				: undefined,
 			crash_policy: "sleep",
 		});
@@ -175,7 +176,7 @@ export class RemoteManagerDriver implements ManagerDriver {
 			name,
 			runner_name_selector: this.#config.runnerName,
 			key: serializeActorKey(key),
-			input: input ? cbor.encode(input).toString("base64") : null,
+			input: input ? uint8ArrayToBase64(cbor.encode(input)) : undefined,
 			crash_policy: "sleep",
 		});
 		const actorId = result.actor.actor_id;

package/src/serde.ts

@@ -5,6 +5,21 @@ import type { VersionedDataHandler } from "@/common/versioned-data";
 import type { Encoding } from "@/mod";
 import { jsonStringifyCompat } from "./actor/protocol/serde";
 
+export function uint8ArrayToBase64(uint8Array: Uint8Array): string {
+	// Check if Buffer is available (Node.js)
+	if (typeof Buffer !== "undefined") {
+		return Buffer.from(uint8Array).toString("base64");
+	}
+
+	// Browser environment - use btoa
+	let binary = "";
+	const len = uint8Array.byteLength;
+	for (let i = 0; i < len; i++) {
+		binary += String.fromCharCode(uint8Array[i]);
+	}
+	return btoa(binary);
+}
+
 export function encodingIsBinary(encoding: Encoding): boolean {
 	if (encoding === "json") {
 		return false;