rivetkit 2.3.0-rc.6 → 2.3.0-rc.8

package/src/registry/native.ts

@@ -2,6 +2,7 @@ import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
 import {
 	ACTOR_CONTEXT_INTERNAL_SYMBOL,
 	CONN_STATE_MANAGER_SYMBOL,
+	RAW_STATE_SYMBOL,
 	getRunFunction,
 	getRunInspectorConfig,
 	type WorkflowInspectorConfig,
@@ -33,6 +34,10 @@ import { HEADER_CONN_PARAMS } from "@/common/actor-router-consts";
 import type { AnyDatabaseProvider } from "@/common/database/config";
 import { wrapJsNativeDatabase } from "@/common/database/native-database";
 import { decodeWorkflowHistoryTransport } from "@/common/inspector-transport";
+import {
+	assertJsonCompatValue,
+	type JsonCompatValue,
+} from "@/common/encoding";
 import { deconstructError, stringifyError } from "@/common/utils";
 import type {
 	RivetCloseEvent,
@@ -54,6 +59,7 @@ import {
 } from "@/serde";
 import { getEnvUniversal, VERSION } from "@/utils";
 import { logger } from "./log";
+import { createWriteThroughProxy } from "./write-through-proxy";
 import { loadNapiRuntime } from "./napi-runtime";
 import {
 	type NativeValidationConfig,
@@ -337,6 +343,15 @@ function databaseNotConfiguredError(): RivetError {
 	);
 }
 
+function databaseClientNotReadyError(): RivetError {
+	return new RivetError(
+		"actor",
+		"database_client_not_ready",
+		"actor database client was not initialized before user code ran. this is an internal lifecycle error; the migration callback should have pre-warmed the client. file an issue if you can reproduce.",
+		{ public: true },
+	);
+}
+
 function stateNotEnabledError(): RivetError {
 	return new RivetError(
 		"actor",
@@ -406,7 +421,20 @@ async function cleanupNativeSleepRuntimeState(
 	runtime: CoreRuntime,
 	ctx: ActorContextHandle,
 ): Promise<void> {
-	await runtime.actorWaitForTrackedShutdownWork(ctx);
+	const waitStarted = Date.now();
+	const drained = await runtime.actorWaitForTrackedShutdownWork(ctx);
+	const waitMs = Date.now() - waitStarted;
+	if (drained) {
+		logger().debug({
+			msg: "sleep cleanup: tracked shutdown work drained",
+			waitMs,
+		});
+	} else {
+		logger().warn({
+			msg: "sleep cleanup: shutdown deadline reached before tracked work drained; closing DB anyway",
+			waitMs,
+		});
+	}
 	await closeNativeDatabaseClient(runtime, ctx);
 	await closeNativeSqlDatabase(runtime, ctx);
 	clearNativeRuntimeState(runtime, ctx);
@@ -583,7 +611,7 @@ function decodeValue<T>(value?: RuntimeBytes | null): T {
 }
 
 function encodeValue(value: unknown): RuntimeBytes {
-	return encodeCborCompat(value);
+	return encodeCborCompat(value as JsonCompatValue);
 }
 
 function unwrapTsfnPayload<T>(error: unknown, payload: T): T {
@@ -1058,54 +1086,6 @@ function decodeArgs(value?: RuntimeBytes | null): unknown[] {
 			: [decoded];
 }
 
-function createWriteThroughProxy<T>(
-	value: T,
-	commit: (next: T) => void,
-	beforeChange?: () => void,
-): T {
-	if (!value || typeof value !== "object") {
-		return value;
-	}
-
-	const proxies = new WeakMap<object, object>();
-	const wrap = (target: object): object => {
-		const cached = proxies.get(target);
-		if (cached) {
-			return cached;
-		}
-
-		const proxy = new Proxy(target, {
-			get(innerTarget, property, receiver) {
-				const result = Reflect.get(innerTarget, property, receiver);
-				return result && typeof result === "object"
-					? wrap(result as object)
-					: result;
-			},
-			set(innerTarget, property, nextValue, receiver) {
-				beforeChange?.();
-				const updated = Reflect.set(
-					innerTarget,
-					property,
-					nextValue,
-					receiver,
-				);
-				commit(value);
-				return updated;
-			},
-			deleteProperty(innerTarget, property) {
-				beforeChange?.();
-				const updated = Reflect.deleteProperty(innerTarget, property);
-				commit(value);
-				return updated;
-			},
-		});
-
-		proxies.set(target, proxy);
-		return proxy;
-	};
-
-	return wrap(value as object) as T;
-}
 
 function buildRequest(init: {
 	method: string;
@@ -1196,14 +1176,21 @@ class NativeConnAdapter {
 		);
 	}
 
+	[RAW_STATE_SYMBOL](): unknown {
+		return this.#readState();
+	}
+
 	get state(): unknown {
 		const nextState = this.#readState();
 		return createWriteThroughProxy(nextState, (nextValue) => {
 			this.#writeState(nextValue, { writeNative: true });
+		}, (newValue) => {
+			assertJsonCompatValue(newValue);
 		});
 	}
 
 	set state(value: unknown) {
+		assertJsonCompatValue(value);
 		this.#writeState(value, { writeNative: true });
 	}
 
@@ -2315,6 +2302,90 @@ class TrackedWebSocketHandleAdapter implements UniversalWebSocket {
 	}
 }
 
+class NativeConnectionMap implements ReadonlyMap<string, NativeConnAdapter> {
+	#runtime: CoreRuntime;
+	#ctx: ActorContextHandle;
+	#schemas: NativeValidationConfig;
+
+	constructor(
+		runtime: CoreRuntime,
+		ctx: ActorContextHandle,
+		schemas: NativeValidationConfig,
+	) {
+		this.#runtime = runtime;
+		this.#ctx = ctx;
+		this.#schemas = schemas;
+	}
+
+	#connToAdapter(conn: ConnHandle): NativeConnAdapter {
+		return new NativeConnAdapter(
+			this.#runtime,
+			conn,
+			this.#schemas,
+			this.#ctx,
+			(connId) =>
+				callNativeSync(() =>
+					this.#runtime.actorQueueHibernationRemoval(
+						this.#ctx,
+						connId,
+					),
+				),
+		);
+	}
+
+	get size(): number {
+		return callNativeSync(() => this.#runtime.actorConns(this.#ctx)).length;
+	}
+
+	get(key: string): NativeConnAdapter | undefined {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		const conn = conns.find(
+			(c) => this.#runtime.connId(c) === key,
+		);
+		if (!conn) return undefined;
+		return this.#connToAdapter(conn);
+	}
+
+	has(key: string): boolean {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		return conns.some((c) => this.#runtime.connId(c) === key);
+	}
+
+	keys(): MapIterator<string> {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		return conns.map((c) => this.#runtime.connId(c))[Symbol.iterator]() satisfies MapIterator<string>;
+	}
+
+	values(): MapIterator<NativeConnAdapter> {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		return conns.map((c) => this.#connToAdapter(c))[Symbol.iterator]() satisfies MapIterator<NativeConnAdapter>;
+	}
+
+	entries(): MapIterator<[string, NativeConnAdapter]> {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		return conns.map(
+			(c) => [this.#runtime.connId(c), this.#connToAdapter(c)] as [string, NativeConnAdapter],
+		)[Symbol.iterator]() satisfies MapIterator<[string, NativeConnAdapter]>;
+	}
+
+	forEach(
+		callback: (value: NativeConnAdapter, key: string, map: ReadonlyMap<string, NativeConnAdapter>) => void,
+		thisArg?: unknown,
+	): void {
+		const conns = callNativeSync(() => this.#runtime.actorConns(this.#ctx));
+		for (const conn of conns) {
+			const id = this.#runtime.connId(conn);
+			callback.call(thisArg, this.#connToAdapter(conn), id, this);
+		}
+	}
+
+	[Symbol.iterator](): MapIterator<[string, NativeConnAdapter]> {
+		return this.entries();
+	}
+
+	readonly [Symbol.toStringTag] = "NativeConnectionMap";
+}
+
 export class ActorContextHandleAdapter {
 	#runtime: CoreRuntime;
 	#ctx: ActorContextHandle;
@@ -2323,9 +2394,9 @@ export class ActorContextHandleAdapter {
 	#abortSignalCleanup?: () => void;
 	#client?: AnyClient;
 	#clientFactory?: () => AnyClient;
+	#connMap?: NativeConnectionMap;
 	#databaseProvider?: Exclude<AnyDatabaseProvider, undefined>;
 	#db?: unknown;
-	#dbProxy?: unknown;
 	#dispatchCancelToken?: CancellationTokenHandle;
 	#kv?: NativeKvAdapter;
 	#queue?: NativeQueueAdapter;
@@ -2388,32 +2459,25 @@ export class ActorContextHandleAdapter {
 			throw databaseNotConfiguredError();
 		}
 
-		if (!this.#dbProxy) {
-			this.#dbProxy = new Proxy(
-				{},
-				{
-					get: (_target, property) => {
-						if (property === "then") {
-							return undefined;
-						}
+		if (this.#db) {
+			return this.#db;
+		}
 
-						return async (...args: Array<unknown>) => {
-							const client = await this.ensureDatabaseClient();
-							const value = Reflect.get(
-								client as object,
-								property,
-							);
-							if (typeof value !== "function") {
-								return value;
-							}
-							return await value.apply(client, args);
-						};
-					},
-				},
-			);
+		const runtimeState = getNativeRuntimeState(this.#runtime, this.#ctx);
+		const cachedClient = runtimeState.databaseClient;
+		if (cachedClient) {
+			this.#db = cachedClient.client;
+			return this.#db;
 		}
 
-		return this.#dbProxy;
+		throw databaseClientNotReadyError();
+	}
+
+	[RAW_STATE_SYMBOL](): unknown {
+		if (!this.#stateEnabled) {
+			throw stateNotEnabledError();
+		}
+		return this.#readState();
 	}
 
 	get state(): unknown {
@@ -2426,8 +2490,9 @@ export class ActorContextHandleAdapter {
 			(nextValue) => {
 				this.#writeState(nextValue, { scheduleSave: true });
 			},
-			() => {
+			(newValue) => {
 				this.#assertCanMutateState();
+				assertJsonCompatValue(newValue);
 			},
 		);
 	}
@@ -2437,6 +2502,7 @@ export class ActorContextHandleAdapter {
 			throw stateNotEnabledError();
 		}
 		this.#assertCanMutateState();
+		assertJsonCompatValue(value);
 		this.#writeState(value, { scheduleSave: true });
 	}
 
@@ -2503,27 +2569,11 @@ export class ActorContextHandleAdapter {
 		return callNativeSync(() => this.#runtime.actorRegion(this.#ctx));
 	}
 
-	get conns(): Map<string, NativeConnAdapter> {
-		return new Map(
-			callNativeSync(() => this.#runtime.actorConns(this.#ctx)).map(
-				(conn) => [
-					this.#runtime.connId(conn),
-					new NativeConnAdapter(
-						this.#runtime,
-						conn,
-						this.#schemas,
-						this.#ctx,
-						(connId) =>
-							callNativeSync(() =>
-								this.#runtime.actorQueueHibernationRemoval(
-									this.#ctx,
-									connId,
-								),
-							),
-					),
-				],
-			),
-		);
+	get conns(): ReadonlyMap<string, NativeConnAdapter> {
+		if (!this.#connMap) {
+			this.#connMap = new NativeConnectionMap(this.#runtime, this.#ctx, this.#schemas);
+		}
+		return this.#connMap;
 	}
 
 	get log() {
@@ -2754,22 +2804,41 @@ export class ActorContextHandleAdapter {
 	}
 
 	keepAwake<T>(promise: Promise<T>): Promise<T> {
+		const startedAt = Date.now();
+		logger().debug({
+			msg: "keepAwake registered",
+			at: startedAt,
+		});
 		const trackedPromise = Promise.resolve(promise)
-			.catch((error) => {
-				logger().warn({
-					msg: "keepAwake promise rejected",
-					error: stringifyError(error),
-				});
-			})
+			.then(
+				() => {
+					logger().debug({
+						msg: "keepAwake promise resolved",
+						durationMs: Date.now() - startedAt,
+					});
+				},
+				(error) => {
+					logger().warn({
+						msg: "keepAwake promise rejected",
+						durationMs: Date.now() - startedAt,
+						error: stringifyError(error),
+					});
+				},
+			)
 			.then(() => null);
 		try {
 			callNativeSync(() =>
 				this.#runtime.actorKeepAwake(this.#ctx, trackedPromise),
 			);
 		} catch (error) {
-			if (!isClosedTaskRegistrationError(error)) {
-				throw error;
+			if (isClosedTaskRegistrationError(error)) {
+				logger().warn({
+					msg: "keepAwake registration dropped (teardown already started); promise will not delay grace",
+					error: stringifyError(error),
+				});
+				return promise;
 			}
+			throw error;
 		}
 		return promise;
 	}
@@ -3502,6 +3571,10 @@ export function buildNativeFactory(
 							getNativeWorkflowInspector(ctx) !== undefined,
 					});
 				} catch (error) {
+					logger().error({
+						msg: "error replaying workflow history",
+						error,
+					});
 					return errorResponse(error);
 				}
 			}
@@ -3681,6 +3754,10 @@ export function buildNativeFactory(
 					);
 					return jsonResponse({ output });
 				} catch (error) {
+					logger().error({
+						msg: "Error handling inspector action request",
+						error,
+					});
 					return errorResponse(error);
 				}
 			}
@@ -3695,6 +3772,10 @@ export function buildNativeFactory(
 				{ status: 404 },
 			);
 		} catch (error) {
+			logger().error({
+				msg: "Error handling inspector request",
+				error,
+			});
 			return errorResponse(error);
 		} finally {
 			await actorCtx.dispose();
@@ -4605,6 +4686,14 @@ export async function buildConfiguredRegistry(config: RegistryConfig): Promise<{
 	serveConfig: RuntimeServeConfig;
 }> {
 	const runtime = await loadConfiguredRuntime(config);
+	if (runtime.kind === "napi") {
+		// Start Node.js runtime health metrics collection (event loop lag,
+		// GC, heap, CPU, libuv handles). Only available on the native NAPI
+		// runtime; wasm/edge hosts do not expose perf_hooks/v8 the same
+		// way and have no Rust-side prometheus collectors loaded.
+		const { startProcessMetrics } = await import("./process-metrics");
+		startProcessMetrics();
+	}
 	return buildRegistryWithRuntime(
 		normalizeRuntimeConfig(config, runtime),
 		runtime,

package/src/registry/process-metrics.ts

@@ -0,0 +1,183 @@
+/**
+ * Node.js runtime health metrics.
+ *
+ * Collects JS-internal data (event loop lag, GC, heap, libuv handles,
+ * event loop utilization, CPU) using Node built-ins (`node:perf_hooks`,
+ * `process`, `node:v8`, `PerformanceObserver`) and pushes them across NAPI
+ * into Rust-side prometheus collectors registered with
+ * `rivet_metrics::REGISTRY` so they appear on the existing `/metrics`
+ * endpoint.
+ *
+ * All data collection happens here in TypeScript. The NAPI bridge is pure
+ * type marshalling and the Rust side only registers + stores the metrics.
+ */
+import { monitorEventLoopDelay, performance, PerformanceObserver } from "node:perf_hooks";
+import { getHeapStatistics } from "node:v8";
+import * as napi from "@rivetkit/rivetkit-napi";
+
+// Some napi process-metrics symbols may be missing on older native binaries
+// (the auto-generated index.js destructures them as `undefined` if the
+// underlying `.node` was built before they were added). Guard each call so
+// the metrics collection runs as a no-op instead of throwing
+// `TypeError: napi.jsXxx is not a function` on every interval tick.
+function callIfFn<T extends unknown[]>(
+	fn: ((...args: T) => void) | undefined,
+	...args: T
+): void {
+	if (typeof fn === "function") {
+		fn(...args);
+	}
+}
+
+const SCRAPE_INTERVAL_MS = 5_000;
+const HEARTBEAT_INTERVAL_MS = 100;
+const EVENTLOOP_DELAY_RESOLUTION_MS = 20;
+const NS_PER_SECOND = 1e9;
+const US_PER_SECOND = 1e6;
+
+// V8 GC kind bitfield from Node's perf_hooks documentation. A `gc` performance
+// entry's `kind` field is one of these values.
+const GC_KIND_NAMES: Record<number, string> = {
+	1: "minor",
+	2: "major",
+	4: "incremental",
+	8: "weakcb",
+};
+
+interface ProcessMetricsState {
+	scrapeInterval: NodeJS.Timeout;
+	heartbeatInterval: NodeJS.Timeout;
+	gcObserver: PerformanceObserver;
+	eventLoopHistogram: ReturnType<typeof monitorEventLoopDelay>;
+	lastCpuUsage: NodeJS.CpuUsage;
+	lastEventLoopUtilization: ReturnType<typeof performance.eventLoopUtilization>;
+}
+
+let state: ProcessMetricsState | undefined;
+
+export function startProcessMetrics(): void {
+	if (state) {
+		return;
+	}
+
+	const eventLoopHistogram = monitorEventLoopDelay({
+		resolution: EVENTLOOP_DELAY_RESOLUTION_MS,
+	});
+	eventLoopHistogram.enable();
+
+	const gcObserver = new PerformanceObserver((list) => {
+		for (const entry of list.getEntries()) {
+			const kind =
+				(entry as PerformanceEntry & { detail?: { kind?: number }; kind?: number }).detail
+					?.kind ??
+				(entry as PerformanceEntry & { kind?: number }).kind;
+			if (typeof kind !== "number") continue;
+			const kindName = GC_KIND_NAMES[kind];
+			if (!kindName) continue;
+			// `entry.duration` is in milliseconds; convert to seconds.
+			callIfFn(napi.jsObserveGcDuration, kindName, entry.duration / 1000);
+		}
+	});
+	gcObserver.observe({ entryTypes: ["gc"], buffered: false });
+
+	const lastCpuUsage = process.cpuUsage();
+	const lastEventLoopUtilization = performance.eventLoopUtilization();
+
+	const heartbeatInterval = setInterval(() => {
+		callIfFn(napi.jsSetEventloopHeartbeatTsMs, Date.now());
+	}, HEARTBEAT_INTERVAL_MS);
+	heartbeatInterval.unref();
+
+	const scrapeInterval = setInterval(() => {
+		try {
+			collectAndPush();
+		} catch {
+			// Collection errors must never bring down the process; metrics
+			// are best-effort.
+		}
+	}, SCRAPE_INTERVAL_MS);
+	scrapeInterval.unref();
+
+	state = {
+		scrapeInterval,
+		heartbeatInterval,
+		gcObserver,
+		eventLoopHistogram,
+		lastCpuUsage,
+		lastEventLoopUtilization,
+	};
+
+	// Emit one snapshot immediately so freshly-scraped instances have data.
+	callIfFn(napi.jsSetEventloopHeartbeatTsMs, Date.now());
+	try {
+		collectAndPush();
+	} catch {
+		// As above; best-effort.
+	}
+}
+
+export function stopProcessMetrics(): void {
+	if (!state) {
+		return;
+	}
+	clearInterval(state.scrapeInterval);
+	clearInterval(state.heartbeatInterval);
+	state.gcObserver.disconnect();
+	state.eventLoopHistogram.disable();
+	state = undefined;
+}
+
+function collectAndPush(): void {
+	if (!state) return;
+
+	// Event loop delay quantiles. `monitorEventLoopDelay()` reports values in
+	// nanoseconds; convert to seconds. Reset after reading so the next window
+	// reflects only the new interval.
+	const hist = state.eventLoopHistogram;
+	callIfFn(napi.jsSetEventloopLagQuantile, "p50", hist.percentile(50) / NS_PER_SECOND);
+	callIfFn(napi.jsSetEventloopLagQuantile, "p90", hist.percentile(90) / NS_PER_SECOND);
+	callIfFn(napi.jsSetEventloopLagQuantile, "p99", hist.percentile(99) / NS_PER_SECOND);
+	callIfFn(napi.jsSetEventloopLagQuantile, "max", hist.max / NS_PER_SECOND);
+	hist.reset();
+
+	// Event loop utilization delta over the scrape window.
+	const nextElu = performance.eventLoopUtilization();
+	const eluDelta = performance.eventLoopUtilization(nextElu, state.lastEventLoopUtilization);
+	state.lastEventLoopUtilization = nextElu;
+	callIfFn(napi.jsSetEventloopUtilization, eluDelta.utilization);
+
+	// CPU usage delta. `process.cpuUsage()` returns microseconds.
+	const nextCpu = process.cpuUsage();
+	const userDeltaUs = nextCpu.user - state.lastCpuUsage.user;
+	const systemDeltaUs = nextCpu.system - state.lastCpuUsage.system;
+	state.lastCpuUsage = nextCpu;
+	if (userDeltaUs > 0) {
+		callIfFn(napi.jsAddProcessCpuSeconds, "user", userDeltaUs / US_PER_SECOND);
+	}
+	if (systemDeltaUs > 0) {
+		callIfFn(napi.jsAddProcessCpuSeconds, "system", systemDeltaUs / US_PER_SECOND);
+	}
+
+	// Memory + heap.
+	const mem = process.memoryUsage();
+	callIfFn(napi.jsSetProcessResidentMemoryBytes, mem.rss);
+	callIfFn(napi.jsSetHeapBytes, "used", mem.heapUsed);
+	callIfFn(napi.jsSetHeapBytes, "total", mem.heapTotal);
+	const heapLimit = getHeapStatistics().heap_size_limit;
+	callIfFn(napi.jsSetHeapBytes, "limit", heapLimit);
+
+	// libuv active handles + requests. These are unstable Node internals
+	// guarded behind underscore-prefixed names; if a future Node release
+	// removes them the try/catch above keeps the rest of the collection
+	// alive.
+	const proc = process as unknown as {
+		_getActiveHandles?: () => unknown[];
+		_getActiveRequests?: () => unknown[];
+	};
+	if (typeof proc._getActiveHandles === "function") {
+		callIfFn(napi.jsSetActiveHandles, proc._getActiveHandles().length);
+	}
+	if (typeof proc._getActiveRequests === "function") {
+		callIfFn(napi.jsSetActiveRequests, proc._getActiveRequests().length);
+	}
+}

package/src/registry/runtime.ts

@@ -257,10 +257,9 @@ export interface RuntimeServerlessResponseHead {
 	headers: Record<string, string>;
 }
 
-export interface RuntimeRegistryRouteResponse {
-	status: number;
-	headers: Record<string, string>;
-	body: RuntimeBytes;
+export interface RuntimeRegistryDiagnostics {
+	mode: string;
+	envoyActiveActorCount?: number | null;
 }
 
 export type RuntimeServerlessStreamEvent =
@@ -320,15 +319,9 @@ export interface CoreRuntime {
 		cancelToken: CancellationTokenHandle,
 		config: RuntimeServeConfig,
 	): Promise<RuntimeServerlessResponseHead>;
-	registryHealth?(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse>;
-	registryMetadata?(
-		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse>;
-	registryMetrics?(
+	registryDiagnostics?(
 		registry: RegistryHandle,
-	): Promise<RuntimeRegistryRouteResponse>;
+	): Promise<RuntimeRegistryDiagnostics>;
 	createActorFactory(
 		callbacks: object,
 		config?: RuntimeActorConfig | undefined | null,

package/src/registry/wasm-runtime.ts

@@ -33,7 +33,6 @@ import type {
 	RuntimeQueueTryNextBatchOptions,
 	RuntimeQueueWaitOptions,
 	RuntimeRequestSaveOpts,
-	RuntimeRegistryRouteResponse,
 	RuntimeServeConfig,
 	RuntimeServerlessRequest,
 	RuntimeServerlessResponseHead,
@@ -271,18 +270,8 @@ export class WasmCoreRuntime implements CoreRuntime {
 		await callWasm(() => asWasmRegistry(registry).shutdown());
 	}
 
-	async registryHealth(): Promise<RuntimeRegistryRouteResponse> {
-		return {
-			status: 200,
-			headers: { "content-type": "application/json" },
-			body: new TextEncoder().encode(
-				JSON.stringify({
-					status: "ok",
-					runtime: "rivetkit",
-					version: "wasm",
-				}),
-			),
-		};
+	async registryDiagnostics(): Promise<{ mode: string; envoyActiveActorCount: null }> {
+		return { mode: "wasm", envoyActiveActorCount: null };
 	}
 
 	async handleServerlessRequest(