rivetkit 2.1.5 → 2.1.6-rc.1

package/src/actor/instance/mod.ts

@@ -6,7 +6,8 @@ import {
 	type SpanStatusInput,
 	type Traces,
 } from "@rivetkit/traces";
-import type { SqliteVfs } from "@rivetkit/sqlite-vfs";
+import type { ISqliteVfs } from "@rivetkit/sqlite-vfs";
+import { ActorMetrics } from "@/actor/metrics";
 import invariant from "invariant";
 import type { ActorKey } from "@/actor/mod";
 import type { Client } from "@/client/client";
@@ -21,10 +22,7 @@ import {
 } from "@/schemas/actor-persist/versioned";
 import { EXTRA_ERROR_LOG } from "@/utils";
 import { getRivetExperimentalOtel } from "@/utils/env-vars";
-import {
-	type ActorConfig,
-	getRunFunction,
-} from "../config";
+import { type ActorConfig, getRunFunction } from "../config";
 import type { ConnDriver } from "../conn/driver";
 import { createHttpDriver } from "../conn/drivers/http";
 import {
@@ -80,6 +78,7 @@ enum CanSleep {
 	Yes,
 	NotReady,
 	NotStarted,
+	PreventSleep,
 	ActiveConns,
 	ActiveDisconnectCallbacks,
 	ActiveHonoHttpRequests,
@@ -173,7 +172,8 @@ export class ActorInstance<
 	// MARK: - Variables & Database
 	#vars?: V;
 	#db?: InferDatabaseClient<DB>;
-	#sqliteVfs?: SqliteVfs;
+	#sqliteVfs?: ISqliteVfs;
+	#metrics = new ActorMetrics();
 
 	// MARK: - Background Tasks
 	#backgroundPromises: Promise<void>[] = [];
@@ -184,6 +184,7 @@ export class ActorInstance<
 	// MARK: - HTTP/WebSocket Tracking
 	#activeHonoHttpRequests = 0;
 	#activeKeepAwakeCount = 0;
+	#preventSleep = false;
 
 	// MARK: - Deprecated (kept for compatibility)
 	#schedule!: Schedule;
@@ -262,6 +263,10 @@ export class ActorInstance<
 		return this.#inspectorToken;
 	}
 
+	get metrics(): ActorMetrics {
+		return this.#metrics;
+	}
+
 	// MARK: - Tracing
 	getCurrentTraceSpan(): SpanHandle | null {
 		return this.#traces.getCurrentSpan();
@@ -332,6 +337,10 @@ export class ActorInstance<
 		return this.#abortController.signal;
 	}
 
+	get preventSleep(): boolean {
+		return this.#preventSleep;
+	}
+
 	get actions(): string[] {
 		return Object.keys(this.#config.actions ?? {});
 	}
@@ -505,10 +514,17 @@ export class ActorInstance<
 			// is intentional and safe.
 			try {
 				this.#abortController.abort();
-			} catch { }
+			} catch {}
 
 			// Wait for run handler to complete
-			await this.#waitForRunHandler(this.overrides.runStopTimeout !== undefined ? Math.min(this.#config.options.runStopTimeout, this.overrides.runStopTimeout) : this.#config.options.runStopTimeout);
+			await this.#waitForRunHandler(
+				this.overrides.runStopTimeout !== undefined
+					? Math.min(
+							this.#config.options.runStopTimeout,
+							this.overrides.runStopTimeout,
+						)
+					: this.#config.options.runStopTimeout,
+			);
 
 			// Call onStop lifecycle
 			if (mode === "sleep") {
@@ -519,14 +535,19 @@ export class ActorInstance<
 				assertUnreachable(mode);
 			}
 
-			// Disconnect non-hibernatable connections
-			await this.#disconnectConnections();
-
 			// Wait for background tasks
 			await this.#waitBackgroundPromises(
-				this.overrides.waitUntilTimeout !== undefined ? Math.min(this.#config.options.waitUntilTimeout, this.overrides.waitUntilTimeout) : this.#config.options.waitUntilTimeout,
+				this.overrides.waitUntilTimeout !== undefined
+					? Math.min(
+							this.#config.options.waitUntilTimeout,
+							this.overrides.waitUntilTimeout,
+						)
+					: this.#config.options.waitUntilTimeout,
 			);
 
+			// Disconnect non-hibernatable connections
+			await this.#disconnectConnections();
+
 			// Clear timeouts and save state
 			this.#rLog.info({ msg: "clearing pending save timeouts" });
 			this.stateManager.clearPendingSaveTimeout();
@@ -633,14 +654,14 @@ export class ActorInstance<
 	async processMessage(
 		message: {
 			body:
-			| {
-				tag: "ActionRequest";
-				val: { id: bigint; name: string; args: unknown };
-			}
-			| {
-				tag: "SubscriptionRequest";
-				val: { eventName: string; subscribe: boolean };
-			};
+				| {
+						tag: "ActionRequest";
+						val: { id: bigint; name: string; args: unknown };
+				  }
+				| {
+						tag: "SubscriptionRequest";
+						val: { eventName: string; subscribe: boolean };
+				  };
 		},
 		conn: Conn<S, CP, CS, V, I, DB, E, Q>,
 	) {
@@ -661,7 +682,10 @@ export class ActorInstance<
 		ctx: ActionContext<S, CP, CS, V, I, DB, E, Q>,
 		eventName: string,
 	): Promise<void> {
-		const canSubscribe = getEventCanSubscribe(this.#config.events, eventName);
+		const canSubscribe = getEventCanSubscribe(
+			this.#config.events,
+			eventName,
+		);
 		if (!canSubscribe) {
 			return;
 		}
@@ -720,7 +744,9 @@ export class ActorInstance<
 		}
 
 		this.#activeKeepAwakeCount++;
+		this.#metrics.actionCalls++;
 		this.resetSleepTimer();
+		const actionStart = performance.now();
 		const actionSpan = this.startTraceSpan(`actor.action.${actionName}`, {
 			"rivet.action.name": actionName,
 		});
@@ -781,6 +807,7 @@ export class ActorInstance<
 				return output;
 			});
 		} catch (error) {
+			this.#metrics.actionErrors++;
 			const isTimeout = error instanceof DeadlineError;
 			const message = isTimeout
 				? "ActionTimedOut"
@@ -804,6 +831,7 @@ export class ActorInstance<
 			});
 			throw error;
 		} finally {
+			this.#metrics.actionTotalMs += performance.now() - actionStart;
 			if (!spanEnded && actionSpan.isActive()) {
 				this.#traces.endSpan(actionSpan, {
 					status: { code: "OK" },
@@ -834,33 +862,33 @@ export class ActorInstance<
 		}
 		const onRequest = this.#config.onRequest;
 
-			return await this.runInTraceSpan(
-				"actor.onRequest",
-				{
-					"http.method": request.method,
-					"http.url": request.url,
-					"rivet.conn.id": conn.id,
-				},
-				async () => {
-					const ctx = new RequestContext(this, conn, request);
-					try {
-						const response = await onRequest(ctx, request);
-						if (!response) {
-							throw new errors.InvalidRequestHandlerResponse();
-						}
-						return response;
-					} catch (error) {
-						this.#rLog.error({
-							msg: "onRequest error",
-							error: stringifyError(error),
-						});
-						throw error;
-					} finally {
-						this.stateManager.savePersistThrottled();
+		return await this.runInTraceSpan(
+			"actor.onRequest",
+			{
+				"http.method": request.method,
+				"http.url": request.url,
+				"rivet.conn.id": conn.id,
+			},
+			async () => {
+				const ctx = new RequestContext(this, conn, request);
+				try {
+					const response = await onRequest(ctx, request);
+					if (!response) {
+						throw new errors.InvalidRequestHandlerResponse();
 					}
-				},
-			);
-		}
+					return response;
+				} catch (error) {
+					this.#rLog.error({
+						msg: "onRequest error",
+						error: stringifyError(error),
+					});
+					throw error;
+				} finally {
+					this.stateManager.savePersistThrottled();
+				}
+			},
+		);
+	}
 
 	handleRawWebSocket(
 		conn: Conn<S, CP, CS, V, I, DB, E, Q>,
@@ -1002,6 +1030,17 @@ export class ActorInstance<
 		}
 	}
 
+	setPreventSleep(prevent: boolean) {
+		if (this.#preventSleep === prevent) return;
+
+		this.#preventSleep = prevent;
+		this.#rLog.debug({
+			msg: "updated prevent sleep state",
+			prevent,
+		});
+		this.resetSleepTimer();
+	}
+
 	beginQueueWait() {
 		this.assertReady(true);
 		this.#activeQueueWaitCount++;
@@ -1278,7 +1317,12 @@ export class ActorInstance<
 						if (result instanceof Promise) {
 							await deadline(
 								result,
-								this.overrides.onSleepTimeout !== undefined ? Math.min(this.#config.options.onSleepTimeout, this.overrides.onSleepTimeout) : this.#config.options.onSleepTimeout,
+								this.overrides.onSleepTimeout !== undefined
+									? Math.min(
+											this.#config.options.onSleepTimeout,
+											this.overrides.onSleepTimeout,
+										)
+									: this.#config.options.onSleepTimeout,
 							);
 						}
 					},
@@ -1310,7 +1354,13 @@ export class ActorInstance<
 						if (result instanceof Promise) {
 							await deadline(
 								result,
-								this.overrides.onDestroyTimeout !== undefined ? Math.min(this.#config.options.onDestroyTimeout, this.overrides.onDestroyTimeout) : this.#config.options.onDestroyTimeout,
+								this.overrides.onDestroyTimeout !== undefined
+									? Math.min(
+											this.#config.options
+												.onDestroyTimeout,
+											this.overrides.onDestroyTimeout,
+										)
+									: this.#config.options.onDestroyTimeout,
 							);
 						}
 					},
@@ -1342,6 +1392,9 @@ export class ActorInstance<
 			runFn(this.actorContext),
 		);
 
+		// Do not destroy or immediately sleep the actor when run exits. Finished
+		// workflows must stay inspectable when something goes wrong, and callers
+		// may still need to invoke actions after the run handler has completed.
 		if (runResult instanceof Promise) {
 			this.#runPromise = runResult
 				.then(() => {
@@ -1355,20 +1408,12 @@ export class ActorInstance<
 						return;
 					}
 
-					// Run handler exited normally - this should crash the actor
-					this.emitTraceEvent(
-						"actor.crash",
-						{ "rivet.actor.reason": "run_exited" },
-						runSpan,
-					);
-					this.endTraceSpan(runSpan, {
-						code: "ERROR",
-						message: "run exited unexpectedly",
-					});
-					this.#rLog.warn({
-						msg: "run handler exited unexpectedly, crashing actor to reschedule",
+					if (runSpan.isActive()) {
+						this.endTraceSpan(runSpan, { code: "OK" });
+					}
+					this.#rLog.info({
+						msg: "run handler exited",
 					});
-					this.startDestroy();
 				})
 				.catch((error) => {
 					if (this.#stopCalled) {
@@ -1382,24 +1427,14 @@ export class ActorInstance<
 						return;
 					}
 
-					// Run handler threw an error - crash the actor
-					this.emitTraceEvent(
-						"actor.crash",
-						{
-							"rivet.actor.reason": "run_error",
-							"error.message": stringifyError(error),
-						},
-						runSpan,
-					);
 					this.endTraceSpan(runSpan, {
 						code: "ERROR",
 						message: stringifyError(error),
 					});
 					this.#rLog.error({
-						msg: "run handler threw error, crashing actor to reschedule",
+						msg: "run handler threw error",
 						error: stringifyError(error),
 					});
-					this.startDestroy();
 				})
 				.finally(() => {
 					this.#runHandlerActive = false;
@@ -1407,6 +1442,9 @@ export class ActorInstance<
 				});
 		} else if (runSpan.isActive()) {
 			this.endTraceSpan(runSpan, { code: "OK" });
+			this.#rLog.info({
+				msg: "run handler exited",
+			});
 			this.#runHandlerActive = false;
 			this.resetSleepTimer();
 		}
@@ -1443,27 +1481,37 @@ export class ActorInstance<
 
 		let client: InferDatabaseClient<DB> | undefined;
 		try {
-			// Every actor gets its own SqliteVfs/@rivetkit/sqlite instance. The async
-			// @rivetkit/sqlite build is not re-entrant, and sharing one instance across
-			// actors can cause cross-actor contention and runtime corruption.
+			// Acquire a SQLite VFS handle for this actor. The driver may return a
+			// standalone VFS or a pooled handle that shares a WASM instance.
 			if (!this.#sqliteVfs && this.driver.createSqliteVfs) {
-				this.#sqliteVfs = await this.driver.createSqliteVfs();
+				this.#sqliteVfs = await this.driver.createSqliteVfs(this.#actorId);
 			}
 
 			client = await this.#config.db.createClient({
 				actorId: this.#actorId,
 				overrideRawDatabaseClient: this.driver.overrideRawDatabaseClient
-					? () => this.driver.overrideRawDatabaseClient!(this.#actorId)
+					? () =>
+							this.driver.overrideRawDatabaseClient!(
+								this.#actorId,
+							)
 					: undefined,
-				overrideDrizzleDatabaseClient: this.driver.overrideDrizzleDatabaseClient
-					? () => this.driver.overrideDrizzleDatabaseClient!(this.#actorId)
+				overrideDrizzleDatabaseClient: this.driver
+					.overrideDrizzleDatabaseClient
+					? () =>
+							this.driver.overrideDrizzleDatabaseClient!(
+								this.#actorId,
+							)
 					: undefined,
 				kv: {
-					batchPut: (entries) => this.driver.kvBatchPut(this.#actorId, entries),
-					batchGet: (keys) => this.driver.kvBatchGet(this.#actorId, keys),
-					batchDelete: (keys) => this.driver.kvBatchDelete(this.#actorId, keys),
+					batchPut: (entries) =>
+						this.driver.kvBatchPut(this.#actorId, entries),
+					batchGet: (keys) =>
+						this.driver.kvBatchGet(this.#actorId, keys),
+					batchDelete: (keys) =>
+						this.driver.kvBatchDelete(this.#actorId, keys),
 				},
 				sqliteVfs: this.#sqliteVfs,
+				metrics: this.#metrics,
 			});
 			this.#rLog.info({ msg: "database migration starting" });
 			await this.#config.db.onMigrate?.(client);
@@ -1498,7 +1546,9 @@ export class ActorInstance<
 				});
 				throw error;
 			}
-			const wrappedError = new Error(`Database setup failed: ${String(error)}`);
+			const wrappedError = new Error(
+				`Database setup failed: ${String(error)}`,
+			);
 			this.#rLog.error({
 				msg: "database setup failed with non-Error object",
 				error: String(error),
@@ -1634,6 +1684,7 @@ export class ActorInstance<
 	#canSleep(): CanSleep {
 		if (!this.#ready) return CanSleep.NotReady;
 		if (!this.#started) return CanSleep.NotReady;
+		if (this.#preventSleep) return CanSleep.PreventSleep;
 		if (this.#activeHonoHttpRequests > 0)
 			return CanSleep.ActiveHonoHttpRequests;
 		if (this.#activeKeepAwakeCount > 0) return CanSleep.ActiveKeepAwake;

package/src/actor/instance/queue-manager.ts

@@ -259,8 +259,7 @@ export class QueueManager<
 	): Promise<QueueMessage[]> {
 		this.#actor.assertReady();
 		const limitedCount = Math.max(1, count);
-		const nameSet =
-			names && names.length > 0 ? new Set(names) : undefined;
+		const nameSet = names && names.length > 0 ? new Set(names) : undefined;
 
 		const immediate = await this.#drainMessages(
 			nameSet,
@@ -356,8 +355,7 @@ export class QueueManager<
 		names: readonly string[] | undefined,
 		abortSignal?: AbortSignal,
 	): Promise<void> {
-		const nameSet =
-			names && names.length > 0 ? new Set(names) : undefined;
+		const nameSet = names && names.length > 0 ? new Set(names) : undefined;
 		const existing = await this.#loadQueueMessages();
 		if (nameSet) {
 			if (existing.some((message) => nameSet.has(message.name))) {
@@ -599,5 +597,4 @@ export class QueueManager<
 			ACTOR_PERSIST_CURRENT_VERSION,
 		);
 	}
-
 }

package/src/actor/instance/queue.ts

@@ -17,7 +17,8 @@ export type QueueMessageOf<Name extends string, Body> = Omit<
 	body: Body;
 };
 
-export type QueueName<TQueues extends QueueSchemaConfig> = keyof TQueues & string;
+export type QueueName<TQueues extends QueueSchemaConfig> = keyof TQueues &
+	string;
 export type QueueFilterName<TQueues extends QueueSchemaConfig> =
 	keyof TQueues extends never ? string : QueueName<TQueues>;
 
@@ -49,9 +50,7 @@ type QueueCompletableMessageForName<
 	TQueues extends QueueSchemaConfig,
 	TName extends QueueFilterName<TQueues>,
 > = QueueMessageForName<TQueues, TName> & {
-	complete(
-		...args: QueueCompleteArgsForName<TQueues, TName>
-	): Promise<void>;
+	complete(...args: QueueCompleteArgsForName<TQueues, TName>): Promise<void>;
 };
 
 export type QueueResultMessageForName<
@@ -159,7 +158,9 @@ export class ActorQueue<
 		const TCompletable extends boolean = false,
 	>(
 		opts?: QueueNextOptions<TName, TCompletable>,
-	): Promise<QueueResultMessageForName<TQueues, TName, TCompletable> | undefined> {
+	): Promise<
+		QueueResultMessageForName<TQueues, TName, TCompletable> | undefined
+	> {
 		const resolvedOpts = (opts ?? {}) as QueueNextOptions<
 			TName,
 			TCompletable
@@ -194,20 +195,16 @@ export class ActorQueue<
 			resolvedOpts.signal,
 		);
 		const messages = await this.#queueManager
-			.receive(
-				names,
-				count,
-				resolvedOpts.timeout,
-				signal,
-				completable,
-			)
+			.receive(names, count, resolvedOpts.timeout, signal, completable)
 			.finally(cleanup);
 		if (!completable) {
 			return messages as Array<
 				QueueResultMessageForName<TQueues, TName, TCompletable>
 			>;
 		}
-		return messages.map((message) => this.#makeCompletableMessage(message)) as unknown as Array<
+		return messages.map((message) =>
+			this.#makeCompletableMessage(message),
+		) as unknown as Array<
 			QueueResultMessageForName<TQueues, TName, TCompletable>
 		>;
 	}
@@ -217,7 +214,9 @@ export class ActorQueue<
 		const TCompletable extends boolean = false,
 	>(
 		opts?: QueueTryNextOptions<TName, TCompletable>,
-	): Promise<QueueResultMessageForName<TQueues, TName, TCompletable> | undefined> {
+	): Promise<
+		QueueResultMessageForName<TQueues, TName, TCompletable> | undefined
+	> {
 		const resolvedOpts = (opts ?? {}) as QueueTryNextOptions<
 			TName,
 			TCompletable
@@ -245,7 +244,9 @@ export class ActorQueue<
 				count: resolvedOpts.count,
 				timeout: 0,
 				completable: true,
-			})) as Array<QueueResultMessageForName<TQueues, TName, TCompletable>>;
+			})) as Array<
+				QueueResultMessageForName<TQueues, TName, TCompletable>
+			>;
 		}
 		return (await this.nextBatch<TName, false>({
 			names: resolvedOpts.names,
@@ -268,16 +269,17 @@ export class ActorQueue<
 		>;
 		while (!this.#abortSignal.aborted) {
 			try {
-				const message = resolvedOpts.completable === true
-					? await this.next<TName, true>({
-							names: resolvedOpts.names,
-							signal: resolvedOpts.signal,
-							completable: true,
-						})
-					: await this.next<TName, false>({
-							names: resolvedOpts.names,
-							signal: resolvedOpts.signal,
-						});
+				const message =
+					resolvedOpts.completable === true
+						? await this.next<TName, true>({
+								names: resolvedOpts.names,
+								signal: resolvedOpts.signal,
+								completable: true,
+							})
+						: await this.next<TName, false>({
+								names: resolvedOpts.names,
+								signal: resolvedOpts.signal,
+							});
 				if (!message) {
 					continue;
 				}
@@ -308,16 +310,16 @@ export class ActorQueue<
 		return await this.#queueManager.enqueue(name, body);
 	}
 
-	#normalizeNames(names: readonly string[] | undefined): string[] | undefined {
+	#normalizeNames(
+		names: readonly string[] | undefined,
+	): string[] | undefined {
 		if (!names || names.length === 0) {
 			return undefined;
 		}
 		return [...new Set(names)];
 	}
 
-	#makeCompletableMessage(
-		message: QueueMessage,
-	): QueueMessage & {
+	#makeCompletableMessage(message: QueueMessage): QueueMessage & {
 		complete: (response?: unknown) => Promise<void>;
 	} {
 		const messageId = message.id.toString();

package/src/actor/instance/state-manager.ts

@@ -219,7 +219,13 @@ export class StateManager<
 			} else {
 				// Create promise for waiting
 				if (!this.#onPersistSavedPromise) {
-					this.#onPersistSavedPromise = promiseWithResolvers((reason) => loggerWithoutContext().warn({ msg: "unhandled persist saved promise rejection", reason }));
+					this.#onPersistSavedPromise = promiseWithResolvers(
+						(reason) =>
+							loggerWithoutContext().warn({
+								msg: "unhandled persist saved promise rejection",
+								reason,
+							}),
+					);
 				}
 
 				// Save throttled

package/src/actor/instance/traces-driver.ts

@@ -13,14 +13,15 @@ function stripPrefix(prefix: Uint8Array, key: Uint8Array): Uint8Array {
 	return key.slice(prefix.length);
 }
 
-function compareBytes(a: Uint8Array, b: Uint8Array): number {
-	const len = Math.min(a.length, b.length);
-	for (let i = 0; i < len; i++) {
-		if (a[i] !== b[i]) {
-			return a[i] - b[i];
+function computeUpperBound(prefix: Uint8Array): Uint8Array | null {
+	const upperBound = prefix.slice();
+	for (let i = upperBound.length - 1; i >= 0; i--) {
+		if (upperBound[i] !== 0xff) {
+			upperBound[i]++;
+			return upperBound.slice(0, i + 1);
 		}
 	}
-	return a.length - b.length;
+	return null;
 }
 
 export class ActorTracesDriver implements TracesDriver {
@@ -55,17 +56,26 @@ export class ActorTracesDriver implements TracesDriver {
 
 	async deletePrefix(prefix: Uint8Array): Promise<void> {
 		const fullPrefix = concatPrefix(this.#prefix, prefix);
-		const entries = await this.#driver.kvListPrefix(
-			this.#actorId,
-			fullPrefix,
-		);
-		if (entries.length === 0) {
-			return;
+		const fullEnd = computeUpperBound(fullPrefix);
+		if (fullEnd) {
+			await this.#driver.kvDeleteRange(
+				this.#actorId,
+				fullPrefix,
+				fullEnd,
+			);
+		} else {
+			const entries = await this.#driver.kvListPrefix(
+				this.#actorId,
+				fullPrefix,
+			);
+			if (entries.length === 0) {
+				return;
+			}
+			await this.#driver.kvBatchDelete(
+				this.#actorId,
+				entries.map(([key]) => key),
+			);
 		}
-		await this.#driver.kvBatchDelete(
-			this.#actorId,
-			entries.map(([key]) => key),
-		);
 	}
 
 	async list(
@@ -87,33 +97,21 @@ export class ActorTracesDriver implements TracesDriver {
 		end: Uint8Array,
 		options?: { reverse?: boolean; limit?: number },
 	): Promise<Array<{ key: Uint8Array; value: Uint8Array }>> {
-		const fullStart = concatPrefix(this.#prefix, start);
-		const fullEnd = concatPrefix(this.#prefix, end);
-		const entries = await this.#driver.kvListPrefix(
+		const entries = await this.#driver.kvListRange(
 			this.#actorId,
-			this.#prefix,
+			concatPrefix(this.#prefix, start),
+			concatPrefix(this.#prefix, end),
+			options,
 		);
-		const filtered = entries
-			.filter(([key]) => {
-				return (
-					compareBytes(key, fullStart) >= 0 &&
-					compareBytes(key, fullEnd) < 0
-				);
-			})
-			.sort(([keyA], [keyB]) => compareBytes(keyA, keyB));
-		if (options?.reverse) {
-			filtered.reverse();
-		}
-		const limited = options?.limit
-			? filtered.slice(0, options.limit)
-			: filtered;
-		return limited.map(([key, value]) => ({
+		return entries.map(([key, value]) => ({
 			key: stripPrefix(this.#prefix, key),
 			value,
 		}));
 	}
 
-	async batch(writes: Array<{ key: Uint8Array; value: Uint8Array }>): Promise<void> {
+	async batch(
+		writes: Array<{ key: Uint8Array; value: Uint8Array }>,
+	): Promise<void> {
 		if (writes.length === 0) {
 			return;
 		}