rivetkit 2.3.0-rc.8 → 2.3.0

package/dist/tsup/workflow/mod.js

@@ -1,23 +1,23 @@
 import {
   createWorkflowInspectorAdapter
-} from "../chunk-UZXQEGVJ.js";
+} from "../chunk-P2GNQ4RN.js";
+import "../chunk-UMZVD6DQ.js";
 import {
   ACTOR_CONTEXT_INTERNAL_SYMBOL,
   RAW_STATE_SYMBOL,
   RUN_FUNCTION_CONFIG_SYMBOL
-} from "../chunk-D5G75T7J.js";
-import "../chunk-VUGENVIK.js";
+} from "../chunk-DPIMKYNB.js";
 import {
   makeWorkflowKey,
   workflowStoragePrefix
-} from "../chunk-3YY5S6TV.js";
-import "../chunk-KY3CERZR.js";
+} from "../chunk-HXUEHHJF.js";
+import "../chunk-2OTRTA3J.js";
 import {
   stringifyError
-} from "../chunk-GBG63SUG.js";
+} from "../chunk-VTTFNQQI.js";
 import {
   RivetError
-} from "../chunk-TMLOKTRB.js";
+} from "../chunk-BRP62GZC.js";
 
 // src/workflow/mod.ts
 import {
@@ -26,403 +26,140 @@ import {
   HistoryDivergedError,
   JoinError,
   RaceError,
-  replayWorkflowFromStep,
   RollbackCheckpointError,
   RollbackError,
+  replayWorkflowFromStep,
   runWorkflow,
   StepExhaustedError
 } from "@rivetkit/workflow-engine";
 import invariant from "invariant";
 
-// src/workflow/driver.ts
-var WORKFLOW_STORAGE_PREFIX = workflowStoragePrefix();
-function stripWorkflowKey(prefixed) {
-  return prefixed.slice(WORKFLOW_STORAGE_PREFIX.length);
-}
-function computeUpperBound(prefix) {
-  const upperBound = prefix.slice();
-  for (let i = upperBound.length - 1; i >= 0; i--) {
-    if (upperBound[i] !== 255) {
-      upperBound[i]++;
-      return upperBound.slice(0, i + 1);
-    }
-  }
-  return null;
-}
-var ActorWorkflowMessageDriver = class {
-  #actor;
+// src/workflow/constants.ts
+var WORKFLOW_GUARD_KV_KEY = "__rivet_actor_workflow_guard_triggered";
+
+// src/workflow/context.ts
+var ActorWorkflowContext = class _ActorWorkflowContext {
+  #inner;
   #runCtx;
-  constructor(actor, runCtx) {
-    this.#actor = actor;
+  #actorAccessDepth = 0;
+  #allowActorAccess = false;
+  #guardViolation = false;
+  constructor(inner, runCtx) {
+    this.#inner = inner;
     this.#runCtx = runCtx;
   }
-  async addMessage(message) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.queueManager.enqueue(message.name, message.data)
-    );
+  get workflowId() {
+    return this.#inner.workflowId;
   }
-  async receiveMessages(opts) {
-    const messages = await this.#runCtx.internalKeepAwake(
-      this.#actor.queueManager.receive(
-        opts.names && opts.names.length > 0 ? [...opts.names] : void 0,
-        opts.count,
-        0,
-        void 0,
-        opts.completable
-      )
-    );
-    return messages.map((message) => ({
-      id: message.id.toString(),
-      name: message.name,
-      data: message.body,
-      sentAt: message.createdAt,
-      ...opts.completable ? {
-        complete: async (response) => {
-          await this.#runCtx.internalKeepAwake(
-            this.#actor.queueManager.completeMessage(
-              message,
-              response
-            )
-          );
-        }
-      } : {}
-    }));
+  get abortSignal() {
+    return this.#inner.abortSignal;
   }
-  async completeMessage(messageId, response) {
-    let parsedId;
-    try {
-      parsedId = BigInt(messageId);
-    } catch {
-      return;
+  get queue() {
+    const self = this;
+    async function next(name, opts) {
+      const message = await self.#inner.queue.next(name, opts);
+      return self.#toActorQueueMessage(message);
     }
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.queueManager.completeMessageById(parsedId, response)
-    );
-  }
-};
-var ActorWorkflowDriver = class {
-  workerPollInterval = 100;
-  messageDriver;
-  #actor;
-  #runCtx;
-  constructor(actor, runCtx) {
-    this.#actor = actor;
-    this.#runCtx = runCtx;
-    this.messageDriver = new ActorWorkflowMessageDriver(actor, runCtx);
-  }
-  async get(key) {
-    const [value] = await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchGet(this.#actor.id, [
-        makeWorkflowKey(key)
-      ])
-    );
-    return value ?? null;
-  }
-  async set(key, value) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchPut(this.#actor.id, [
-        [makeWorkflowKey(key), value]
-      ])
-    );
-  }
-  async delete(key) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvBatchDelete(this.#actor.id, [
-        makeWorkflowKey(key)
-      ])
-    );
+    async function nextBatch(name, opts) {
+      const messages = await self.#inner.queue.nextBatch(name, opts);
+      return messages.map(
+        (message) => self.#toActorQueueMessage(message)
+      );
+    }
+    async function send(name, body) {
+      self.#ensureActorAccess("queue.send");
+      await self.#runCtx.queue.send(name, body);
+    }
+    return {
+      next,
+      nextBatch,
+      send
+    };
   }
-  async deletePrefix(prefix) {
-    const start = makeWorkflowKey(prefix);
-    const end = computeUpperBound(start);
-    if (end) {
-      await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvDeleteRange(this.#actor.id, start, end)
+  async step(nameOrConfig, run) {
+    if (typeof nameOrConfig === "string") {
+      if (!run) {
+        throw new Error("Step run function missing");
+      }
+      return await this.#wrapActive(
+        () => this.#inner.step(
+          nameOrConfig,
+          () => this.#withActorAccessAndStateRollback(run)
+        )
       );
-    } else {
-      const entries = await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvListPrefix(this.#actor.id, start)
+    }
+    const stepConfig = nameOrConfig;
+    const config = {
+      ...stepConfig,
+      run: () => this.#withActorAccessAndStateRollback(stepConfig.run)
+    };
+    return await this.#wrapActive(() => this.#inner.step(config));
+  }
+  async tryStep(nameOrConfig, run) {
+    if (typeof nameOrConfig === "string") {
+      if (!run) {
+        throw new Error("Step run function missing");
+      }
+      return await this.#wrapActive(
+        () => this.#inner.tryStep(
+          nameOrConfig,
+          () => this.#withActorAccessAndStateRollback(run)
+        )
       );
-      if (entries.length === 0) {
-        return;
+    }
+    const stepConfig = nameOrConfig;
+    const config = {
+      ...stepConfig,
+      run: () => this.#withActorAccessAndStateRollback(stepConfig.run)
+    };
+    return await this.#wrapActive(() => this.#inner.tryStep(config));
+  }
+  async try(nameOrConfig, run) {
+    if (typeof nameOrConfig === "string") {
+      if (!run) {
+        throw new Error("Try run function missing");
       }
-      await this.#runCtx.internalKeepAwake(
-        this.#actor.driver.kvBatchDelete(
-          this.#actor.id,
-          entries.map(([key]) => key)
+      return await this.#wrapActive(
+        () => this.#inner.try(
+          nameOrConfig,
+          async (ctx) => run(this.#createChildContext(ctx))
         )
       );
     }
+    const tryConfig = nameOrConfig;
+    const config = {
+      ...tryConfig,
+      run: async (ctx) => tryConfig.run(this.#createChildContext(ctx))
+    };
+    return await this.#wrapActive(() => this.#inner.try(config));
   }
-  async deleteRange(start, end) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvDeleteRange(
-        this.#actor.id,
-        makeWorkflowKey(start),
-        makeWorkflowKey(end)
-      )
-    );
+  async loop(nameOrConfig, run) {
+    if (typeof nameOrConfig === "string") {
+      if (!run) {
+        throw new Error("Loop run function missing");
+      }
+      return await this.#wrapActive(
+        () => this.#inner.loop(
+          nameOrConfig,
+          async (ctx) => run(this.#createChildContext(ctx))
+        )
+      );
+    }
+    const wrapped = {
+      ...nameOrConfig,
+      run: async (ctx, state) => nameOrConfig.run(this.#createChildContext(ctx), state)
+    };
+    return await this.#wrapActive(() => this.#inner.loop(wrapped));
   }
-  async list(prefix) {
-    const entries = await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.kvListPrefix(
-        this.#actor.id,
-        makeWorkflowKey(prefix)
-      )
-    );
-    return entries.map(([key, value]) => ({
-      key: stripWorkflowKey(key),
-      value
-    }));
+  sleep(name, durationMs) {
+    return this.#inner.sleep(name, durationMs);
   }
-  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 }) => [
-            makeWorkflowKey(key),
-            value
-          ])
-        ),
-        this.#actor.stateManager.saveState({
-          immediate: true
-        })
-      ])
-    );
+  sleepUntil(name, timestampMs) {
+    return this.#inner.sleepUntil(name, timestampMs);
   }
-  async setAlarm(_workflowId, wakeAt) {
-    await this.#runCtx.internalKeepAwake(
-      this.#actor.driver.setAlarm(this.#actor, wakeAt)
-    );
-  }
-  async clearAlarm(_workflowId) {
-    return;
-  }
-  waitForMessages(messageNames, abortSignal) {
-    return this.#actor.queueManager.waitForNames(
-      messageNames.length > 0 ? messageNames : void 0,
-      abortSignal
-    );
-  }
-};
-var NoopWorkflowMessageDriver = class {
-  async addMessage(_message) {
-    throw new Error("Workflow control driver does not support messages");
-  }
-  async receiveMessages(_opts) {
-    throw new Error("Workflow control driver does not support messages");
-  }
-  async completeMessage(_messageId, _response) {
-    throw new Error("Workflow control driver does not support messages");
-  }
-};
-var ActorWorkflowControlDriver = class {
-  workerPollInterval = 100;
-  messageDriver = new NoopWorkflowMessageDriver();
-  #actor;
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  async get(key) {
-    const [value] = await this.#actor.driver.kvBatchGet(this.#actor.id, [
-      makeWorkflowKey(key)
-    ]);
-    return value ?? null;
-  }
-  async set(key, value) {
-    await this.#actor.driver.kvBatchPut(this.#actor.id, [
-      [makeWorkflowKey(key), value]
-    ]);
-  }
-  async delete(key) {
-    await this.#actor.driver.kvBatchDelete(this.#actor.id, [
-      makeWorkflowKey(key)
-    ]);
-  }
-  async deletePrefix(prefix) {
-    const start = makeWorkflowKey(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)
-    );
-  }
-  async deleteRange(start, end) {
-    await this.#actor.driver.kvDeleteRange(
-      this.#actor.id,
-      makeWorkflowKey(start),
-      makeWorkflowKey(end)
-    );
-  }
-  async list(prefix) {
-    const entries = await this.#actor.driver.kvListPrefix(
-      this.#actor.id,
-      makeWorkflowKey(prefix)
-    );
-    return entries.map(([key, value]) => ({
-      key: stripWorkflowKey(key),
-      value
-    }));
-  }
-  async batch(writes) {
-    if (writes.length === 0) {
-      return;
-    }
-    await this.#actor.driver.kvBatchPut(
-      this.#actor.id,
-      writes.map(({ key, value }) => [makeWorkflowKey(key), value])
-    );
-  }
-  async setAlarm(_workflowId, wakeAt) {
-    await this.#actor.driver.setAlarm(this.#actor, wakeAt);
-  }
-  async clearAlarm(_workflowId) {
-    return;
-  }
-  waitForMessages(_messageNames, _abortSignal) {
-    throw new Error("Workflow control driver does not support messages");
-  }
-};
-
-// src/workflow/constants.ts
-var WORKFLOW_GUARD_KV_KEY = "__rivet_actor_workflow_guard_triggered";
-
-// src/workflow/context.ts
-var ActorWorkflowContext = class _ActorWorkflowContext {
-  #inner;
-  #runCtx;
-  #actorAccessDepth = 0;
-  #allowActorAccess = false;
-  #guardViolation = false;
-  constructor(inner, runCtx) {
-    this.#inner = inner;
-    this.#runCtx = runCtx;
-  }
-  get workflowId() {
-    return this.#inner.workflowId;
-  }
-  get abortSignal() {
-    return this.#inner.abortSignal;
-  }
-  get queue() {
-    const self = this;
-    async function next(name, opts) {
-      const message = await self.#inner.queue.next(name, opts);
-      return self.#toActorQueueMessage(message);
-    }
-    async function nextBatch(name, opts) {
-      const messages = await self.#inner.queue.nextBatch(name, opts);
-      return messages.map(
-        (message) => self.#toActorQueueMessage(message)
-      );
-    }
-    async function send(name, body) {
-      self.#ensureActorAccess("queue.send");
-      await self.#runCtx.queue.send(name, body);
-    }
-    return {
-      next,
-      nextBatch,
-      send
-    };
-  }
-  async step(nameOrConfig, run) {
-    if (typeof nameOrConfig === "string") {
-      if (!run) {
-        throw new Error("Step run function missing");
-      }
-      return await this.#wrapActive(
-        () => this.#inner.step(
-          nameOrConfig,
-          () => this.#withActorAccessAndStateRollback(run)
-        )
-      );
-    }
-    const stepConfig = nameOrConfig;
-    const config = {
-      ...stepConfig,
-      run: () => this.#withActorAccessAndStateRollback(stepConfig.run)
-    };
-    return await this.#wrapActive(() => this.#inner.step(config));
-  }
-  async tryStep(nameOrConfig, run) {
-    if (typeof nameOrConfig === "string") {
-      if (!run) {
-        throw new Error("Step run function missing");
-      }
-      return await this.#wrapActive(
-        () => this.#inner.tryStep(
-          nameOrConfig,
-          () => this.#withActorAccessAndStateRollback(run)
-        )
-      );
-    }
-    const stepConfig = nameOrConfig;
-    const config = {
-      ...stepConfig,
-      run: () => this.#withActorAccessAndStateRollback(stepConfig.run)
-    };
-    return await this.#wrapActive(() => this.#inner.tryStep(config));
-  }
-  async try(nameOrConfig, run) {
-    if (typeof nameOrConfig === "string") {
-      if (!run) {
-        throw new Error("Try run function missing");
-      }
-      return await this.#wrapActive(
-        () => this.#inner.try(
-          nameOrConfig,
-          async (ctx) => run(this.#createChildContext(ctx))
-        )
-      );
-    }
-    const tryConfig = nameOrConfig;
-    const config = {
-      ...tryConfig,
-      run: async (ctx) => tryConfig.run(this.#createChildContext(ctx))
-    };
-    return await this.#wrapActive(() => this.#inner.try(config));
-  }
-  async loop(nameOrConfig, run) {
-    if (typeof nameOrConfig === "string") {
-      if (!run) {
-        throw new Error("Loop run function missing");
-      }
-      return await this.#wrapActive(
-        () => this.#inner.loop(
-          nameOrConfig,
-          async (ctx) => run(this.#createChildContext(ctx))
-        )
-      );
-    }
-    const wrapped = {
-      ...nameOrConfig,
-      run: async (ctx, state) => nameOrConfig.run(this.#createChildContext(ctx), state)
-    };
-    return await this.#wrapActive(() => this.#inner.loop(wrapped));
-  }
-  sleep(name, durationMs) {
-    return this.#inner.sleep(name, durationMs);
-  }
-  sleepUntil(name, timestampMs) {
-    return this.#inner.sleepUntil(name, timestampMs);
-  }
-  destroy() {
-    this.#ensureActorAccess("destroy");
-    this.#runCtx.destroy();
+  destroy() {
+    this.#ensureActorAccess("destroy");
+    this.#runCtx.destroy();
   }
   async rollbackCheckpoint(name) {
     await this.#wrapActive(() => this.#inner.rollbackCheckpoint(name));
@@ -608,6 +345,269 @@ var ActorWorkflowContext = class _ActorWorkflowContext {
   }
 };
 
+// src/workflow/driver.ts
+var WORKFLOW_STORAGE_PREFIX = workflowStoragePrefix();
+function stripWorkflowKey(prefixed) {
+  return prefixed.slice(WORKFLOW_STORAGE_PREFIX.length);
+}
+function computeUpperBound(prefix) {
+  const upperBound = prefix.slice();
+  for (let i = upperBound.length - 1; i >= 0; i--) {
+    if (upperBound[i] !== 255) {
+      upperBound[i]++;
+      return upperBound.slice(0, i + 1);
+    }
+  }
+  return null;
+}
+var ActorWorkflowMessageDriver = class {
+  #actor;
+  #runCtx;
+  constructor(actor, runCtx) {
+    this.#actor = actor;
+    this.#runCtx = runCtx;
+  }
+  async addMessage(message) {
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.queueManager.enqueue(message.name, message.data)
+    );
+  }
+  async receiveMessages(opts) {
+    const messages = await this.#runCtx.internalKeepAwake(
+      this.#actor.queueManager.receive(
+        opts.names && opts.names.length > 0 ? [...opts.names] : void 0,
+        opts.count,
+        0,
+        void 0,
+        opts.completable
+      )
+    );
+    return messages.map((message) => ({
+      id: message.id.toString(),
+      name: message.name,
+      data: message.body,
+      sentAt: message.createdAt,
+      ...opts.completable ? {
+        complete: async (response) => {
+          await this.#runCtx.internalKeepAwake(
+            this.#actor.queueManager.completeMessage(
+              message,
+              response
+            )
+          );
+        }
+      } : {}
+    }));
+  }
+  async completeMessage(messageId, response) {
+    let parsedId;
+    try {
+      parsedId = BigInt(messageId);
+    } catch {
+      return;
+    }
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.queueManager.completeMessageById(parsedId, response)
+    );
+  }
+};
+var ActorWorkflowDriver = class {
+  workerPollInterval = 100;
+  messageDriver;
+  #actor;
+  #runCtx;
+  constructor(actor, runCtx) {
+    this.#actor = actor;
+    this.#runCtx = runCtx;
+    this.messageDriver = new ActorWorkflowMessageDriver(actor, runCtx);
+  }
+  async get(key) {
+    const [value] = await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.kvBatchGet(this.#actor.id, [
+        makeWorkflowKey(key)
+      ])
+    );
+    return value ?? null;
+  }
+  async set(key, value) {
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.kvBatchPut(this.#actor.id, [
+        [makeWorkflowKey(key), value]
+      ])
+    );
+  }
+  async delete(key) {
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.kvBatchDelete(this.#actor.id, [
+        makeWorkflowKey(key)
+      ])
+    );
+  }
+  async deletePrefix(prefix) {
+    const start = makeWorkflowKey(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)
+        )
+      );
+    }
+  }
+  async deleteRange(start, end) {
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.kvDeleteRange(
+        this.#actor.id,
+        makeWorkflowKey(start),
+        makeWorkflowKey(end)
+      )
+    );
+  }
+  async list(prefix) {
+    const entries = await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.kvListPrefix(
+        this.#actor.id,
+        makeWorkflowKey(prefix)
+      )
+    );
+    return entries.map(([key, value]) => ({
+      key: stripWorkflowKey(key),
+      value
+    }));
+  }
+  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 }) => [
+            makeWorkflowKey(key),
+            value
+          ])
+        ),
+        this.#actor.stateManager.saveState({
+          immediate: true
+        })
+      ])
+    );
+  }
+  async setAlarm(_workflowId, wakeAt) {
+    await this.#runCtx.internalKeepAwake(
+      this.#actor.driver.setAlarm(this.#actor, wakeAt)
+    );
+  }
+  async clearAlarm(_workflowId) {
+    return;
+  }
+  waitForMessages(messageNames, abortSignal) {
+    return this.#actor.queueManager.waitForNames(
+      messageNames.length > 0 ? messageNames : void 0,
+      abortSignal
+    );
+  }
+};
+var NoopWorkflowMessageDriver = class {
+  async addMessage(_message) {
+    throw new Error("Workflow control driver does not support messages");
+  }
+  async receiveMessages(_opts) {
+    throw new Error("Workflow control driver does not support messages");
+  }
+  async completeMessage(_messageId, _response) {
+    throw new Error("Workflow control driver does not support messages");
+  }
+};
+var ActorWorkflowControlDriver = class {
+  workerPollInterval = 100;
+  messageDriver = new NoopWorkflowMessageDriver();
+  #actor;
+  constructor(actor) {
+    this.#actor = actor;
+  }
+  async get(key) {
+    const [value] = await this.#actor.driver.kvBatchGet(this.#actor.id, [
+      makeWorkflowKey(key)
+    ]);
+    return value ?? null;
+  }
+  async set(key, value) {
+    await this.#actor.driver.kvBatchPut(this.#actor.id, [
+      [makeWorkflowKey(key), value]
+    ]);
+  }
+  async delete(key) {
+    await this.#actor.driver.kvBatchDelete(this.#actor.id, [
+      makeWorkflowKey(key)
+    ]);
+  }
+  async deletePrefix(prefix) {
+    const start = makeWorkflowKey(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)
+    );
+  }
+  async deleteRange(start, end) {
+    await this.#actor.driver.kvDeleteRange(
+      this.#actor.id,
+      makeWorkflowKey(start),
+      makeWorkflowKey(end)
+    );
+  }
+  async list(prefix) {
+    const entries = await this.#actor.driver.kvListPrefix(
+      this.#actor.id,
+      makeWorkflowKey(prefix)
+    );
+    return entries.map(([key, value]) => ({
+      key: stripWorkflowKey(key),
+      value
+    }));
+  }
+  async batch(writes) {
+    if (writes.length === 0) {
+      return;
+    }
+    await this.#actor.driver.kvBatchPut(
+      this.#actor.id,
+      writes.map(({ key, value }) => [makeWorkflowKey(key), value])
+    );
+  }
+  async setAlarm(_workflowId, wakeAt) {
+    await this.#actor.driver.setAlarm(this.#actor, wakeAt);
+  }
+  async clearAlarm(_workflowId) {
+    return;
+  }
+  waitForMessages(_messageNames, _abortSignal) {
+    throw new Error("Workflow control driver does not support messages");
+  }
+};
+
 // src/workflow/mod.ts
 import { Loop } from "@rivetkit/workflow-engine";
 function shouldRethrowWorkflowError(error) {