@rivetkit/engine-runner 2.1.9 → 2.1.10

package/dist/mod.cjs

@@ -104,7 +104,7 @@ ${error.stack}` : ""}`;
 
 // src/actor.ts
 var RunnerActor = (_class = class {
-  constructor(actorId, generation, config, hibernatingRequests) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);
+  constructor(actorId, generation, config, hibernatingRequests) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
     this.hibernatingRequests = hibernatingRequests;
     this.actorId = actorId;
     this.generation = generation;
@@ -125,6 +125,12 @@ var RunnerActor = (_class = class {
    * that the caller is implemented correctly.
    **/
   __init6() {this.hibernationRestored = false}
+  /**
+   * Set when the actor has explicitly requested to stop (e.g. c.destroy()).
+   * Used to send StopCode.Ok (graceful) vs StopCode.Error (ungraceful) so
+   * the engine crash policy handles sleepable actors correctly.
+   **/
+  __init7() {this.stopIntentSent = false}
   // Pending request methods
   getPendingRequest(gatewayId, requestId) {
     var _a;
@@ -1534,6 +1540,7 @@ var Runner = class {
   
   #started = false;
   #shutdown = false;
+  #draining = false;
   #reconnectAttempt = 0;
   #reconnectTimeout;
   // Protocol metadata
@@ -1593,6 +1600,22 @@ var Runner = class {
     if (!actor) return;
     this.#sendActorIntent(actorId, actor.generation, "stop");
   }
+  /**
+   * Like stopActor but marks the actor for graceful destruction.
+   * This ensures the engine destroys the actor instead of sleeping it.
+   *
+   * NOTE: If a drain (GoingAway) occurs after this is called but before the
+   * stop completes, the engine's going_away flag overrides graceful_exit and
+   * the actor will sleep instead of being destroyed. The destroy intent is
+   * lost in this race. This is acceptable since the actor will be rescheduled
+   * elsewhere and can be destroyed on the next wake.
+   */
+  destroyActor(actorId, generation) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    actor.stopIntentSent = true;
+    this.#sendActorIntent(actorId, actor.generation, "stop");
+  }
   async forceStopActor(actorId, generation) {
     var _a, _b;
     (_a = this.log) == null ? void 0 : _a.debug({
@@ -1745,6 +1768,7 @@ var Runner = class {
       return;
     }
     this.#shutdown = true;
+    this.#draining = !immediate;
     (_b = this.log) == null ? void 0 : _b.info({
       msg: "starting shutdown",
       immediate,
@@ -2319,7 +2343,7 @@ var Runner = class {
       actorState = {
         tag: "ActorStateStopped",
         val: {
-          code: protocol.StopCode.Ok,
+          code: actor.stopIntentSent || this.#draining ? protocol.StopCode.Ok : protocol.StopCode.Error,
           message: null
         }
       };