rivetkit 2.1.2 → 2.1.4

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

@@ -0,0 +1,157 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runActorLifecycleTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor Lifecycle Tests", () => {
+		test("actor stop during start waits for start to complete", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-stop-during-start-${Date.now()}`;
+
+			// Create actor - this starts the actor
+			const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+
+			// Immediately try to call an action and then destroy
+			// This creates a race where the actor might not be fully started yet
+			const pingPromise = actor.ping();
+
+			// Get actor ID
+			const actorId = await actor.resolve();
+
+			// Destroy immediately while start might still be in progress
+			await actor.destroy();
+
+			// The ping should still complete successfully because destroy waits for start
+			const result = await pingPromise;
+			expect(result).toBe("pong");
+
+			// Verify actor was actually destroyed
+			let destroyed = false;
+			try {
+				await client.startStopRaceActor.getForId(actorId).ping();
+			} catch (err: any) {
+				destroyed = true;
+				expect(err.group).toBe("actor");
+				expect(err.code).toBe("not_found");
+			}
+			expect(destroyed).toBe(true);
+		});
+
+		test("actor stop before actor instantiation completes cleans up handler", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-stop-before-instantiation-${Date.now()}`;
+
+			// Create multiple actors rapidly to increase chance of race
+			const actors = Array.from({ length: 5 }, (_, i) =>
+				client.startStopRaceActor.getOrCreate([
+					`${actorKey}-${i}`,
+				]),
+			);
+
+			// Resolve all actor IDs (this triggers start)
+			const ids = await Promise.all(actors.map((a) => a.resolve()));
+
+			// Immediately destroy all actors
+			await Promise.all(actors.map((a) => a.destroy()));
+
+			// Verify all actors were cleaned up
+			for (const id of ids) {
+				let destroyed = false;
+				try {
+					await client.startStopRaceActor.getForId(id).ping();
+				} catch (err: any) {
+					destroyed = true;
+					expect(err.group).toBe("actor");
+					expect(err.code).toBe("not_found");
+				}
+				expect(destroyed, `actor ${id} should be destroyed`).toBe(
+					true,
+				);
+			}
+		});
+
+		test("onBeforeActorStart completes before stop proceeds", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-before-actor-start-${Date.now()}`;
+
+			// Create actor
+			const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+
+			// Call action to ensure actor is starting
+			const statePromise = actor.getState();
+
+			// Destroy immediately
+			await actor.destroy();
+
+			// State should be initialized because onBeforeActorStart must complete
+			const state = await statePromise;
+			expect(state.initialized).toBe(true);
+			expect(state.startCompleted).toBe(true);
+		});
+
+		test("multiple rapid create/destroy cycles handle race correctly", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			// Perform multiple rapid create/destroy cycles
+			for (let i = 0; i < 10; i++) {
+				const actorKey = `test-rapid-cycle-${Date.now()}-${i}`;
+				const actor = client.startStopRaceActor.getOrCreate([
+					actorKey,
+				]);
+
+				// Trigger start
+				const resolvePromise = actor.resolve();
+
+				// Immediately destroy
+				const destroyPromise = actor.destroy();
+
+				// Both should complete without errors
+				await Promise.all([resolvePromise, destroyPromise]);
+			}
+
+			// If we get here without errors, the race condition is handled correctly
+			expect(true).toBe(true);
+		});
+
+		test("actor stop called with no actor instance cleans up handler", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-cleanup-no-instance-${Date.now()}`;
+
+			// Create and immediately destroy
+			const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+			const id = await actor.resolve();
+			await actor.destroy();
+
+			// Try to recreate with same key - should work without issues
+			const newActor = client.startStopRaceActor.getOrCreate([
+				actorKey,
+			]);
+			const result = await newActor.ping();
+			expect(result).toBe("pong");
+
+			// Clean up
+			await newActor.destroy();
+		});
+
+		test("onDestroy is called even when actor is destroyed during start", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-ondestroy-during-start-${Date.now()}`;
+
+			// Create actor
+			const actor = client.startStopRaceActor.getOrCreate([actorKey]);
+
+			// Start and immediately destroy
+			const statePromise = actor.getState();
+			await actor.destroy();
+
+			// Verify onDestroy was called (requires actor to be started)
+			const state = await statePromise;
+			expect(state.destroyCalled).toBe(true);
+		});
+	});
+}

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

@@ -182,15 +182,16 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			}
 		});
 
-		test("wait send returns completion response", async (c) => {
-			const { client } = await setupDriverTest(c, driverTestConfig);
-			const handle = client.queueActor.getOrCreate(["wait-complete"]);
-
-			const actionPromise = handle.receiveAndComplete("tasks");
-			const result = await handle.send("tasks", 
-				{ value: 123 },
-				{ wait: true, timeout: 1_000 },
-			);
+			test("wait send returns completion response", async (c) => {
+				const { client } = await setupDriverTest(c, driverTestConfig);
+				const handle = client.queueActor.getOrCreate(["wait-complete"]);
+				const waitTimeout = driverTestConfig.useRealTimers ? 5_000 : 1_000;
+
+				const actionPromise = handle.receiveAndComplete("tasks");
+				const result = await handle.send("tasks", 
+					{ value: 123 },
+					{ wait: true, timeout: waitTimeout },
+				);
 
 			await actionPromise;
 			expect(result).toEqual({

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

@@ -13,8 +13,18 @@ export function runActorWorkflowTests(driverTestConfig: DriverTestConfig) {
 				"workflow-basic",
 			]);
 
-			await waitFor(driverTestConfig, 1000);
-			const state = await actor.getState();
+			let state = await actor.getState();
+			for (let i = 0; i < 50; i++) {
+				if (
+					state.runCount > 0 &&
+					state.history.length > 0 &&
+					state.guardTriggered
+				) {
+					break;
+				}
+				await waitFor(driverTestConfig, 100);
+				state = await actor.getState();
+			}
 			expect(state.runCount).toBeGreaterThan(0);
 			expect(state.history.length).toBeGreaterThan(0);
 			expect(state.guardTriggered).toBe(true);

package/src/driver-test-suite/tests/conn-error-serialization.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "../mod";
+import { setupDriverTest } from "../utils";
+
+export function runConnErrorSerializationTests(driverTestConfig: DriverTestConfig) {
+	describe("Connection Error Serialization Tests", () => {
+		test("error thrown in createConnState preserves group and code through WebSocket serialization", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-error-serialization-${Date.now()}`;
+
+			// Create actor handle with params that will trigger error in createConnState
+			const actor = client.connErrorSerializationActor.getOrCreate(
+				[actorKey],
+				{ params: { shouldThrow: true } },
+			);
+
+			// Try to connect, which will trigger error in createConnState
+			const conn = actor.connect();
+
+			// Wait for connection to fail
+			let caughtError: any;
+			try {
+				// Try to call an action, which should fail because connection couldn't be established
+				await conn.getValue();
+			} catch (err) {
+				caughtError = err;
+			}
+
+			// Verify the error was caught
+			expect(caughtError).toBeDefined();
+
+			// Verify the error has the correct group and code from the original error
+			// Original error: new CustomConnectionError("...") with group="connection", code="custom_error"
+			expect(caughtError.group).toBe("connection");
+			expect(caughtError.code).toBe("custom_error");
+
+			// Clean up
+			await conn.dispose();
+		});
+
+		test("successful createConnState does not throw error", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actorKey = `test-no-error-${Date.now()}`;
+
+			// Create actor handle with params that will NOT trigger error
+			const actor = client.connErrorSerializationActor.getOrCreate(
+				[actorKey],
+				{ params: { shouldThrow: false } },
+			);
+
+			// Connect without triggering error
+			const conn = actor.connect();
+
+			// This should succeed
+			const value = await conn.getValue();
+			expect(value).toBe(0);
+
+			// Clean up
+			await conn.dispose();
+		});
+	});
+}

package/src/driver-test-suite/utils.ts

@@ -26,10 +26,6 @@ export async function setupDriverTest(
 	// Build drivers
 	const { endpoint, namespace, runnerName, cleanup } =
 		await driverTestConfig.start();
-	c.onTestFinished(() => {
-		logger().info("cleaning up test");
-		cleanup();
-	});
 
 	let client: Client<typeof registry>;
 	if (driverTestConfig.clientType === "http") {
@@ -56,10 +52,14 @@ export async function setupDriverTest(
 		assertUnreachable(driverTestConfig.clientType);
 	}
 
-	// Cleanup client
-	if (!driverTestConfig.HACK_skipCleanupNet) {
-		c.onTestFinished(async () => await client.dispose());
-	}
+	c.onTestFinished(async () => {
+		if (!driverTestConfig.HACK_skipCleanupNet) {
+			await client.dispose();
+		}
+
+		logger().info("cleaning up test");
+		await cleanup();
+	});
 
 	return {
 		client,

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

@@ -3,6 +3,7 @@ import type {
 	RunnerConfig as EngineRunnerConfig,
 	HibernatingWebSocketMetadata,
 } from "@rivetkit/engine-runner";
+import type { SqliteVfs } from "@rivetkit/sqlite-vfs";
 import { idToStr, Runner } from "@rivetkit/engine-runner";
 import * as cbor from "cbor-x";
 import type { Context as HonoContext } from "hono";
@@ -51,6 +52,7 @@ import {
 import { logger } from "./log";
 
 const RUNNER_SSE_PING_INTERVAL = 1000;
+const RUNNER_STOP_WAIT_MS = 15_000;
 
 // Message ack deadline is 30s on the gateway, but we will ack more frequently
 // in order to minimize the message buffer size on the gateway and to give
@@ -69,6 +71,7 @@ const CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD = 500_000;
 interface ActorHandler {
 	actor?: AnyActorInstance;
 	actorStartPromise?: ReturnType<typeof promiseWithResolvers<void>>;
+	actorStartError?: Error;
 	alarmTimeout?: LongTimeoutHandle;
 }
 
@@ -153,7 +156,7 @@ export class EngineActorDriver implements ActorDriver {
 			onConnected: () => {
 				this.#runnerStarted.resolve(undefined);
 			},
-			onDisconnected: (_code, _reason) => {},
+			onDisconnected: (_code, _reason) => { },
 			onShutdown: () => {
 				this.#runnerStopped.resolve(undefined);
 				this.#isRunnerStopped = true;
@@ -189,6 +192,7 @@ export class EngineActorDriver implements ActorDriver {
 		if (!handler)
 			throw new Error(`Actor handler does not exist ${actorId}`);
 		if (handler.actorStartPromise) await handler.actorStartPromise.promise;
+		if (handler.actorStartError) throw handler.actorStartError;
 		if (!handler.actor) throw new Error("Actor should be loaded");
 		return handler;
 	}
@@ -283,6 +287,16 @@ export class EngineActorDriver implements ActorDriver {
 		return result;
 	}
 
+	/** Creates a SQLite VFS instance for creating KV-backed databases */
+	async createSqliteVfs(): Promise<SqliteVfs> {
+		// Dynamic import keeps @rivetkit/sqlite out of the main entrypoint bundle.
+		// Returning a fresh SqliteVfs gives each actor an isolated sqlite module
+		// instance, avoiding async re-entrancy across actors.
+		const specifier = "@rivetkit/" + "sqlite-vfs";
+		const { SqliteVfs } = await import(specifier);
+		return new SqliteVfs();
+	}
+
 	// MARK: - Actor Lifecycle
 	async loadActor(actorId: string): Promise<AnyActorInstance> {
 		const handler = await this.#loadActorHandler(actorId);
@@ -350,13 +364,38 @@ export class EngineActorDriver implements ActorDriver {
 		await Promise.all(stopPromises);
 		logger().debug({ msg: "all actors stopped" });
 
-		await this.#runner.shutdown(immediate);
+		try {
+			await this.#runner.shutdown(immediate);
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			if (message.includes("WebSocket connection closed during shutdown")) {
+				logger().debug({
+					msg: "ignoring shutdown websocket close race",
+					error: message,
+				});
+			} else {
+				throw error;
+			}
+		}
+
+		const stopped = await Promise.race([
+			this.#runnerStopped.promise.then(() => true),
+			new Promise<false>((resolve) =>
+				setTimeout(() => resolve(false), RUNNER_STOP_WAIT_MS),
+			),
+		]);
+		if (!stopped) {
+			logger().warn({
+				msg: "timed out waiting for runner shutdown",
+				waitMs: RUNNER_STOP_WAIT_MS,
+			});
+		}
 	}
 
 	async serverlessHandleStart(c: HonoContext): Promise<Response> {
 		return streamSSE(c, async (stream) => {
 			// NOTE: onAbort does not work reliably
-			stream.onAbort(() => {});
+			stream.onAbort(() => { });
 			c.req.raw.signal.addEventListener("abort", () => {
 				logger().debug("SSE aborted, shutting down runner");
 
@@ -430,6 +469,7 @@ export class EngineActorDriver implements ActorDriver {
 			};
 			this.#actors.set(actorId, handler);
 		}
+		handler.actorStartError = undefined;
 
 		const name = actorConfig.name as string;
 		invariant(actorConfig.key, "actor should have a key");
@@ -457,8 +497,28 @@ export class EngineActorDriver implements ActorDriver {
 
 			// Create actor instance
 			const definition = lookupInRegistry(this.#config, actorConfig.name);
+
 			handler.actor = await definition.instantiate();
 
+			// Apply protocol limits as per-instance overrides without mutating the shared definition
+			const protocolMetadata = this.#runner.getProtocolMetadata();
+			if (protocolMetadata) {
+				logger().debug({
+					msg: "applying config limits from protocol",
+					protocolMetadata,
+				});
+
+				const stopThresholdMax = Math.max(Number(protocolMetadata.actorStopThreshold) - 1000, 0);
+				handler.actor.overrides.onSleepTimeout = stopThresholdMax;
+				handler.actor.overrides.onDestroyTimeout = stopThresholdMax;
+
+				if (protocolMetadata.serverlessDrainGracePeriod) {
+					const drainMax = Math.max(Number(protocolMetadata.serverlessDrainGracePeriod) - 1000, 0);
+					handler.actor.overrides.runStopTimeout = drainMax;
+					handler.actor.overrides.waitUntilTimeout = drainMax;
+				}
+			}
+
 			// Start actor
 			await handler.actor.start(
 				this,
@@ -471,13 +531,34 @@ export class EngineActorDriver implements ActorDriver {
 
 			logger().debug({ msg: "runner actor started", actorId, name, key });
 		} catch (innerError) {
-			const error = new Error(
-				`Failed to start actor ${actorId}: ${innerError}`,
-				{ cause: innerError },
-			);
+			const error =
+				innerError instanceof Error
+					? new Error(
+						`Failed to start actor ${actorId}: ${innerError.message}`,
+						{ cause: innerError },
+					)
+					: new Error(`Failed to start actor ${actorId}: ${String(innerError)}`);
+			handler.actor = undefined;
+			handler.actorStartError = error;
 			handler.actorStartPromise?.reject(error);
 			handler.actorStartPromise = undefined;
-			throw error;
+			logger().error({
+				msg: "runner actor failed to start",
+				actorId,
+				name,
+				key,
+				err: stringifyError(error),
+			});
+
+			try {
+				this.#runner.stopActor(actorId);
+			} catch (stopError) {
+				logger().debug({
+					msg: "failed to stop actor after start failure",
+					actorId,
+					err: stringifyError(stopError),
+				});
+			}
 		}
 	}
 
@@ -498,7 +579,26 @@ export class EngineActorDriver implements ActorDriver {
 		this.#actorStopIntent.delete(actorId);
 
 		const handler = this.#actors.get(actorId);
-		if (handler?.actor) {
+		if (!handler) {
+			logger().debug({ msg: "no runner actor handler to stop", actorId, reason });
+			return;
+		}
+
+		if (handler.actorStartPromise) {
+			try {
+				logger().debug({ msg: "runner actor stopping before it started, waiting", actorId, generation });
+				await handler.actorStartPromise.promise;
+			} catch (err) {
+				// Start failed, but we still want to clean up the handler
+				logger().debug({
+					msg: "actor start failed during stop, cleaning up handler",
+					actorId,
+					err: stringifyError(err),
+				});
+			}
+		}
+
+		if (handler.actor) {
 			try {
 				await handler.actor.onStop(reason);
 			} catch (err) {
@@ -507,9 +607,10 @@ export class EngineActorDriver implements ActorDriver {
 					err: stringifyError(err),
 				});
 			}
-			this.#actors.delete(actorId);
 		}
 
+		this.#actors.delete(actorId);
+
 		logger().debug({ msg: "runner actor stopped", actorId, reason });
 	}
 
@@ -693,7 +794,7 @@ export class EngineActorDriver implements ActorDriver {
 						entry.bufferedMessageSize >=
 						CONN_BUFFERED_MESSAGE_SIZE_THRESHOLD
 					) {
-						// Reset buffered message size immeidatley (instead
+						// Reset buffered message size immediately (instead
 						// of waiting for onAfterPersistConn) since we may
 						// receive more messages before onAfterPersistConn
 						// is called, which would called saveState
@@ -872,6 +973,7 @@ export class EngineActorDriver implements ActorDriver {
 		// Resolve promise if waiting
 		const handler = this.#actors.get(actor.id);
 		invariant(handler, "missing actor handler in onBeforeActorReady");
+		handler.actorStartError = undefined;
 		handler.actorStartPromise?.resolve();
 		handler.actorStartPromise = undefined;
 

package/src/manager/router.ts

@@ -1,4 +1,3 @@
-import { serveStatic } from "@hono/node-server/serve-static";
 import { createRoute } from "@hono/zod-openapi";
 import * as cbor from "cbor-x";
 import type { Hono } from "hono";
@@ -38,9 +37,10 @@ import {
 	type Actor as ApiActor,
 } from "@/manager-api/actors";
 import { buildActorNames, type RegistryConfig } from "@/registry/config";
-import type { GetUpgradeWebSocket } from "@/utils";
+import { loadRuntimeServeStatic } from "@/utils/serve";
+import type { GetUpgradeWebSocket, Runtime } from "@/utils";
 import { timingSafeEqual } from "@/utils/crypto";
-import { getNodeEnv } from "@/utils/env-vars";
+import { isDev } from "@/utils/env-vars";
 import {
 	buildOpenApiRequestBody,
 	buildOpenApiResponses,
@@ -54,6 +54,7 @@ export function buildManagerRouter(
 	config: RegistryConfig,
 	managerDriver: ManagerDriver,
 	getUpgradeWebSocket: GetUpgradeWebSocket | undefined,
+	runtime: Runtime = "node",
 ) {
 	return createRouter(config.managerBasePath, (router) => {
 		// Actor gateway
@@ -319,13 +320,13 @@ export function buildManagerRouter(
 			});
 
 			router.openapi(route, async (c) => {
-				if (getNodeEnv() === "development" && !config.token) {
+				if (isDev() && !config.token) {
 					logger().warn({
 						msg: "RIVET_TOKEN is not set, skipping KV store access checks in development mode. This endpoint will be disabled in production, unless you set the token.",
 					});
 				}
 
-				if (getNodeEnv() !== "development") {
+				if (!isDev()) {
 					if (!config.token) {
 						throw new RestrictedFeature("KV store access");
 					}
@@ -589,8 +590,21 @@ export function buildManagerRouter(
 		if (config.inspector.enabled) {
 			let inspectorRoot: string | undefined;
 
-
 			router.get("/ui/*", async (c, next) => {
+				let serveStatic;
+				try {
+					serveStatic = await loadRuntimeServeStatic(runtime);
+				} catch (error) {
+					logger().error({
+						msg: "failed to load inspector static file handler",
+						error: stringifyError(error),
+					});
+					return c.text(
+						`Failed to load static file handler for runtime '${runtime}'.`,
+						500,
+					);
+				}
+
 				if (!inspectorRoot) {
 					inspectorRoot = await getInspectorDir();
 				}

package/src/{registry → utils}/serve.ts

@@ -1,12 +1,16 @@
 import type { Hono } from "hono";
-import { detectRuntime, stringifyError } from "../utils";
-import { logger } from "./log";
-import { RegistryConfig } from "./config";
+import { detectRuntime, stringifyError, type Runtime } from "../utils";
+import { RegistryConfig } from "@/registry/config";
+import { logger } from "@/registry/log";
 
 // TODO: Go back to dynamic import for this
 import getPort from "get-port";
 
 const DEFAULT_PORT = 6420;
+export type ServeStatic =
+	typeof import("@hono/node-server/serve-static").serveStatic;
+const serveStaticLoaderPromises: Partial<Record<Runtime, Promise<ServeStatic>>> =
+	{};
 
 /**
  * Finds a free port starting from the given port.
@@ -34,8 +38,8 @@ export async function crossPlatformServe(
 	config: RegistryConfig,
 	managerPort: number,
 	app: Hono<any>,
+	runtime: Runtime = detectRuntime(),
 ): Promise<{ upgradeWebSocket: any }> {
-	const runtime = detectRuntime();
 	logger().debug({ msg: "detected runtime for serve", runtime });
 
 	switch (runtime) {
@@ -50,6 +54,36 @@ export async function crossPlatformServe(
 	}
 }
 
+export async function loadRuntimeServeStatic(
+	runtime: Runtime,
+): Promise<ServeStatic> {
+	if (!serveStaticLoaderPromises[runtime]) {
+		if (runtime === "node") {
+			const nodeServeStaticModule = "@hono/node-server/serve-static";
+			serveStaticLoaderPromises[runtime] = import(
+				/* webpackIgnore: true */
+				nodeServeStaticModule
+			).then((x) => x.serveStatic);
+		} else if (runtime === "bun") {
+			const bunModule = "hono/bun";
+			serveStaticLoaderPromises[runtime] = import(
+				/* webpackIgnore: true */
+				bunModule
+			).then((x) => x.serveStatic as ServeStatic);
+		} else if (runtime === "deno") {
+			const denoModule = "hono/deno";
+			serveStaticLoaderPromises[runtime] = import(
+				/* webpackIgnore: true */
+				denoModule
+			).then((x) => x.serveStatic as ServeStatic);
+		} else {
+			throw new Error(`unsupported runtime: ${runtime}`);
+		}
+	}
+
+	return await serveStaticLoaderPromises[runtime]!;
+}
+
 async function serveNode(
 	config: RegistryConfig,
 	managerPort: number,

package/src/workflow/context.ts

@@ -212,6 +212,7 @@ export class ActorWorkflowContext<
 			body: unknown,
 		): Promise<void>;
 		async function send(name: string, body: unknown): Promise<void> {
+			self.#ensureActorAccess("queue.send");
 			await self.#runCtx.queue.send(name as never, body as never);
 		}
 
@@ -445,10 +446,12 @@ export class ActorWorkflowContext<
 	}
 
 	keepAwake<T>(promise: Promise<T>): Promise<T> {
+		this.#ensureActorAccess("keepAwake");
 		return this.#runCtx.keepAwake(promise);
 	}
 
 	waitUntil(promise: Promise<void>): void {
+		this.#ensureActorAccess("waitUntil");
 		this.#runCtx.waitUntil(promise);
 	}
 
@@ -465,6 +468,7 @@ export class ActorWorkflowContext<
 		...args: Array<unknown>
 	): void;
 	broadcast(name: string, ...args: Array<unknown>): void {
+		this.#ensureActorAccess("broadcast");
 		this.#runCtx.broadcast(
 			name as never,
 			...((args as unknown[]) as never[]),