rivetkit 2.3.11-rc.4 → 2.3.11-rc.6

package/src/registry/native.ts

@@ -48,7 +48,10 @@ import type { AnyDatabaseProvider } from "@/common/database/config";
 import { wrapJsNativeDatabase } from "@/common/database/native-database";
 import { assertJsonCompatValue, type JsonCompatValue } from "@/common/encoding";
 import { isResponseLike, type ResponseLike } from "@/common/fetch-like";
-import { decodeWorkflowHistoryTransport } from "@/common/inspector-transport";
+import {
+	decodeWorkflowHistoryTransport,
+	type WorkflowHistoryBytes,
+} from "@/common/inspector-transport";
 import { deconstructError, stringifyError } from "@/common/utils";
 import type {
 	RivetCloseEvent,
@@ -64,7 +67,7 @@ import type {
 	SqliteBackend,
 } from "@/registry/config";
 import { decodeCborCompat, encodeCborCompat } from "@/serde";
-import { getEnvUniversal, VERSION } from "@/utils";
+import { getEnvUniversal, toUint8Array, VERSION } from "@/utils";
 import {
 	getNodeFsSync,
 	getNodePath,
@@ -677,7 +680,15 @@ function decodeValue<T>(value?: RuntimeBytes | null): T {
 	return decodeCborCompat(value);
 }
 
-function encodeValue(value: unknown): RuntimeBytes {
+// Rejects `WorkflowHistoryBytes`: the compat layer rewrites an ArrayBuffer as
+// `["$ArrayBuffer", "<base64>"]`, and the inspector wire field carries raw BARE.
+// The conditional distributes, so it catches the branded type on its own but
+// only strips it from a union that also has other members. A non-distributive
+// `[T] extends [...]` resolves to `never` for the `any` arguments this takes
+// elsewhere, so the union case stays uncovered.
+function encodeValue<T>(
+	value: T extends WorkflowHistoryBytes ? never : T,
+): RuntimeBytes {
 	return encodeCborCompat(value as JsonCompatValue);
 }
 
@@ -769,9 +780,10 @@ function callNativeSync<T>(invoke: () => T): T {
 	}
 }
 
-type NativeWorkflowInspectorConfig = WorkflowInspectorConfig<ArrayBuffer> & {
-	getState?: () => Promise<unknown> | unknown;
-};
+type NativeWorkflowInspectorConfig =
+	WorkflowInspectorConfig<WorkflowHistoryBytes> & {
+		getState?: () => Promise<unknown> | unknown;
+	};
 
 function isClosedTaskRegistrationError(error: unknown): boolean {
 	const metadata = error instanceof RivetError ? error.metadata : undefined;
@@ -4816,7 +4828,7 @@ export function buildNativeFactory(
 								getNativeWorkflowInspector(ctx)?.getHistory();
 							return history == null
 								? undefined
-								: encodeValue(history);
+								: toUint8Array(history);
 						},
 					)
 				: undefined,
@@ -4846,7 +4858,7 @@ export function buildNativeFactory(
 								)) ?? null;
 							return history == null
 								? undefined
-								: encodeValue(history);
+								: toUint8Array(history);
 						},
 					)
 				: undefined,

package/src/workflow/inspector.ts

@@ -10,14 +10,14 @@ import type {
 	WorkflowHistorySnapshot,
 	WorkflowState,
 } from "@rivetkit/workflow-engine";
-import type * as inspectorSchema from "@/common/bare/generated/inspector/v4";
 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";
 
-type HistoryListener = (history: inspectorSchema.WorkflowHistory) => void;
+type HistoryListener = (history: WorkflowHistoryBytes) => void;
 
 function createHistoryEmitter() {
 	const listeners = new Set<HistoryListener>();
@@ -27,7 +27,7 @@ function createHistoryEmitter() {
 			listeners.add(listener);
 			return () => listeners.delete(listener);
 		},
-		emit: (history: inspectorSchema.WorkflowHistory) => {
+		emit: (history: WorkflowHistoryBytes) => {
 			for (const listener of listeners) {
 				listener(history);
 			}
@@ -36,14 +36,12 @@ function createHistoryEmitter() {
 }
 
 export interface WorkflowInspectorAdapter {
-	getHistory: () => inspectorSchema.WorkflowHistory | null;
+	getHistory: () => WorkflowHistoryBytes | null;
 	getState: () => Promise<WorkflowState | null>;
 	onHistoryUpdated: (
-		listener: (history: inspectorSchema.WorkflowHistory) => void,
+		listener: (history: WorkflowHistoryBytes) => void,
 	) => () => void;
-	replayFromStep: (
-		entryId?: string,
-	) => Promise<inspectorSchema.WorkflowHistory | null>;
+	replayFromStep: (entryId?: string) => Promise<WorkflowHistoryBytes | null>;
 }
 
 export function createWorkflowInspectorAdapter(): {
@@ -51,17 +49,15 @@ export function createWorkflowInspectorAdapter(): {
 	update: (snapshot: WorkflowHistorySnapshot) => void;
 	setGetState: (fn: () => Promise<WorkflowState | null>) => void;
 	setReplayFromStep: (
-		fn: (
-			entryId?: string,
-		) => Promise<inspectorSchema.WorkflowHistory | null>,
+		fn: (entryId?: string) => Promise<WorkflowHistoryBytes | null>,
 	) => void;
 } {
 	const emitter = createHistoryEmitter();
-	let history: inspectorSchema.WorkflowHistory | null = null;
+	let history: WorkflowHistoryBytes | null = null;
 	let getState: () => Promise<WorkflowState | null> = async () => null;
 	let replayFromStep: (
 		entryId?: string,
-	) => Promise<inspectorSchema.WorkflowHistory | null> = async () => {
+	) => Promise<WorkflowHistoryBytes | null> = async () => {
 		throw new Error("Workflow replay controls are not initialized");
 	};