rivetkit 2.3.3 → 2.3.5-rc.1

package/dist/tsup/utils.d.ts

@@ -1,148 +1,5 @@
-import { Context, Handler } from 'hono';
+import 'hono';
 export { d as assertUnreachable, s as stringifyError } from './utils-CqDnC_PS.js';
+export { D as DeepMutable, a as DeepReadonly, b as EXTRA_ERROR_LOG, G as GetUpgradeWebSocket, L as LongTimeoutHandle, R as Runtime, S as SinglePromiseQueue, U as UpgradeWebSocket, V as VERSION, c as arrayBuffersEqual, d as bufferToArrayBuffer, e as combineUrlPath, f as dbg, g as detectRuntime, h as getEnvUniversal, i as httpUserAgent, j as interval, k as joinSignals, l as jsonParseCompat, m as jsonStringifyCompat, p as promiseWithResolvers, s as setLongTimeout, n as sleep, t as toUint8Array } from './utils-CV0akuDD.js';
 import 'hono/utils/http-status';
-
-/**
- * Joins multiple abort signals into one.
- *
- * The returned signal aborts when the first input signal aborts.
- * Uses `AbortSignal.any(...)` when available, with a runtime fallback.
- *
- * @experimental
- */
-declare function joinSignals(...signals: Array<AbortSignal | undefined | null>): AbortSignal;
-/**
- * Returns a promise that resolves after the given number of milliseconds.
- *
- * @experimental
- */
-declare function sleep(ms: number): Promise<void>;
-/**
- * Creates a fixed-rate interval tick function that can be awaited in a loop.
- *
- * @example
- * const tick = interval(100);
- * while (!c.aborted) {
- *   await tick();
- *   if (c.aborted) break;
- *   // ... game logic
- * }
- *
- * @experimental
- */
-declare function interval(ms: number): () => Promise<void>;
-declare const VERSION: string;
-/**
- * Builds the HTTP user agent used by this library.
- *
- * @experimental
- */
-declare function httpUserAgent(): string;
-type UpgradeWebSocket = (createEvents: (c: Context) => any) => Handler;
-type GetUpgradeWebSocket = () => UpgradeWebSocket;
-/**
- * Reads an environment variable from Deno or Node runtimes.
- *
- * @experimental
- */
-declare function getEnvUniversal(key: string): string | undefined;
-/**
- * Traces a debug value and returns it.
- *
- * @experimental
- */
-declare function dbg<T>(x: T): T;
-/**
- * Converts various ArrayBuffer-like types to Uint8Array.
- * Handles ArrayBuffer, ArrayBufferView (including typed arrays), and passes through existing Uint8Array.
- *
- * @param data - The ArrayBuffer or ArrayBufferView to convert
- * @returns A Uint8Array view of the data
- *
- * @experimental
- */
-declare function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array;
-type LongTimeoutHandle = {
-    abort: () => void;
-};
-/**
- * Polyfill for Promise.withResolvers().
- *
- * This is specifically for Cloudflare Workers. Their implementation of Promise.withResolvers does not work correctly.
- *
- * @experimental
- */
-declare function promiseWithResolvers<T>(onReject: (reason?: any) => void): {
-    promise: Promise<T>;
-    resolve: (value: T | PromiseLike<T>) => void;
-    reject: (reason?: any) => void;
-};
-/**
- * Sets a timeout that supports delays larger than the JavaScript timer limit.
- *
- * @experimental
- */
-declare function setLongTimeout(listener: () => void, after: number): LongTimeoutHandle;
-/**
- * A tiny utility that coalesces/enqueues async operations so only the latest
- * queued task runs per cycle, while callers receive a promise that resolves
- * when the task for the cycle they joined has completed.
- */
-declare class SinglePromiseQueue {
-    #private;
-    /** The currently running promise of #drainLoop. Do not await this, instead await `pending` to await the current cycle. */
-    runningDrainLoop?: Promise<void>;
-    /** Queue the next operation and return a promise that resolves when it flushes. */
-    enqueue(op: () => Promise<void>): Promise<void>;
-}
-/**
- * Converts a Buffer or Uint8Array into an ArrayBuffer view.
- *
- * @experimental
- */
-declare function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer;
-/**
- * Properly combines a base URL endpoint with a path, preserving any base path in the endpoint.
- *
- * @example
- * combineUrlPath("http://localhost:8787/rivet", "/actors/action")
- * // Returns: "http://localhost:8787/rivet/actors/action"
- *
- * @example
- * combineUrlPath("http://localhost:8787/rivet", "/actors?type=foo", { namespace: "test" })
- * // Returns: "http://localhost:8787/rivet/actors?type=foo&namespace=test"
- *
- * @param endpoint The base URL endpoint that may contain a path component
- * @param path The path to append to the endpoint (may include query parameters)
- * @param queryParams Optional additional query parameters to append
- * @returns The properly combined URL string
- *
- * @experimental
- */
-declare function combineUrlPath(endpoint: string, path: string, queryParams?: Record<string, string | undefined>): string;
-/**
- * Compares two ArrayBuffer values by byte content.
- *
- * @experimental
- */
-declare function arrayBuffersEqual(buf1: ArrayBuffer, buf2: ArrayBuffer): boolean;
-declare const EXTRA_ERROR_LOG: {
-    issues: string;
-    support: string;
-    version: string;
-};
-type Runtime = "deno" | "bun" | "node";
-/**
- * Detects the current JavaScript runtime from the user agent.
- *
- * @experimental
- */
-declare function detectRuntime(): Runtime;
-type DeepReadonly<T> = {
-    readonly [K in keyof T]: T[K] extends object ? DeepReadonly<T[K]> : T[K];
-};
-type DeepMutable<T> = {
-    -readonly [K in keyof T]: T[K] extends object ? DeepMutable<T[K]> : T[K];
-};
-
-export { type DeepMutable, type DeepReadonly, EXTRA_ERROR_LOG, type GetUpgradeWebSocket, type LongTimeoutHandle, type Runtime, SinglePromiseQueue, type UpgradeWebSocket, VERSION, arrayBuffersEqual, bufferToArrayBuffer, combineUrlPath, dbg, detectRuntime, getEnvUniversal, httpUserAgent, interval, joinSignals, promiseWithResolvers, setLongTimeout, sleep, toUint8Array };
+import 'zod/v4';

package/dist/tsup/utils.js

@@ -12,12 +12,14 @@ import {
   httpUserAgent,
   interval,
   joinSignals,
+  jsonParseCompat,
+  jsonStringifyCompat,
   promiseWithResolvers,
   setLongTimeout,
   sleep,
   stringifyError,
   toUint8Array
-} from "./chunk-BLDO2FKO.js";
+} from "./chunk-B4IZU537.js";
 import "./chunk-ZZ3WBRPD.js";
 export {
   EXTRA_ERROR_LOG,
@@ -33,6 +35,8 @@ export {
   httpUserAgent,
   interval,
   joinSignals,
+  jsonParseCompat,
+  jsonStringifyCompat,
   promiseWithResolvers,
   setLongTimeout,
   sleep,

package/dist/tsup/workflow/mod.cjs

@@ -1,20 +1,18 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } var _class; var _class2;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } var _class; var _class2;
 
-var _chunkTYLP3U4Ycjs = require('../chunk-TYLP3U4Y.cjs');
-require('../chunk-S644FL73.cjs');
+var _chunkTNIWIUNVcjs = require('../chunk-TNIWIUNV.cjs');
+require('../chunk-TR5NLR5V.cjs');
 
 
 
+var _chunkG3CCRCTKcjs = require('../chunk-G3CCRCTK.cjs');
 
-var _chunk3MHDOUD7cjs = require('../chunk-3MHDOUD7.cjs');
 
 
+var _chunkMYWZCDMLcjs = require('../chunk-MYWZCDML.cjs');
 
-var _chunkVE2X4KMGcjs = require('../chunk-VE2X4KMG.cjs');
-require('../chunk-APW73HCH.cjs');
 
-
-var _chunkPYO2U53Vcjs = require('../chunk-PYO2U53V.cjs');
+var _chunk6HQCLWAWcjs = require('../chunk-6HQCLWAW.cjs');
 
 
 
@@ -289,32 +287,13 @@ var WorkflowContext = class _WorkflowContext {
   isEvicted() {
     return this.#inner.isEvicted();
   }
-  // Runs a user step body inside a fresh step context, snapshotting actor
-  // state/vars so a thrown step rolls back its mutations, and deactivating the
-  // step context once the body settles so it cannot be used after the step.
+  // Runs a user step body inside a fresh step context and deactivates the step
+  // context once the body settles. Workflows are roll-forward only, so state and
+  // vars mutations made before a failure always remain visible.
   async #runStep(run) {
     const stepCtx = new WorkflowStepContext(this.#runCtx, () => this.#markGuardTriggered());
-    let stateSnapshot = null;
-    try {
-      stateSnapshot = { state: this.#runCtx[_chunk3MHDOUD7cjs.RAW_STATE_SYMBOL]() };
-    } catch (error) {
-      this.#runCtx.log.debug({
-        msg: "failed to get state, likely due to being stateless workflow",
-        error
-      });
-    }
-    if (stateSnapshot) {
-      stateSnapshot.state = structuredClone(stateSnapshot.state);
-    }
-    const varsSnapshot = structuredClone(this.#runCtx.vars);
     try {
       return await run(stepCtx);
-    } catch (error) {
-      if (stateSnapshot) {
-        this.#runCtx.state = stateSnapshot.state;
-      }
-      this.#runCtx.vars = varsSnapshot;
-      throw error;
     } finally {
       stepCtx[DEACTIVATE_STEP]();
     }
@@ -334,8 +313,7 @@ var WorkflowContext = class _WorkflowContext {
       ...message.complete ? { complete: message.complete } : {}
     };
   }
-  // Runs a step rollback compensation with an active step context. Rollbacks
-  // intentionally mutate actor state, so their writes are not snapshotted.
+  // Runs a step rollback compensation with an active step context.
   async #runRollback(rollback, output) {
     const stepCtx = new WorkflowStepContext(this.#runCtx, () => this.#markGuardTriggered());
     try {
@@ -376,7 +354,9 @@ var WorkflowContext = class _WorkflowContext {
 };
 
 // src/workflow/driver.ts
-var WORKFLOW_STORAGE_PREFIX = _chunkVE2X4KMGcjs.workflowStoragePrefix.call(void 0, );
+var WORKFLOW_STORAGE_PREFIX = _chunkMYWZCDMLcjs.workflowStoragePrefix.call(void 0, );
+var WORKFLOW_SQLITE_MAX_BATCH_ROWS = 128;
+var WORKFLOW_SQLITE_MAX_BATCH_BYTES = 512 * 1024;
 function stripWorkflowKey(prefixed) {
   return prefixed.slice(WORKFLOW_STORAGE_PREFIX.length);
 }
@@ -390,6 +370,159 @@ function computeUpperBound(prefix) {
   }
   return null;
 }
+function normalizeSqlBlob(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return new Uint8Array(value);
+  }
+  if (ArrayBuffer.isView(value)) {
+    return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+  }
+  if (Array.isArray(value)) {
+    const bytes = new Uint8Array(value.length);
+    for (const [i, item] of value.entries()) {
+      if (!Number.isInteger(item) || item < 0 || item > 255) {
+        throw new Error("workflow sqlite value was not a byte array");
+      }
+      bytes[i] = item;
+    }
+    return bytes;
+  }
+  throw new Error("workflow sqlite value was not a blob");
+}
+function runtimeSqlFromContext(runCtx) {
+  const sql = runCtx == null ? void 0 : runCtx.sql;
+  if (sql && typeof sql === "object" && "query" in sql && "execute" in sql && "executeBatch" in sql && "run" in sql) {
+    return sql;
+  }
+  return void 0;
+}
+var WorkflowStorage = class {
+  #sql;
+  constructor(sql) {
+    if (!sql) {
+      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;
+  }
+  async get(key) {
+    var _a;
+    const prefixed = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, key);
+    const result = await this.#sql.query(
+      "SELECT value FROM _rivet_wf_kv WHERE key = ?",
+      [prefixed]
+    );
+    return ((_a = result.rows[0]) == null ? void 0 : _a[0]) == null ? null : normalizeSqlBlob(result.rows[0][0]);
+  }
+  async set(key, value) {
+    await this.batch([{ key, value }]);
+  }
+  async delete(key) {
+    const prefixed = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, key);
+    await this.#sql.run("DELETE FROM _rivet_wf_kv WHERE key = ?", [
+      prefixed
+    ]);
+  }
+  async deletePrefix(prefix) {
+    const start = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, prefix);
+    const end = computeUpperBound(start);
+    if (end) {
+      await this.#sql.run(
+        "DELETE FROM _rivet_wf_kv WHERE key >= ? AND key < ?",
+        [start, end]
+      );
+      return;
+    }
+    const entries = await this.listRaw(start);
+    await this.deleteRawKeys(
+      entries.filter(([key]) => keyStartsWith(key, start)).map(([key]) => key)
+    );
+  }
+  async deleteRange(start, end) {
+    const prefixedStart = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, start);
+    const prefixedEnd = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, end);
+    await this.#sql.run(
+      "DELETE FROM _rivet_wf_kv WHERE key >= ? AND key < ?",
+      [prefixedStart, prefixedEnd]
+    );
+  }
+  async list(prefix) {
+    const prefixed = _chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, prefix);
+    const entries = await this.listRaw(prefixed);
+    return entries.filter(([key]) => keyStartsWith(key, prefixed)).map(([key, value]) => ({
+      key: stripWorkflowKey(key),
+      value
+    }));
+  }
+  async batch(writes) {
+    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: [_chunkMYWZCDMLcjs.makeWorkflowKey.call(void 0, key), value]
+        }))
+      );
+    }
+  }
+  async listRaw(prefix) {
+    const end = computeUpperBound(prefix);
+    const result = end ? await this.#sql.query(
+      "SELECT key, value FROM _rivet_wf_kv WHERE key >= ? AND key < ? ORDER BY key ASC",
+      [prefix, end]
+    ) : await this.#sql.query(
+      "SELECT key, value FROM _rivet_wf_kv WHERE key >= ? ORDER BY key ASC",
+      [prefix]
+    );
+    return result.rows.map((row) => [
+      normalizeSqlBlob(row[0]),
+      normalizeSqlBlob(row[1])
+    ]);
+  }
+  async deleteRawKeys(keys) {
+    for (let start = 0; 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]
+        }))
+      );
+    }
+  }
+};
+function chunkWorkflowWrites(writes) {
+  const chunks = [];
+  let chunk = [];
+  let chunkBytes = 0;
+  for (const write of writes) {
+    const writeBytes = WORKFLOW_STORAGE_PREFIX.length + write.key.length + write.value.length;
+    if (chunk.length > 0 && (chunk.length >= WORKFLOW_SQLITE_MAX_BATCH_ROWS || chunkBytes + writeBytes > WORKFLOW_SQLITE_MAX_BATCH_BYTES)) {
+      chunks.push(chunk);
+      chunk = [];
+      chunkBytes = 0;
+    }
+    chunk.push(write);
+    chunkBytes += writeBytes;
+  }
+  if (chunk.length > 0) chunks.push(chunk);
+  return chunks;
+}
+function keyStartsWith(key, prefix) {
+  if (key.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (key[i] !== prefix[i]) return false;
+  }
+  return true;
+}
 var ActorWorkflowMessageDriver = class {
   #actor;
   #runCtx;
@@ -442,95 +575,44 @@ var ActorWorkflowMessageDriver = class {
   }
 };
 var ActorWorkflowDriver = (_class = class {
-  __init() {this.workerPollInterval = 100}
+  __init() {this.atomicBatch = true}
+  __init2() {this.workerPollInterval = 100}
   
   #actor;
   #runCtx;
-  constructor(actor, runCtx) {;_class.prototype.__init.call(this);
+  #storage;
+  constructor(actor, runCtx) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
     this.#actor = actor;
     this.#runCtx = runCtx;
     this.messageDriver = new ActorWorkflowMessageDriver(actor, runCtx);
+    this.#storage = new WorkflowStorage(runtimeSqlFromContext(runCtx));
   }
   async get(key) {
-    const [value] = await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchGet(this.#actor.id, [
-        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
-      ])
-    );
-    return _nullishCoalesce(value, () => ( null));
+    return await this.#runCtx.internalKeepAwake(this.#storage.get(key));
   }
   async set(key, value) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchPut(this.#actor.id, [
-        [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value]
-      ])
-    );
+    await this.#runCtx.internalKeepAwake(this.#storage.set(key, value));
   }
   async delete(key) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchDelete(this.#actor.id, [
-        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
-      ])
-    );
+    await this.#runCtx.internalKeepAwake(this.#storage.delete(key));
   }
   async deletePrefix(prefix) {
-    const start = _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix);
-    const end = computeUpperBound(start);
-    if (end) {
-      await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvDeleteRange(this.#actor.id, start, end)
-      );
-    } else {
-      const entries = await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvListPrefix(this.#actor.id, start)
-      );
-      if (entries.length === 0) {
-        return;
-      }
-      await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvBatchDelete(
-          this.#actor.id,
-          entries.map(([key]) => key)
-        )
-      );
-    }
+    await this.#runCtx.internalKeepAwake(
+      this.#storage.deletePrefix(prefix)
+    );
   }
   async deleteRange(start, end) {
     await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvDeleteRange(
-        this.#actor.id,
-        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, start),
-        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, end)
-      )
+      this.#storage.deleteRange(start, end)
     );
   }
   async list(prefix) {
-    const entries = await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvListPrefix(
-        this.#actor.id,
-        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix)
-      )
-    );
-    return entries.map(([key, value]) => ({
-      key: stripWorkflowKey(key),
-      value
-    }));
+    return await this.#runCtx.internalKeepAwake(this.#storage.list(prefix));
   }
   async batch(writes) {
     if (writes.length === 0) return;
     await this.#runCtx.internalKeepAwake(
-      Promise.all([
-        this.#actor.driver.kvBatchPut(
-          this.#actor.id,
-          writes.map(({ key, value }) => [
-            _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key),
-            value
-          ])
-        ),
-        this.#actor.stateManager.saveState({
-          immediate: true
-        })
-      ])
+      this.#actor.stateManager.saveStateAndWorkflowBatch(writes)
     );
   }
   async setAlarm(_workflowId, wakeAt) {
@@ -560,72 +642,37 @@ var NoopWorkflowMessageDriver = class {
   }
 };
 var ActorWorkflowControlDriver = (_class2 = class {
-  __init2() {this.workerPollInterval = 100}
-  __init3() {this.messageDriver = new NoopWorkflowMessageDriver()}
+  __init3() {this.workerPollInterval = 100}
+  __init4() {this.messageDriver = new NoopWorkflowMessageDriver()}
   #actor;
-  constructor(actor) {;_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);
+  #storage;
+  constructor(actor, runCtx) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);
     this.#actor = actor;
+    this.#storage = new WorkflowStorage(runtimeSqlFromContext(runCtx));
   }
   async get(key) {
-    const [value] = await this.#actor.driver.kvBatchGet(this.#actor.id, [
-      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
-    ]);
-    return _nullishCoalesce(value, () => ( null));
+    return await this.#storage.get(key);
   }
   async set(key, value) {
-    await this.#actor.driver.kvBatchPut(this.#actor.id, [
-      [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value]
-    ]);
+    await this.#storage.set(key, value);
   }
   async delete(key) {
-    await this.#actor.driver.kvBatchDelete(this.#actor.id, [
-      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
-    ]);
+    await this.#storage.delete(key);
   }
   async deletePrefix(prefix) {
-    const start = _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix);
-    const end = computeUpperBound(start);
-    if (end) {
-      await this.#actor.driver.kvDeleteRange(this.#actor.id, start, end);
-      return;
-    }
-    const entries = await this.#actor.driver.kvListPrefix(
-      this.#actor.id,
-      start
-    );
-    if (entries.length === 0) {
-      return;
-    }
-    await this.#actor.driver.kvBatchDelete(
-      this.#actor.id,
-      entries.map(([key]) => key)
-    );
+    await this.#storage.deletePrefix(prefix);
   }
   async deleteRange(start, end) {
-    await this.#actor.driver.kvDeleteRange(
-      this.#actor.id,
-      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, start),
-      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, end)
-    );
+    await this.#storage.deleteRange(start, end);
   }
   async list(prefix) {
-    const entries = await this.#actor.driver.kvListPrefix(
-      this.#actor.id,
-      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix)
-    );
-    return entries.map(([key, value]) => ({
-      key: stripWorkflowKey(key),
-      value
-    }));
+    return await this.#storage.list(prefix);
   }
   async batch(writes) {
     if (writes.length === 0) {
       return;
     }
-    await this.#actor.driver.kvBatchPut(
-      this.#actor.id,
-      writes.map(({ key, value }) => [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value])
-    );
+    await this.#storage.batch(writes);
   }
   async setAlarm(_workflowId, wakeAt) {
     await this.#actor.driver.setAlarm(this.#actor, wakeAt);
@@ -669,17 +716,17 @@ function workflow(fn, options = {}) {
   function getWorkflowInspector(actorId) {
     let workflowInspector = workflowInspectors.get(actorId);
     if (!workflowInspector) {
-      workflowInspector = _chunkTYLP3U4Ycjs.createWorkflowInspectorAdapter.call(void 0, );
+      workflowInspector = _chunkTNIWIUNVcjs.createWorkflowInspectorAdapter.call(void 0, );
       workflowInspectors.set(actorId, workflowInspector);
     }
     return workflowInspector;
   }
   async function run(runCtx) {
-    const actor = runCtx[_chunk3MHDOUD7cjs.ACTOR_CONTEXT_INTERNAL_SYMBOL];
+    const actor = runCtx[_chunkG3CCRCTKcjs.ACTOR_CONTEXT_INTERNAL_SYMBOL];
     _invariant2.default.call(void 0, actor, "workflow() requires an actor instance");
     const workflowInspector = getWorkflowInspector(actor.id);
     const driver = new ActorWorkflowDriver(actor, runCtx);
-    const controlDriver = new ActorWorkflowControlDriver(actor);
+    const controlDriver = new ActorWorkflowControlDriver(actor, runCtx);
     workflowInspector.setReplayFromStep(async (entryId) => {
       const workflowState = await workflowInspector.adapter.getState();
       if (actor.isRunHandlerActive() || workflowState === "pending" || workflowState === "running") {
@@ -737,20 +784,20 @@ function workflow(fn, options = {}) {
       if (shouldRethrowWorkflowError(error)) {
         runCtx.log.error({
           msg: "workflow run failed",
-          error: _chunkPYO2U53Vcjs.stringifyError.call(void 0, error)
+          error: _chunk6HQCLWAWcjs.stringifyError.call(void 0, error)
         });
         throw error;
       }
       runCtx.log.warn({
         msg: "workflow failed and will sleep until woken",
-        error: _chunkPYO2U53Vcjs.stringifyError.call(void 0, error)
+        error: _chunk6HQCLWAWcjs.stringifyError.call(void 0, error)
       });
     } finally {
       runCtx.abortSignal.removeEventListener("abort", onAbort);
     }
   }
   const runWithConfig = run;
-  runWithConfig[_chunk3MHDOUD7cjs.RUN_FUNCTION_CONFIG_SYMBOL] = {
+  runWithConfig[_chunkG3CCRCTKcjs.RUN_FUNCTION_CONFIG_SYMBOL] = {
     icon: "diagram-project",
     // Drop the per-actor inspector when the actor is destroyed so this map
     // does not retain one inspector (and its encoded history) per actor id