rivetkit 2.3.11-rc.8 → 2.3.11

package/src/registry/wasm-runtime.ts

@@ -1,11 +1,3 @@
-import type {
-	ActorContext as WasmActorContext,
-	ActorFactory as WasmActorFactory,
-	CancellationToken as WasmCancellationToken,
-	ConnHandle as WasmConnHandle,
-	CoreRegistry as WasmCoreRegistry,
-	WebSocketHandle as WasmWebSocketHandle,
-} from "@rivetkit/rivetkit-wasm";
 import { decodeBridgeRivetError, RivetError } from "@/actor/errors";
 import type {
 	WasmRuntimeBindings,
@@ -15,6 +7,7 @@ import type {
 import type {
 	ActorContextHandle,
 	ActorFactoryHandle,
+	ActorStateTransactionHandle,
 	CancellationTokenHandle,
 	ConnHandle,
 	CoreRuntime,
@@ -23,6 +16,8 @@ import type {
 	RuntimeActorKeySegment,
 	RuntimeApplicationListenerConfig,
 	RuntimeBytes,
+	RuntimeCronFire,
+	RuntimeCronJobInfo,
 	RuntimeHttpRequest,
 	RuntimeInspectorSnapshot,
 	RuntimeKvEntry,
@@ -34,12 +29,10 @@ import type {
 	RuntimeQueueNextBatchOptions,
 	RuntimeQueueTryNextBatchOptions,
 	RuntimeQueueWaitOptions,
-	RuntimeCronFire,
-	RuntimeCronJobInfo,
 	RuntimeRegistryRouteResponse,
 	RuntimeRequestSaveOpts,
-	RuntimeServeConfig,
 	RuntimeScheduledEventInfo,
+	RuntimeServeConfig,
 	RuntimeServerlessRequest,
 	RuntimeServerlessResponseHead,
 	RuntimeServerlessStreamCallback,
@@ -62,6 +55,35 @@ type WasmBindings = WasmRuntimeBindings;
 export type WasmInitInput = WasmRuntimeInitInput;
 type AnyFunction = (...args: unknown[]) => unknown;
 type WasmRuntimeLoadConfig = Pick<WasmRuntimeConfig, "bindings" | "initInput">;
+type WasmActorContext = object;
+type WasmActorFactory = object;
+type WasmConnHandle = object;
+type WasmWebSocketHandle = object;
+
+interface WasmCancellationToken {
+	aborted(): boolean;
+	cancel(): void;
+	onCancelled(callback: (...args: unknown[]) => unknown): void;
+}
+
+interface WasmCoreRegistry {
+	register(name: string, factory: WasmActorFactory): void;
+	serve(config: RuntimeServeConfig): Promise<void>;
+	shutdown(): Promise<void>;
+}
+
+interface WasmConstructors {
+	CoreRegistry: new () => WasmCoreRegistry;
+	ActorFactory: new (
+		callbacks: object,
+		config: RuntimeActorConfig | undefined | null,
+	) => WasmActorFactory;
+	CancellationToken: new () => WasmCancellationToken;
+}
+
+function asWasmConstructors(bindings: WasmBindings): WasmConstructors {
+	return bindings as unknown as WasmConstructors;
+}
 
 function asWasmRegistry(handle: RegistryHandle): WasmCoreRegistry {
 	return handle as unknown as WasmCoreRegistry;
@@ -235,11 +257,11 @@ function childHandle<T>(handle: unknown, name: string): T {
 export class WasmCoreRuntime implements CoreRuntime {
 	readonly kind = "wasm";
 
-	#bindings: WasmBindings;
+	#constructors: WasmConstructors;
 	#sql = new WeakMap<WasmActorContext, RuntimeSqlDatabase>();
 
 	constructor(bindings: WasmBindings) {
-		this.#bindings = bindings;
+		this.#constructors = asWasmConstructors(bindings);
 	}
 
 	#actorSql(ctx: ActorContextHandle): RuntimeSqlDatabase {
@@ -254,7 +276,7 @@ export class WasmCoreRuntime implements CoreRuntime {
 
 	createRegistry(): RegistryHandle {
 		return callWasmSync(() =>
-			asRegistryHandle(new this.#bindings.CoreRegistry()),
+			asRegistryHandle(new this.#constructors.CoreRegistry()),
 		);
 	}
 
@@ -342,7 +364,7 @@ export class WasmCoreRuntime implements CoreRuntime {
 	): ActorFactoryHandle {
 		return callWasmSync(() =>
 			asActorFactoryHandle(
-				new this.#bindings.ActorFactory(callbacks, config),
+				new this.#constructors.ActorFactory(callbacks, config),
 			),
 		);
 	}
@@ -350,7 +372,7 @@ export class WasmCoreRuntime implements CoreRuntime {
 	createCancellationToken(): CancellationTokenHandle {
 		return callWasmSync(
 			() =>
-				new this.#bindings.CancellationToken() as unknown as CancellationTokenHandle,
+				new this.#constructors.CancellationToken() as unknown as CancellationTokenHandle,
 		);
 	}
 
@@ -399,6 +421,17 @@ export class WasmCoreRuntime implements CoreRuntime {
 		);
 	}
 
+	async actorSetRunWakeAt(
+		ctx: ActorContextHandle,
+		timestampMs?: number | undefined | null,
+	): Promise<void> {
+		await callHandleAsync(
+			asWasmActorContext(ctx),
+			"setRunWakeAt",
+			optionalWasmNumber(timestampMs),
+		);
+	}
+
 	actorRequestSave(
 		ctx: ActorContextHandle,
 		opts?: RuntimeRequestSaveOpts | undefined | null,
@@ -748,9 +781,10 @@ export class WasmCoreRuntime implements CoreRuntime {
 	async actorSqlBeginTransaction(
 		ctx: ActorContextHandle,
 		timeoutMs?: number,
+		name?: string,
 	): Promise<SqliteTransactionHandle> {
 		return (await callWasm(() =>
-			this.#actorSql(ctx).beginTransaction(timeoutMs),
+			this.#actorSql(ctx).beginTransaction(timeoutMs, name),
 		)) as unknown as SqliteTransactionHandle;
 	}
 
@@ -802,6 +836,61 @@ export class WasmCoreRuntime implements CoreRuntime {
 			).rollback(),
 		);
 	}
+	async actorBeginStateTransaction(
+		ctx: ActorContextHandle,
+		timeoutMs?: number,
+	): Promise<ActorStateTransactionHandle> {
+		return (await callWasm(() =>
+			(
+				asWasmActorContext(ctx) as unknown as {
+					beginStateTransaction(
+						timeoutMs?: number,
+					): Promise<ActorStateTransactionHandle>;
+				}
+			).beginStateTransaction(timeoutMs),
+		)) as ActorStateTransactionHandle;
+	}
+
+	async actorStateTransactionExecute(
+		transaction: ActorStateTransactionHandle,
+		sql: string,
+		params?: RuntimeSqlBindParams,
+	): Promise<RuntimeSqlExecuteResult> {
+		const result = await callWasm(() =>
+			(
+				transaction as unknown as {
+					execute(
+						sql: string,
+						params?: RuntimeSqlBindParams,
+					): Promise<RuntimeSqlExecuteResult>;
+				}
+			).execute(sql, params),
+		);
+		return normalizeRuntimeSqlExecuteResult(result);
+	}
+
+	async actorStateTransactionCommit(
+		transaction: ActorStateTransactionHandle,
+		payload: RuntimeStateDeltaPayload,
+	): Promise<void> {
+		await callWasm(() =>
+			(
+				transaction as unknown as {
+					commit(payload: RuntimeStateDeltaPayload): Promise<void>;
+				}
+			).commit(payload),
+		);
+	}
+
+	async actorStateTransactionRollback(
+		transaction: ActorStateTransactionHandle,
+	): Promise<void> {
+		await callWasm(() =>
+			(
+				transaction as unknown as { rollback(): Promise<void> }
+			).rollback(),
+		);
+	}
 
 	async actorSqlQuery(
 		ctx: ActorContextHandle,
@@ -912,6 +1001,22 @@ export class WasmCoreRuntime implements CoreRuntime {
 		);
 	}
 
+	async actorQueueCompletePersisted(
+		ctx: ActorContextHandle,
+		messageId: bigint,
+		expectedName: string,
+		response?: RuntimeBytes | undefined | null,
+	): Promise<boolean> {
+		const queue = childHandle(asWasmActorContext(ctx), "queue");
+		return await callHandleAsync(
+			queue,
+			"completePersisted",
+			messageId,
+			expectedName,
+			response,
+		);
+	}
+
 	async actorQueueEnqueueAndWait(
 		ctx: ActorContextHandle,
 		name: string,

package/src/registry/write-through-proxy.ts

@@ -38,3 +38,104 @@ export function createWriteThroughProxy<T>(
 		},
 	) as T;
 }
+
+/**
+ * Returns the raw target behind an `@rivetkit/on-change` proxy, following
+ * chains of proxies wrapping proxies until reaching a plain value.
+ */
+function unwrapProxy(value: unknown): unknown {
+	let current = value;
+	while (current !== null && typeof current === "object") {
+		const target = onChange.target(current as Record<string, any>);
+		if (target === current) {
+			break;
+		}
+		current = target;
+	}
+	return current;
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+	const proto = Object.getPrototypeOf(value as object);
+	return proto === Object.prototype || proto === null;
+}
+
+function unwrapDeep(value: unknown, seen: Set<object>): unknown {
+	const unwrapped = unwrapProxy(value);
+	if (!unwrapped || typeof unwrapped !== "object") {
+		return unwrapped;
+	}
+	if (seen.has(unwrapped)) {
+		return unwrapped;
+	}
+	seen.add(unwrapped);
+
+	if (Array.isArray(unwrapped)) {
+		for (let i = 0; i < unwrapped.length; i++) {
+			const child = unwrapDeep(unwrapped[i], seen);
+			if (child !== unwrapped[i]) {
+				unwrapped[i] = child;
+			}
+		}
+		return unwrapped;
+	}
+
+	if (unwrapped instanceof Map) {
+		const replacements: [unknown, unknown, unknown][] = [];
+		for (const [key, child] of unwrapped.entries()) {
+			const nextKey = unwrapDeep(key, seen);
+			const nextChild = unwrapDeep(child, seen);
+			if (nextKey !== key || nextChild !== child) {
+				replacements.push([key, nextKey, nextChild]);
+			}
+		}
+		for (const [key, nextKey, nextChild] of replacements) {
+			if (nextKey !== key) {
+				unwrapped.delete(key);
+			}
+			unwrapped.set(nextKey, nextChild);
+		}
+		return unwrapped;
+	}
+
+	if (unwrapped instanceof Set) {
+		const replacements: [unknown, unknown][] = [];
+		for (const child of unwrapped.values()) {
+			const next = unwrapDeep(child, seen);
+			if (next !== child) {
+				replacements.push([child, next]);
+			}
+		}
+		for (const [child, next] of replacements) {
+			unwrapped.delete(child);
+			unwrapped.add(next);
+		}
+		return unwrapped;
+	}
+
+	if (isPlainObject(unwrapped)) {
+		for (const key of Object.keys(unwrapped)) {
+			const child = unwrapDeep(unwrapped[key], seen);
+			if (child !== unwrapped[key]) {
+				unwrapped[key] = child;
+			}
+		}
+	}
+
+	return unwrapped;
+}
+
+/**
+ * Strips every `@rivetkit/on-change` proxy out of a value in place, including
+ * proxies nested inside plain objects, arrays, `Map`s, and `Set`s.
+ *
+ * A read of `c.state` or `conn.state` hands back a deep write-through proxy,
+ * so an update written as `c.state = { ...c.state, foo }` produces a plain root
+ * object whose children are still proxies. Persisting that value as-is makes
+ * the next read wrap proxies in another proxy layer, and each layer multiplies
+ * the work of traversing the state, so repeated spread updates degrade
+ * exponentially. Unwrapping before persisting keeps stored state proxy-free.
+ */
+export function unwrapWriteThroughProxy<T>(value: T): T {
+	return unwrapDeep(value, new Set()) as T;
+}

package/src/utils/node.ts

@@ -19,20 +19,35 @@ let nodeStream: typeof import("node:stream/promises") | undefined;
 let nodeUrl: typeof import("node:url") | undefined;
 
 let hasImportedDependencies = false;
+type NodeBuiltin = `node:${string}`;
+let fallbackRequire: ReturnType<typeof createRequire> | undefined;
 
-// Helper to get a require function that works in both CommonJS and ESM.
-// We use require() instead of await import() because registry.start() cannot
-// be async and needs immediate access to Node.js modules during setup.
-export function getRequireFn() {
-	// TODO: This causes issues in tsup
-	// CommonJS context - use global require
-	// if (typeof require !== "undefined") {
-	// 	console.log("existing require");
-	// 	return require;
-	// }
-
-	// ESM context - use createRequire with import.meta.url
-	return createRequire(import.meta.url);
+/**
+ * Loads a Node.js built-in synchronously without relying on `import.meta`,
+ * which esbuild cannot preserve in CommonJS output. Prefer Node's dedicated
+ * built-in loader and retain `createRequire` for Node 22.0-22.2 compatibility.
+ *
+ * @see https://nodejs.org/api/process.html#processgetbuiltinmoduleid
+ * @see https://github.com/evanw/esbuild/issues/1492
+ */
+export function loadNodeBuiltin<T>(id: NodeBuiltin): T {
+	const nodeProcess = globalThis.process;
+	const builtin = nodeProcess?.getBuiltinModule?.(id);
+
+	if (builtin !== undefined) {
+		return builtin as T;
+	}
+
+	if (!nodeProcess?.execPath) {
+		throw new Error("Node.js built-ins are not available");
+	}
+
+	// Node 22.0-22.2 does not provide getBuiltinModule(). Avoid import.meta here:
+	// esbuild replaces it with an empty shim in CommonJS output, leaving
+	// import_meta.url undefined. This loader only resolves built-ins, so the
+	// fallback base does not affect package resolution.
+	fallbackRequire ??= createRequire(nodeProcess.execPath);
+	return fallbackRequire(id) as T;
 }
 
 /**
@@ -48,22 +63,23 @@ export function importNodeDependencies(): void {
 	if (hasImportedDependencies) return;
 
 	try {
-		// Get a require function that works in both CommonJS and ESM
-		const requireFn = getRequireFn();
-
-		// Use requireFn with webpack ignore comment to prevent bundling
-		nodeCrypto = requireFn(/* webpackIgnore: true */ "node:crypto");
-		nodeFsSync = requireFn(/* webpackIgnore: true */ "node:fs");
-		nodeFs = requireFn(/* webpackIgnore: true */ "node:fs/promises");
-		nodePath = requireFn(/* webpackIgnore: true */ "node:path");
-		nodeOs = requireFn(/* webpackIgnore: true */ "node:os");
-		nodeChildProcess = requireFn(
-			/* webpackIgnore: true */ "node:child_process",
-		);
-		nodeStream = requireFn(
-			/* webpackIgnore: true */ "node:stream/promises",
+		nodeCrypto =
+			loadNodeBuiltin<typeof import("node:crypto")>("node:crypto");
+		nodeFsSync = loadNodeBuiltin<typeof import("node:fs")>("node:fs");
+		nodeFs =
+			loadNodeBuiltin<typeof import("node:fs/promises")>(
+				"node:fs/promises",
+			);
+		nodePath = loadNodeBuiltin<typeof import("node:path")>("node:path");
+		nodeOs = loadNodeBuiltin<typeof import("node:os")>("node:os");
+		nodeChildProcess =
+			loadNodeBuiltin<typeof import("node:child_process")>(
+				"node:child_process",
+			);
+		nodeStream = loadNodeBuiltin<typeof import("node:stream/promises")>(
+			"node:stream/promises",
 		);
-		nodeUrl = requireFn(/* webpackIgnore: true */ "node:url");
+		nodeUrl = loadNodeBuiltin<typeof import("node:url")>("node:url");
 		hasImportedDependencies = true;
 	} catch (err) {
 		console.warn(

package/src/workflow/driver.ts

@@ -8,7 +8,7 @@ import type {
 import type { RunContext } from "@/actor/config";
 import type { AnyStaticActorInstance } from "@/actor/definition";
 import { makeWorkflowKey, workflowStoragePrefix } from "@/actor/keys";
-import type { SqliteDatabase } from "@/common/database/config";
+import type { RawAccess } from "@/common/database/config";
 
 const WORKFLOW_STORAGE_PREFIX = workflowStoragePrefix();
 // Keep workflow flushes below depot's 320-dirty-page commit ceiling. The
@@ -68,52 +68,40 @@ function normalizeSqlBlob(value: unknown): Uint8Array {
 	throw new Error("workflow sqlite value was not a blob");
 }
 
-function runtimeSqlFromContext(
+function runtimeDbFromContext(
 	runCtx?: RunContext<any, any, any, any, any, any, any, any>,
-): SqliteDatabase | undefined {
-	const sql = (runCtx as unknown as { sql?: unknown } | undefined)?.sql;
+): RawAccess | undefined {
+	const db = (runCtx as unknown as { db?: unknown } | undefined)?.db;
 	if (
-		sql &&
-		typeof sql === "object" &&
-		"query" in sql &&
-		"execute" in sql &&
-		"executeBatch" in sql &&
-		"run" in sql
+		db &&
+		typeof db === "object" &&
+		"execute" in db &&
+		"transaction" in db
 	) {
-		return sql as SqliteDatabase;
+		return db as RawAccess;
 	}
 	return undefined;
 }
 
-type WorkflowSqliteDatabase = SqliteDatabase &
-	Required<Pick<SqliteDatabase, "executeBatch">>;
-
 class WorkflowStorage {
-	#sql: WorkflowSqliteDatabase;
+	#db: RawAccess;
 
-	constructor(sql?: SqliteDatabase) {
-		if (!sql) {
+	constructor(db?: RawAccess) {
+		if (!db) {
 			throw new Error(
 				"workflow storage requires embedded SQLite; actor KV workflow storage is no longer supported",
 			);
 		}
-		if (!sql.executeBatch) {
-			throw new Error(
-				"workflow storage requires a SQLite database with executeBatch support",
-			);
-		}
-		this.#sql = sql as WorkflowSqliteDatabase;
+		this.#db = db;
 	}
 
 	async get(key: Uint8Array): Promise<Uint8Array | null> {
 		const prefixed = makeWorkflowKey(key);
-		const result = await this.#sql.query(
+		const rows = await this.#db.execute<{ value: unknown }>(
 			"SELECT value FROM _rivet_wf_kv WHERE key = ?",
-			[prefixed],
+			prefixed,
 		);
-		return result.rows[0]?.[0] == null
-			? null
-			: normalizeSqlBlob(result.rows[0][0]);
+		return rows[0]?.value == null ? null : normalizeSqlBlob(rows[0].value);
 	}
 
 	async set(key: Uint8Array, value: Uint8Array): Promise<void> {
@@ -122,18 +110,20 @@ class WorkflowStorage {
 
 	async delete(key: Uint8Array): Promise<void> {
 		const prefixed = makeWorkflowKey(key);
-		await this.#sql.run("DELETE FROM _rivet_wf_kv WHERE key = ?", [
+		await this.#db.execute(
+			"DELETE FROM _rivet_wf_kv WHERE key = ?",
 			prefixed,
-		]);
+		);
 	}
 
 	async deletePrefix(prefix: Uint8Array): Promise<void> {
 		const start = makeWorkflowKey(prefix);
 		const end = computeUpperBound(start);
 		if (end) {
-			await this.#sql.run(
+			await this.#db.execute(
 				"DELETE FROM _rivet_wf_kv WHERE key >= ? AND key < ?",
-				[start, end],
+				start,
+				end,
 			);
 			return;
 		}
@@ -148,9 +138,10 @@ class WorkflowStorage {
 	async deleteRange(start: Uint8Array, end: Uint8Array): Promise<void> {
 		const prefixedStart = makeWorkflowKey(start);
 		const prefixedEnd = makeWorkflowKey(end);
-		await this.#sql.run(
+		await this.#db.execute(
 			"DELETE FROM _rivet_wf_kv WHERE key >= ? AND key < ?",
-			[prefixedStart, prefixedEnd],
+			prefixedStart,
+			prefixedEnd,
 		);
 	}
 
@@ -168,29 +159,33 @@ class WorkflowStorage {
 	async batch(writes: KVWrite[]): Promise<void> {
 		if (writes.length === 0) return;
 		for (const chunk of chunkWorkflowWrites(writes)) {
-			await this.#sql.executeBatch(
-				chunk.map(({ key, value }) => ({
-					sql: "INSERT INTO _rivet_wf_kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
-					params: [makeWorkflowKey(key), value],
-				})),
-			);
+			await this.#db.transaction(async (tx) => {
+				for (const { key, value } of chunk) {
+					await tx.execute(
+						"INSERT INTO _rivet_wf_kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value",
+						makeWorkflowKey(key),
+						value,
+					);
+				}
+			});
 		}
 	}
 
 	async listRaw(prefix: Uint8Array): Promise<KVEntryTuple[]> {
 		const end = computeUpperBound(prefix);
-		const result = end
-			? await this.#sql.query(
+		const rows = end
+			? await this.#db.execute<{ key: unknown; value: unknown }>(
 					"SELECT key, value FROM _rivet_wf_kv WHERE key >= ? AND key < ? ORDER BY key ASC",
-					[prefix, end],
+					prefix,
+					end,
 				)
-			: await this.#sql.query(
+			: await this.#db.execute<{ key: unknown; value: unknown }>(
 					"SELECT key, value FROM _rivet_wf_kv WHERE key >= ? ORDER BY key ASC",
-					[prefix],
+					prefix,
 				);
-		return result.rows.map((row) => [
-			normalizeSqlBlob(row[0]),
-			normalizeSqlBlob(row[1]),
+		return rows.map((row) => [
+			normalizeSqlBlob(row.key),
+			normalizeSqlBlob(row.value),
 		]);
 	}
 
@@ -200,14 +195,17 @@ class WorkflowStorage {
 			start < keys.length;
 			start += WORKFLOW_SQLITE_MAX_BATCH_ROWS
 		) {
-			await this.#sql.executeBatch(
-				keys
-					.slice(start, start + WORKFLOW_SQLITE_MAX_BATCH_ROWS)
-					.map((key) => ({
-						sql: "DELETE FROM _rivet_wf_kv WHERE key = ?",
-						params: [key],
-					})),
-			);
+			await this.#db.transaction(async (tx) => {
+				for (const key of keys.slice(
+					start,
+					start + WORKFLOW_SQLITE_MAX_BATCH_ROWS,
+				)) {
+					await tx.execute(
+						"DELETE FROM _rivet_wf_kv WHERE key = ?",
+						key,
+					);
+				}
+			});
 		}
 	}
 }
@@ -331,7 +329,7 @@ export class ActorWorkflowDriver implements EngineDriver {
 		this.#actor = actor;
 		this.#runCtx = runCtx;
 		this.messageDriver = new ActorWorkflowMessageDriver(actor, runCtx);
-		this.#storage = new WorkflowStorage(runtimeSqlFromContext(runCtx));
+		this.#storage = new WorkflowStorage(runtimeDbFromContext(runCtx));
 	}
 
 	async get(key: Uint8Array): Promise<Uint8Array | null> {
@@ -425,7 +423,7 @@ export class ActorWorkflowControlDriver implements EngineDriver {
 		runCtx?: RunContext<any, any, any, any, any, any, any, any>,
 	) {
 		this.#actor = actor;
-		this.#storage = new WorkflowStorage(runtimeSqlFromContext(runCtx));
+		this.#storage = new WorkflowStorage(runtimeDbFromContext(runCtx));
 	}
 
 	async get(key: Uint8Array): Promise<Uint8Array | null> {

package/src/workflow/inspector.ts

@@ -10,12 +10,14 @@ import type {
 	WorkflowHistorySnapshot,
 	WorkflowState,
 } from "@rivetkit/workflow-engine";
-import * as transport from "@/common/bare/transport/v1";
-import type { JsonCompatValue } from "@/common/encoding";
-import type { WorkflowHistoryBytes } from "@/common/inspector-transport";
-import { encodeWorkflowHistoryTransport } from "@/common/inspector-transport";
-import { encodeCborCompat } from "@/serde";
-import { assertUnreachable, bufferToArrayBuffer } from "@/utils";
+import * as transport from "@/inspector/workflow";
+import {
+	encodeWorkflowHistoryTransport,
+	encodeWorkflowInspectorValue,
+	type WorkflowInspectorAdapter as PublicWorkflowInspectorAdapter,
+	type WorkflowHistoryBytes,
+} from "@/inspector/workflow";
+import { assertUnreachable } from "@/utils";
 
 type HistoryListener = (history: WorkflowHistoryBytes) => void;
 
@@ -35,14 +37,7 @@ function createHistoryEmitter() {
 	};
 }
 
-export interface WorkflowInspectorAdapter {
-	getHistory: () => WorkflowHistoryBytes | null;
-	getState: () => Promise<WorkflowState | null>;
-	onHistoryUpdated: (
-		listener: (history: WorkflowHistoryBytes) => void,
-	) => () => void;
-	replayFromStep: (entryId?: string) => Promise<WorkflowHistoryBytes | null>;
-}
+export type WorkflowInspectorAdapter = PublicWorkflowInspectorAdapter;
 
 export function createWorkflowInspectorAdapter(): {
 	adapter: WorkflowInspectorAdapter;
@@ -88,7 +83,7 @@ export function createWorkflowInspectorAdapter(): {
 }
 
 function encodeCbor(value: unknown): ArrayBuffer {
-	return bufferToArrayBuffer(encodeCborCompat(value as JsonCompatValue));
+	return encodeWorkflowInspectorValue(value);
 }
 
 function encodeOptionalCbor(value: unknown): ArrayBuffer | null {