fix(rivetkit): restore waitForNames and fix queue type errors

rivetkit-typescript/packages/rivetkit/src/actor/instance/queue-manager.ts

@@ -56,6 +56,15 @@ interface QueueCompletionWaiter {
 	timeoutHandle?: ReturnType<typeof setTimeout>;
 }
 
+interface MessageListener {
+	nameSet: Set<string>;
+	resolve: () => void;
+	reject: (error: Error) => void;
+	actorAbortCleanup?: () => void;
+	signal?: AbortSignal;
+	signalAbortCleanup?: () => void;
+}
+
 const DEFAULT_METADATA: QueueMetadata = {
 	nextId: 1n,
 	size: 0,
@@ -75,6 +84,7 @@ export class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 	#pendingWarningHandle: ReturnType<typeof setTimeout> | undefined;
 	#redeliveryTimeout: ReturnType<typeof setTimeout> | undefined;
 	#redeliveryAt: number | undefined;
+	#messageListeners = new Set<MessageListener>();
 
 	constructor(
 		actor: ActorInstance<S, CP, CS, V, I, DB>,
@@ -197,6 +207,7 @@ export class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 		if (!options.deferWaiters) {
 			await this.#maybeResolveWaiters();
 		}
+		this.#notifyMessageListeners(name);
 
 		return message;
 	}
@@ -352,6 +363,59 @@ export class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 		await this.#maybeResolveWaiters();
 	}
 
+	/** Waits for messages with any of the specified names to appear in the queue. */
+	async waitForNames(
+		names: string[],
+		abortSignal?: AbortSignal,
+	): Promise<void> {
+		const nameSet = new Set(names);
+		const existing = await this.#loadQueueMessages();
+		if (existing.some((message) => nameSet.has(message.name))) {
+			return;
+		}
+
+		return await new Promise<void>((resolve, reject) => {
+			const listener: MessageListener = {
+				nameSet,
+				resolve: () => {
+					this.#removeMessageListener(listener);
+					resolve();
+				},
+				reject: (error) => {
+					this.#removeMessageListener(listener);
+					reject(error);
+				},
+			};
+
+			const actorAbortSignal = this.#actor.abortSignal;
+			const onActorAbort = () =>
+				listener.reject(new errors.ActorAborted());
+			if (actorAbortSignal.aborted) {
+				onActorAbort();
+				return;
+			}
+			actorAbortSignal.addEventListener("abort", onActorAbort, {
+				once: true,
+			});
+			listener.actorAbortCleanup = () =>
+				actorAbortSignal.removeEventListener("abort", onActorAbort);
+
+			if (abortSignal) {
+				const onAbort = () =>
+					listener.reject(new errors.ActorAborted());
+				if (abortSignal.aborted) {
+					onAbort();
+					return;
+				}
+				abortSignal.addEventListener("abort", onAbort, { once: true });
+				listener.signalAbortCleanup = () =>
+					abortSignal.removeEventListener("abort", onAbort);
+			}
+
+			this.#messageListeners.add(listener);
+		});
+	}
+
 	/** Returns all messages currently in the queue without removing them. */
 	async getMessages(): Promise<QueueMessage[]> {
 		return await this.#loadQueueMessages();
@@ -473,6 +537,26 @@ export class QueueManager<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 		return decoded;
 	}
 
+	#removeMessageListener(listener: MessageListener): void {
+		if (this.#messageListeners.delete(listener)) {
+			listener.actorAbortCleanup?.();
+			listener.signalAbortCleanup?.();
+		}
+	}
+
+	#notifyMessageListeners(name: string): void {
+		if (this.#messageListeners.size === 0) {
+			return;
+		}
+		for (const listener of [...this.#messageListeners]) {
+			if (!listener.nameSet.has(name)) {
+				continue;
+			}
+			this.#removeMessageListener(listener);
+			listener.resolve();
+		}
+	}
+
 	async #removeMessages(
 		messages: QueueMessage[],
 		options: { resolveWaiters: boolean },

rivetkit-typescript/packages/rivetkit/src/actor/instance/queue.ts

@@ -99,7 +99,8 @@ export class ActorQueue<S, CP, CS, V, I, DB extends AnyDatabaseProvider> {
 
 	/** Sends a message to the specified queue. */
 	async send(name: string, body: unknown): Promise<QueueMessage> {
-		return await this.#queueManager.enqueue(name, body);
+		const message = await this.#queueManager.enqueue(name, body);
+		return this.#toQueueMessage(message, false);
 	}
 }
 

rivetkit-typescript/packages/rivetkit/src/driver-test-suite/tests/actor-queue.ts

@@ -152,7 +152,7 @@ export function runActorQueueTests(driverTestConfig: DriverTestConfig) {
 			await waitFor(driverTestConfig, 60);
 			const result = await resultPromise;
 
-			expect(result.status).toBe("timedOut");
+			expect(result?.status).toBe("timedOut");
 		});
 
 		test("complete throws when wait is false", async (c) => {

rivetkit-typescript/packages/workflow-engine/AGENTS.md

@@ -0,0 +1,9 @@
+# Workflow Engine Notes
+
+## Dirty State Requirements
+
+- History entries must set `entry.dirty = true` whenever the entry is created or mutated. `flush()` persists dirty entries and clears the flag.
+- Entry metadata must set `metadata.dirty = true` whenever metadata fields change. `flush()` persists dirty metadata and clears the flag.
+- Name registry writes are tracked by `storage.flushedNameCount`. New names must be registered with `registerName()` before flushing.
+- Workflow state/output/error are tracked via `storage.flushedState`, `storage.flushedOutput`, and `storage.flushedError`. Update the fields and call `flush()`; it will write if the value changed.
+- `flush()` does not clear workflow output/error keys when values are unset. If you need to clear them, explicitly `driver.delete(buildWorkflowOutputKey())` or `driver.delete(buildWorkflowErrorKey())`.