rivetkit 2.3.0-rc.9 → 2.3.1

package/dist/tsup/workflow/mod.cjs

@@ -1,22 +1,24 @@
-"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(); } } var _class; var _class2;
+"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;
 
-var _chunkCPA4Y3RGcjs = require('../chunk-CPA4Y3RG.cjs');
+var _chunkJLJJZYCJcjs = require('../chunk-JLJJZYCJ.cjs');
+require('../chunk-4UUEB43Y.cjs');
 
 
 
-var _chunkWQ4HNA4Wcjs = require('../chunk-WQ4HNA4W.cjs');
-require('../chunk-4CGA6QJO.cjs');
 
+var _chunk3MHDOUD7cjs = require('../chunk-3MHDOUD7.cjs');
 
 
-var _chunkLD5YASJUcjs = require('../chunk-LD5YASJU.cjs');
-require('../chunk-VJFRBJVQ.cjs');
 
+var _chunkVE2X4KMGcjs = require('../chunk-VE2X4KMG.cjs');
+require('../chunk-V5KMAMX3.cjs');
 
-var _chunkY5NSCZA2cjs = require('../chunk-Y5NSCZA2.cjs');
 
+var _chunkMNHKOS6Lcjs = require('../chunk-MNHKOS6L.cjs');
 
-var _chunkQAZLM4WTcjs = require('../chunk-QAZLM4WT.cjs');
+
+
+var _chunk4FC7TVS6cjs = require('../chunk-4FC7TVS6.cjs');
 
 // src/workflow/mod.ts
 
@@ -33,8 +35,345 @@ var _chunkQAZLM4WTcjs = require('../chunk-QAZLM4WT.cjs');
 var _workflowengine = require('@rivetkit/workflow-engine');
 var _invariant = require('invariant'); var _invariant2 = _interopRequireDefault(_invariant);
 
+// src/workflow/constants.ts
+var WORKFLOW_GUARD_KV_KEY = "__rivet_actor_workflow_guard_triggered";
+
+// src/workflow/context.ts
+var DEACTIVATE_STEP = /* @__PURE__ */ Symbol("workflow.step.deactivate");
+var WorkflowStepContext = class {
+  #runCtx;
+  #active = true;
+  #onGuardViolation;
+  constructor(runCtx, onGuardViolation) {
+    this.#runCtx = runCtx;
+    this.#onGuardViolation = onGuardViolation;
+  }
+  [DEACTIVATE_STEP]() {
+    this.#active = false;
+  }
+  #ensureActive(feature) {
+    if (!this.#active) {
+      this.#onGuardViolation();
+      throw new Error(
+        `${feature} is only available inside workflow steps`
+      );
+    }
+  }
+  get actorId() {
+    return this.#runCtx.actorId;
+  }
+  get name() {
+    return this.#runCtx.name;
+  }
+  get key() {
+    return this.#runCtx.key;
+  }
+  get log() {
+    return this.#runCtx.log;
+  }
+  get abortSignal() {
+    return this.#runCtx.abortSignal;
+  }
+  get state() {
+    this.#ensureActive("state");
+    return this.#runCtx.state;
+  }
+  get vars() {
+    this.#ensureActive("vars");
+    return this.#runCtx.vars;
+  }
+  get db() {
+    this.#ensureActive("db");
+    return this.#runCtx.db;
+  }
+  client() {
+    this.#ensureActive("client");
+    return this.#runCtx.client();
+  }
+  broadcast(name, ...args) {
+    this.#ensureActive("broadcast");
+    this.#runCtx.broadcast(
+      name,
+      ...args
+    );
+  }
+  get queue() {
+    const self = this;
+    async function send(name, body) {
+      self.#ensureActive("queue.send");
+      await self.#runCtx.queue.send(name, body);
+    }
+    return { send };
+  }
+  /**
+   * Holds the actor awake for the duration of the provided promise. The actor
+   * cannot idle-sleep or finalize the sleep grace period until the promise
+   * settles.
+   */
+  keepAwake(promise) {
+    this.#ensureActive("keepAwake");
+    return this.#runCtx.keepAwake(promise);
+  }
+  /**
+   * Registers a promise that the sleep grace period will wait on. Use this for
+   * best-effort flush/cleanup work that may complete inside the grace window.
+   */
+  waitUntil(promise) {
+    this.#ensureActive("waitUntil");
+    this.#runCtx.waitUntil(promise);
+  }
+  destroy() {
+    this.#ensureActive("destroy");
+    this.#runCtx.destroy();
+  }
+};
+var WorkflowContext = class _WorkflowContext {
+  #inner;
+  #runCtx;
+  constructor(inner, runCtx) {
+    this.#inner = inner;
+    this.#runCtx = runCtx;
+  }
+  get workflowId() {
+    return this.#inner.workflowId;
+  }
+  get abortSignal() {
+    return this.#inner.abortSignal;
+  }
+  get actorId() {
+    return this.#runCtx.actorId;
+  }
+  get name() {
+    return this.#runCtx.name;
+  }
+  get key() {
+    return this.#runCtx.key;
+  }
+  get log() {
+    return this.#runCtx.log;
+  }
+  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)
+      );
+    }
+    return {
+      next,
+      nextBatch
+    };
+  }
+  async step(nameOrConfig, run) {
+    if (typeof nameOrConfig === "string") {
+      if (!run) {
+        throw new Error("Step run function missing");
+      }
+      const stepRun = run;
+      return await this.#wrapActive(
+        () => this.#inner.step(nameOrConfig, () => this.#runStep(stepRun))
+      );
+    }
+    const stepConfig = nameOrConfig;
+    const rollback = stepConfig.rollback;
+    const config = {
+      ...stepConfig,
+      run: () => this.#runStep(stepConfig.run),
+      rollback: rollback ? (_ctx, output) => this.#runRollback(rollback, output) : void 0
+    };
+    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");
+      }
+      const stepRun = run;
+      return await this.#wrapActive(
+        () => this.#inner.tryStep(nameOrConfig, () => this.#runStep(stepRun))
+      );
+    }
+    const stepConfig = nameOrConfig;
+    const rollback = stepConfig.rollback;
+    const config = {
+      ...stepConfig,
+      run: () => this.#runStep(stepConfig.run),
+      rollback: rollback ? (_ctx, output) => this.#runRollback(rollback, output) : void 0
+    };
+    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");
+      }
+      const tryRun = run;
+      return await this.#wrapActive(
+        () => this.#inner.try(
+          nameOrConfig,
+          async (ctx) => tryRun(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");
+      }
+      const loopRun = run;
+      return await this.#wrapActive(
+        () => this.#inner.loop(
+          nameOrConfig,
+          // A void return (no explicit Loop result) is undefined at
+          // runtime, which the engine treats as continue.
+          async (ctx) => await _asyncNullishCoalesce(await loopRun(this.#createChildContext(ctx)), async () => ( void 0))
+        )
+      );
+    }
+    const loopConfig = nameOrConfig;
+    const wrapped = {
+      ...loopConfig,
+      run: (async (ctx, state) => await _asyncNullishCoalesce(await loopConfig.run(this.#createChildContext(ctx), state), async () => ( void 0)))
+    };
+    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);
+  }
+  async rollbackCheckpoint(name) {
+    await this.#wrapActive(() => this.#inner.rollbackCheckpoint(name));
+  }
+  async join(name, branches) {
+    const wrappedBranches = Object.fromEntries(
+      Object.entries(branches).map(([key, branch]) => [
+        key,
+        {
+          run: async (ctx) => branch.run(this.#createChildContext(ctx))
+        }
+      ])
+    );
+    return await this.#wrapActive(
+      () => this.#inner.join(name, wrappedBranches)
+    );
+  }
+  async race(name, branches) {
+    const wrappedBranches = branches.map((branch) => ({
+      name: branch.name,
+      run: (ctx) => branch.run(this.#createChildContext(ctx))
+    }));
+    return await this.#wrapActive(
+      () => this.#inner.race(name, wrappedBranches)
+    );
+  }
+  async removed(name, originalType) {
+    await this.#wrapActive(() => this.#inner.removed(name, originalType));
+  }
+  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.
+  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]();
+    }
+  }
+  #toActorQueueMessage(message) {
+    let id;
+    try {
+      id = BigInt(message.id);
+    } catch (e) {
+      throw new Error(`Invalid queue message id "${message.id}"`);
+    }
+    return {
+      id,
+      name: message.name,
+      body: message.body,
+      createdAt: message.createdAt,
+      ...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.
+  async #runRollback(rollback, output) {
+    const stepCtx = new WorkflowStepContext(this.#runCtx, () => this.#markGuardTriggered());
+    try {
+      await rollback(stepCtx, output);
+    } finally {
+      stepCtx[DEACTIVATE_STEP]();
+    }
+  }
+  async #wrapActive(run) {
+    return await this.#runCtx.internalKeepAwake(run);
+  }
+  // Records that a step context was used outside its step. Mirrors the value
+  // onto actor state and a KV flag so callers can observe the violation.
+  #markGuardTriggered() {
+    try {
+      const state = this.#runCtx.state;
+      if (state && typeof state === "object" && "guardTriggered" in state) {
+        state.guardTriggered = true;
+      }
+    } catch (e2) {
+    }
+    this.#runCtx.waitUntil(
+      (async () => {
+        try {
+          await this.#runCtx.kv.put(WORKFLOW_GUARD_KV_KEY, "true");
+        } catch (error) {
+          this.#runCtx.log.error({
+            msg: "failed to persist workflow guard flag",
+            error
+          });
+        }
+      })()
+    );
+  }
+  #createChildContext(ctx) {
+    return new _WorkflowContext(ctx, this.#runCtx);
+  }
+};
+
 // src/workflow/driver.ts
-var WORKFLOW_STORAGE_PREFIX = _chunkLD5YASJUcjs.workflowStoragePrefix.call(void 0, );
+var WORKFLOW_STORAGE_PREFIX = _chunkVE2X4KMGcjs.workflowStoragePrefix.call(void 0, );
 function stripWorkflowKey(prefixed) {
   return prefixed.slice(WORKFLOW_STORAGE_PREFIX.length);
 }
@@ -91,7 +430,7 @@ var ActorWorkflowMessageDriver = class {
     let parsedId;
     try {
       parsedId = BigInt(messageId);
-    } catch (e) {
+    } catch (e3) {
       return;
     }
     await this.#runCtx.internalKeepAwake(
@@ -112,7 +451,7 @@ var ActorWorkflowDriver = (_class = class {
   async get(key) {
     const [value] = await this.#runCtx.internalKeepAwake(
       this.#actor.driver.kvBatchGet(this.#actor.id, [
-        _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key)
+        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
       ])
     );
     return _nullishCoalesce(value, () => ( null));
@@ -120,19 +459,19 @@ var ActorWorkflowDriver = (_class = class {
   async set(key, value) {
     await this.#runCtx.internalKeepAwake(
       this.#actor.driver.kvBatchPut(this.#actor.id, [
-        [_chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key), value]
+        [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value]
       ])
     );
   }
   async delete(key) {
     await this.#runCtx.internalKeepAwake(
       this.#actor.driver.kvBatchDelete(this.#actor.id, [
-        _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key)
+        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
       ])
     );
   }
   async deletePrefix(prefix) {
-    const start = _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, prefix);
+    const start = _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix);
     const end = computeUpperBound(start);
     if (end) {
       await this.#runCtx.internalKeepAwake(
@@ -157,8 +496,8 @@ var ActorWorkflowDriver = (_class = class {
     await this.#runCtx.internalKeepAwake(
       this.#actor.driver.kvDeleteRange(
         this.#actor.id,
-        _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, start),
-        _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, end)
+        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, start),
+        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, end)
       )
     );
   }
@@ -166,7 +505,7 @@ var ActorWorkflowDriver = (_class = class {
     const entries = await this.#runCtx.internalKeepAwake(
       this.#actor.driver.kvListPrefix(
         this.#actor.id,
-        _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, prefix)
+        _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix)
       )
     );
     return entries.map(([key, value]) => ({
@@ -181,7 +520,7 @@ var ActorWorkflowDriver = (_class = class {
         this.#actor.driver.kvBatchPut(
           this.#actor.id,
           writes.map(({ key, value }) => [
-            _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key),
+            _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key),
             value
           ])
         ),
@@ -226,22 +565,22 @@ var ActorWorkflowControlDriver = (_class2 = class {
   }
   async get(key) {
     const [value] = await this.#actor.driver.kvBatchGet(this.#actor.id, [
-      _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key)
+      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
     ]);
     return _nullishCoalesce(value, () => ( null));
   }
   async set(key, value) {
     await this.#actor.driver.kvBatchPut(this.#actor.id, [
-      [_chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key), value]
+      [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value]
     ]);
   }
   async delete(key) {
     await this.#actor.driver.kvBatchDelete(this.#actor.id, [
-      _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key)
+      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key)
     ]);
   }
   async deletePrefix(prefix) {
-    const start = _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, 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);
@@ -262,14 +601,14 @@ var ActorWorkflowControlDriver = (_class2 = class {
   async deleteRange(start, end) {
     await this.#actor.driver.kvDeleteRange(
       this.#actor.id,
-      _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, start),
-      _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, end)
+      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, start),
+      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, end)
     );
   }
   async list(prefix) {
     const entries = await this.#actor.driver.kvListPrefix(
       this.#actor.id,
-      _chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, prefix)
+      _chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, prefix)
     );
     return entries.map(([key, value]) => ({
       key: stripWorkflowKey(key),
@@ -282,7 +621,7 @@ var ActorWorkflowControlDriver = (_class2 = class {
     }
     await this.#actor.driver.kvBatchPut(
       this.#actor.id,
-      writes.map(({ key, value }) => [_chunkLD5YASJUcjs.makeWorkflowKey.call(void 0, key), value])
+      writes.map(({ key, value }) => [_chunkVE2X4KMGcjs.makeWorkflowKey.call(void 0, key), value])
     );
   }
   async setAlarm(_workflowId, wakeAt) {
@@ -296,293 +635,6 @@ var ActorWorkflowControlDriver = (_class2 = class {
   }
 }, _class2);
 
-// 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.#withActorAccess(run)
-        )
-      );
-    }
-    const stepConfig = nameOrConfig;
-    const config = {
-      ...stepConfig,
-      run: () => this.#withActorAccess(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.#withActorAccess(run)
-        )
-      );
-    }
-    const stepConfig = nameOrConfig;
-    const config = {
-      ...stepConfig,
-      run: () => this.#withActorAccess(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();
-  }
-  async rollbackCheckpoint(name) {
-    await this.#wrapActive(() => this.#inner.rollbackCheckpoint(name));
-  }
-  async join(name, branches) {
-    const wrappedBranches = Object.fromEntries(
-      Object.entries(branches).map(([key, branch]) => [
-        key,
-        {
-          run: async (ctx) => branch.run(this.#createChildContext(ctx))
-        }
-      ])
-    );
-    return await this.#wrapActive(
-      () => this.#inner.join(name, wrappedBranches)
-    );
-  }
-  async race(name, branches) {
-    const wrappedBranches = branches.map((branch) => ({
-      name: branch.name,
-      run: (ctx) => branch.run(this.#createChildContext(ctx))
-    }));
-    return await this.#wrapActive(
-      () => this.#inner.race(name, wrappedBranches)
-    );
-  }
-  async removed(name, originalType) {
-    await this.#wrapActive(() => this.#inner.removed(name, originalType));
-  }
-  isEvicted() {
-    return this.#inner.isEvicted();
-  }
-  get state() {
-    this.#ensureActorAccess("state");
-    return this.#runCtx.state;
-  }
-  get vars() {
-    this.#ensureActorAccess("vars");
-    return this.#runCtx.vars;
-  }
-  client() {
-    this.#ensureActorAccess("client");
-    return this.#runCtx.client();
-  }
-  get db() {
-    this.#ensureActorAccess("db");
-    return this.#runCtx.db;
-  }
-  get log() {
-    return this.#runCtx.log;
-  }
-  /** @deprecated No-op. Use `keepAwake(promise)` or `waitUntil(promise)` instead. */
-  setPreventSleep(_prevent) {
-    this.#ensureActorAccess("setPreventSleep");
-  }
-  /** @deprecated No-op. Always returns `false`. */
-  get preventSleep() {
-    this.#ensureActorAccess("preventSleep");
-    return false;
-  }
-  /**
-   * Holds the actor awake for the duration of the provided promise. The
-   * actor cannot idle-sleep or finalize the sleep grace period until the
-   * promise settles.
-   */
-  keepAwake(promise) {
-    this.#ensureActorAccess("keepAwake");
-    return this.#runCtx.keepAwake(promise);
-  }
-  /**
-   * Registers a promise that the sleep grace period will wait on. Use this
-   * for best-effort flush/cleanup work that may complete inside the grace
-   * window. For work the actor must stay running through, prefer
-   * `c.keepAwake(promise)` which also blocks idle sleep.
-   */
-  waitUntil(promise) {
-    this.#ensureActorAccess("waitUntil");
-    this.#runCtx.waitUntil(promise);
-  }
-  get actorId() {
-    return this.#runCtx.actorId;
-  }
-  broadcast(name, ...args) {
-    this.#ensureActorAccess("broadcast");
-    this.#runCtx.broadcast(
-      name,
-      ...args
-    );
-  }
-  #toActorQueueMessage(message) {
-    let id;
-    try {
-      id = BigInt(message.id);
-    } catch (e2) {
-      throw new Error(`Invalid queue message id "${message.id}"`);
-    }
-    return {
-      id,
-      name: message.name,
-      body: message.body,
-      createdAt: message.createdAt,
-      ...message.complete ? { complete: message.complete } : {}
-    };
-  }
-  async #wrapActive(run) {
-    return await this.#runCtx.internalKeepAwake(run);
-  }
-  async #withActorAccess(run) {
-    this.#actorAccessDepth++;
-    if (this.#actorAccessDepth === 1) {
-      this.#allowActorAccess = true;
-    }
-    try {
-      return await run();
-    } finally {
-      this.#actorAccessDepth--;
-      if (this.#actorAccessDepth === 0) {
-        this.#allowActorAccess = false;
-      }
-    }
-  }
-  #ensureActorAccess(feature) {
-    if (!this.#allowActorAccess) {
-      this.#guardViolation = true;
-      this.#markGuardTriggered();
-      throw new Error(
-        `${feature} is only available inside workflow steps`
-      );
-    }
-  }
-  consumeGuardViolation() {
-    const violated = this.#guardViolation;
-    this.#guardViolation = false;
-    return violated;
-  }
-  #markGuardTriggered() {
-    try {
-      const state = this.#runCtx.state;
-      if (state && typeof state === "object" && "guardTriggered" in state) {
-        state.guardTriggered = true;
-      }
-    } catch (e3) {
-    }
-    this.#runCtx.waitUntil(
-      (async () => {
-        try {
-          await this.#runCtx.kv.put(WORKFLOW_GUARD_KV_KEY, "true");
-        } catch (error) {
-          this.#runCtx.log.error({
-            msg: "failed to persist workflow guard flag",
-            error
-          });
-        }
-      })()
-    );
-  }
-  #createChildContext(ctx) {
-    return new _ActorWorkflowContext(ctx, this.#runCtx);
-  }
-};
-
 // src/workflow/mod.ts
 
 function shouldRethrowWorkflowError(error) {
@@ -595,7 +647,7 @@ function shouldRethrowWorkflowError(error) {
   return true;
 }
 function workflowReplayInFlightError() {
-  return new (0, _chunkQAZLM4WTcjs.RivetError)(
+  return new (0, _chunk4FC7TVS6cjs.RivetError)(
     "actor",
     "workflow_in_flight",
     "Workflow replay is unavailable while the workflow is currently in flight.",
@@ -614,13 +666,13 @@ function workflow(fn, options = {}) {
   function getWorkflowInspector(actorId) {
     let workflowInspector = workflowInspectors.get(actorId);
     if (!workflowInspector) {
-      workflowInspector = _chunkCPA4Y3RGcjs.createWorkflowInspectorAdapter.call(void 0, );
+      workflowInspector = _chunkJLJJZYCJcjs.createWorkflowInspectorAdapter.call(void 0, );
       workflowInspectors.set(actorId, workflowInspector);
     }
     return workflowInspector;
   }
   async function run(runCtx) {
-    const actor = runCtx[_chunkWQ4HNA4Wcjs.ACTOR_CONTEXT_INTERNAL_SYMBOL];
+    const actor = runCtx[_chunk3MHDOUD7cjs.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);
@@ -650,11 +702,13 @@ function workflow(fn, options = {}) {
     });
     const handle = _workflowengine.runWorkflow.call(void 0, 
       actor.id,
-      async (ctx) => await fn(new ActorWorkflowContext(ctx, runCtx)),
+      async (ctx) => await fn(new WorkflowContext(ctx, runCtx)),
       void 0,
       driver,
       {
         mode: "live",
+        // The actor logger and the engine's pino logger are runtime
+        // compatible but not structurally assignable.
         logger: runCtx.log,
         onHistoryUpdated: workflowInspector.update,
         onError: onError ? async (event) => await onError(runCtx, event) : void 0
@@ -674,27 +728,33 @@ function workflow(fn, options = {}) {
     try {
       await handle.result;
     } catch (error) {
-      if (runCtx.abortSignal.aborted) {
+      if (runCtx.abortSignal.aborted || _chunk4FC7TVS6cjs.isActorAbortedError.call(void 0, error)) {
         return;
       }
       if (shouldRethrowWorkflowError(error)) {
         runCtx.log.error({
           msg: "workflow run failed",
-          error: _chunkY5NSCZA2cjs.stringifyError.call(void 0, error)
+          error: _chunkMNHKOS6Lcjs.stringifyError.call(void 0, error)
         });
         throw error;
       }
       runCtx.log.warn({
         msg: "workflow failed and will sleep until woken",
-        error: _chunkY5NSCZA2cjs.stringifyError.call(void 0, error)
+        error: _chunkMNHKOS6Lcjs.stringifyError.call(void 0, error)
       });
     } finally {
       runCtx.abortSignal.removeEventListener("abort", onAbort);
     }
   }
   const runWithConfig = run;
-  runWithConfig[_chunkWQ4HNA4Wcjs.RUN_FUNCTION_CONFIG_SYMBOL] = {
+  runWithConfig[_chunk3MHDOUD7cjs.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
+    // for the process lifetime.
+    disposeInspector: (actorId) => {
+      workflowInspectors.delete(actorId);
+    },
     inspectorFactory: (actor) => {
       const actorId = resolveWorkflowInspectorActorId(actor);
       return {
@@ -729,5 +789,6 @@ function resolveWorkflowInspectorActorId(actor) {
 
 
 
-exports.ActorWorkflowContext = ActorWorkflowContext; exports.Loop = _workflowengine.Loop; exports.workflow = workflow;
+
+exports.Loop = _workflowengine.Loop; exports.WorkflowContext = WorkflowContext; exports.WorkflowStepContext = WorkflowStepContext; exports.workflow = workflow;
 //# sourceMappingURL=mod.cjs.map