@rivetkit/engine-runner 2.0.26 → 2.0.27

package/dist/mod.js

@@ -83,23 +83,6 @@ function idToStr(id) {
   const bytes = new Uint8Array(id);
   return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
-function stringifyError(error) {
-  var _a;
-  if (error instanceof Error) {
-    return `${error.name}: ${error.message}${error.stack ? `
-${error.stack}` : ""}`;
-  } else if (typeof error === "string") {
-    return error;
-  } else if (typeof error === "object" && error !== null) {
-    try {
-      return `${JSON.stringify(error)}`;
-    } catch {
-      return `[object ${((_a = error.constructor) == null ? void 0 : _a.name) || "Object"}]`;
-    }
-  } else {
-    return String(error);
-  }
-}
 
 // src/actor.ts
 var RunnerActor = class {
@@ -116,9 +99,6 @@ var RunnerActor = class {
   pendingRequests = [];
   webSockets = [];
   actorStartPromise;
-  lastCommandIdx = -1n;
-  nextEventIdx = 0n;
-  eventHistory = [];
   /**
    * If restoreHibernatingRequests has been called. This is used to assert
    * that the caller is implemented correctly.
@@ -235,14 +215,6 @@ var RunnerActor = class {
       this.webSockets.splice(index, 1);
     }
   }
-  handleAckEvents(lastEventIdx) {
-    this.eventHistory = this.eventHistory.filter(
-      (event) => event.checkpoint.index > lastEventIdx
-    );
-  }
-  recordEvent(eventWrapper) {
-    this.eventHistory.push(eventWrapper);
-  }
 };
 
 // src/stringify.ts
@@ -261,6 +233,8 @@ function stringifyMessageId(messageId) {
 }
 function stringifyToServerTunnelMessageKind(kind) {
   switch (kind.tag) {
+    case "DeprecatedTunnelAck":
+      return "DeprecatedTunnelAck";
     case "ToServerResponseStart": {
       const { status, headers, body, stream } = kind.val;
       const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -294,6 +268,8 @@ function stringifyToServerTunnelMessageKind(kind) {
 }
 function stringifyToClientTunnelMessageKind(kind) {
   switch (kind.tag) {
+    case "DeprecatedTunnelAck":
+      return "DeprecatedTunnelAck";
     case "ToClientRequestStart": {
       const { actorId, method, path, headers, body, stream } = kind.val;
       const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -324,20 +300,20 @@ function stringifyToClientTunnelMessageKind(kind) {
 function stringifyCommand(command) {
   switch (command.tag) {
     case "CommandStartActor": {
-      const { generation, config, hibernatingRequests } = command.val;
+      const { actorId, generation, config, hibernatingRequests } = command.val;
       const keyStr = config.key === null ? "null" : `"${config.key}"`;
       const inputStr = config.input === null ? "null" : stringifyArrayBuffer(config.input);
       const hibernatingRequestsStr = hibernatingRequests.length > 0 ? `[${hibernatingRequests.map((hr) => `{gatewayId: ${idToStr(hr.gatewayId)}, requestId: ${idToStr(hr.requestId)}}`).join(", ")}]` : "[]";
-      return `CommandStartActor{generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
+      return `CommandStartActor{actorId: "${actorId}", generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
     }
     case "CommandStopActor": {
-      const { generation } = command.val;
-      return `CommandStopActor{generation: ${generation}}`;
+      const { actorId, generation } = command.val;
+      return `CommandStopActor{actorId: "${actorId}", generation: ${generation}}`;
     }
   }
 }
 function stringifyCommandWrapper(wrapper) {
-  return `CommandWrapper{actorId: "${wrapper.checkpoint.actorId}", index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
+  return `CommandWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
 }
 function stringifyEvent(event) {
   switch (event.tag) {
@@ -368,7 +344,7 @@ function stringifyEvent(event) {
   }
 }
 function stringifyEventWrapper(wrapper) {
-  return `EventWrapper{actorId: ${wrapper.checkpoint.actorId}, index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
+  return `EventWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
 }
 function stringifyToServer(message) {
   switch (message.tag) {
@@ -377,27 +353,28 @@ function stringifyToServer(message) {
         name,
         version,
         totalSlots,
+        lastCommandIdx,
         prepopulateActorNames,
         metadata
       } = message.val;
+      const lastCommandIdxStr = lastCommandIdx === null ? "null" : stringifyBigInt(lastCommandIdx);
       const prepopulateActorNamesStr = prepopulateActorNames === null ? "null" : `Map(${prepopulateActorNames.size})`;
       const metadataStr = metadata === null ? "null" : `"${metadata}"`;
-      return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
+      return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, lastCommandIdx: ${lastCommandIdxStr}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
     }
     case "ToServerEvents": {
       const events = message.val;
       return `ToServerEvents{count: ${events.length}, events: [${events.map((e) => stringifyEventWrapper(e)).join(", ")}]}`;
     }
     case "ToServerAckCommands": {
-      const { lastCommandCheckpoints } = message.val;
-      const checkpointsStr = lastCommandCheckpoints.length > 0 ? `[${lastCommandCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]` : "[]";
-      return `ToServerAckCommands{lastCommandCheckpoints: ${checkpointsStr}}`;
+      const { lastCommandIdx } = message.val;
+      return `ToServerAckCommands{lastCommandIdx: ${stringifyBigInt(lastCommandIdx)}}`;
     }
     case "ToServerStopping":
       return "ToServerStopping";
-    case "ToServerPong": {
+    case "ToServerPing": {
       const { ts } = message.val;
-      return `ToServerPong{ts: ${stringifyBigInt(ts)}}`;
+      return `ToServerPing{ts: ${stringifyBigInt(ts)}}`;
     }
     case "ToServerKvRequest": {
       const { actorId, requestId, data } = message.val;
@@ -413,21 +390,19 @@ function stringifyToServer(message) {
 function stringifyToClient(message) {
   switch (message.tag) {
     case "ToClientInit": {
-      const { runnerId, metadata } = message.val;
+      const { runnerId, lastEventIdx, metadata } = message.val;
       const metadataStr = `{runnerLostThreshold: ${stringifyBigInt(metadata.runnerLostThreshold)}}`;
-      return `ToClientInit{runnerId: "${runnerId}", metadata: ${metadataStr}}`;
+      return `ToClientInit{runnerId: "${runnerId}", lastEventIdx: ${stringifyBigInt(lastEventIdx)}, metadata: ${metadataStr}}`;
     }
-    case "ToClientPing":
-      const { ts } = message.val;
-      return `ToClientPing{ts: ${stringifyBigInt(ts)}}`;
+    case "ToClientClose":
+      return "ToClientClose";
     case "ToClientCommands": {
       const commands = message.val;
       return `ToClientCommands{count: ${commands.length}, commands: [${commands.map((c) => stringifyCommandWrapper(c)).join(", ")}]}`;
     }
     case "ToClientAckEvents": {
-      const { lastEventCheckpoints } = message.val;
-      const checkpointsStr = lastEventCheckpoints.length > 0 ? `[${lastEventCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]` : "[]";
-      return `ToClientAckEvents{lastEventCheckpoints: ${checkpointsStr}}`;
+      const { lastEventIdx } = message.val;
+      return `ToClientAckEvents{lastEventIdx: ${stringifyBigInt(lastEventIdx)}}`;
     }
     case "ToClientKvResponse": {
       const { requestId, data } = message.val;
@@ -918,6 +893,11 @@ var WebSocketTunnelAdapter = class {
 };
 
 // src/tunnel.ts
+var RunnerShutdownError = class extends Error {
+  constructor() {
+    super("Runner shut down");
+  }
+};
 var Tunnel = class {
   #runner;
   /** Maps request IDs to actor IDs for lookup */
@@ -1039,7 +1019,7 @@ var Tunnel = class {
           (_a2 = this.log) == null ? void 0 : _a2.error({
             msg: "error creating websocket during restore",
             requestId: requestIdStr,
-            error: stringifyError(err)
+            err
           });
           this.#sendMessage(gatewayId, requestId, {
             tag: "ToServerWebSocketClose",
@@ -1088,7 +1068,7 @@ var Tunnel = class {
           (_a2 = this.log) == null ? void 0 : _a2.error({
             msg: "error creating stale websocket during restore",
             requestId: requestIdStr,
-            error: stringifyError(err)
+            err
           });
         });
         backgroundOperations.push(cleanupOperation);
@@ -1368,6 +1348,8 @@ var Tunnel = class {
           message.messageKind.val
         );
         break;
+      case "DeprecatedTunnelAck":
+        break;
       default:
         unreachable(message.messageKind);
     }
@@ -1756,14 +1738,10 @@ async function importWebSocket() {
 
 // src/mod.ts
 var KV_EXPIRE = 3e4;
-var PROTOCOL_VERSION = 4;
+var PROTOCOL_VERSION = 3;
+var RUNNER_PING_INTERVAL = 3e3;
 var EVENT_BACKLOG_WARN_THRESHOLD = 1e4;
 var SIGNAL_HANDLERS = [];
-var RunnerShutdownError = class extends Error {
-  constructor() {
-    super("Runner shut down");
-  }
-};
 var Runner = class {
   #config;
   get config() {
@@ -1773,6 +1751,9 @@ var Runner = class {
   // WebSocket
   __pegboardWebSocket;
   runnerId;
+  #lastCommandIdx = -1;
+  #pingLoop;
+  #nextEventIdx = 0n;
   #started = false;
   #shutdown = false;
   #shuttingDown = false;
@@ -1782,6 +1763,7 @@ var Runner = class {
   #runnerLostThreshold;
   #runnerLostTimeout;
   // Event storage for resending
+  #eventHistory = [];
   #eventBacklogWarned = false;
   // Command acknowledgment
   #ackInterval;
@@ -1812,15 +1794,7 @@ var Runner = class {
     this.#config = config;
     if (this.#config.logger) setLogger(this.#config.logger);
     this.#kvCleanupInterval = setInterval(() => {
-      var _a;
-      try {
-        this.#cleanupOldKvRequests();
-      } catch (err) {
-        (_a = this.log) == null ? void 0 : _a.error({
-          msg: "error cleaning up kv requests",
-          error: stringifyError(err)
-        });
-      }
+      this.#cleanupOldKvRequests();
     }, 15e3);
   }
   // MARK: Manage actors
@@ -1847,28 +1821,14 @@ var Runner = class {
     this.#removeActor(actorId, generation);
     this.#sendActorStateUpdate(actorId, actor.generation, "stopped");
   }
-  #handleLost() {
+  #stopAllActors() {
     var _a;
     (_a = this.log) == null ? void 0 : _a.info({
-      msg: "stopping all actors due to runner lost threshold"
+      msg: "stopping all actors due to runner lost threshold exceeded"
     });
-    for (const [_, request] of this.#kvRequests.entries()) {
-      request.reject(new RunnerShutdownError());
-    }
-    this.#kvRequests.clear();
-    this.#stopAllActors();
-  }
-  #stopAllActors() {
     const actorIds = Array.from(this.#actors.keys());
     for (const actorId of actorIds) {
-      this.forceStopActor(actorId).catch((err) => {
-        var _a;
-        (_a = this.log) == null ? void 0 : _a.error({
-          msg: "error stopping actor",
-          actorId,
-          error: stringifyError(err)
-        });
-      });
+      this.forceStopActor(actorId);
     }
   }
   getActor(actorId, generation) {
@@ -1996,6 +1956,10 @@ var Runner = class {
       clearTimeout(this.#runnerLostTimeout);
       this.#runnerLostTimeout = void 0;
     }
+    if (this.#pingLoop) {
+      clearInterval(this.#pingLoop);
+      this.#pingLoop = void 0;
+    }
     if (this.#ackInterval) {
       clearInterval(this.#ackInterval);
       this.#ackInterval = void 0;
@@ -2203,6 +2167,7 @@ var Runner = class {
         name: this.#config.runnerName,
         version: this.#config.version,
         totalSlots: this.#config.totalSlots,
+        lastCommandIdx: this.#lastCommandIdx >= 0 ? BigInt(this.#lastCommandIdx) : null,
         prepopulateActorNames: new Map(
           Object.entries(this.#config.prepopulateActorNames).map(
             ([name, data]) => [
@@ -2217,29 +2182,39 @@ var Runner = class {
         tag: "ToServerInit",
         val: init
       });
+      const pingLoop = setInterval(() => {
+        var _a3;
+        if (ws.readyState === 1) {
+          this.__sendToServer({
+            tag: "ToServerPing",
+            val: {
+              ts: BigInt(Date.now())
+            }
+          });
+        } else {
+          clearInterval(pingLoop);
+          (_a3 = this.log) == null ? void 0 : _a3.info({
+            msg: "WebSocket not open, stopping ping loop"
+          });
+        }
+      }, RUNNER_PING_INTERVAL);
+      this.#pingLoop = pingLoop;
       const ackInterval = 5 * 60 * 1e3;
       const ackLoop = setInterval(() => {
-        var _a3, _b2;
-        try {
-          if (ws.readyState === 1) {
-            this.#sendCommandAcknowledgment();
-          } else {
-            clearInterval(ackLoop);
-            (_a3 = this.log) == null ? void 0 : _a3.info({
-              msg: "WebSocket not open, stopping ack loop"
-            });
-          }
-        } catch (err) {
-          (_b2 = this.log) == null ? void 0 : _b2.error({
-            msg: "error in command acknowledgment loop",
-            error: stringifyError(err)
+        var _a3;
+        if (ws.readyState === 1) {
+          this.#sendCommandAcknowledgment();
+        } else {
+          clearInterval(ackLoop);
+          (_a3 = this.log) == null ? void 0 : _a3.info({
+            msg: "WebSocket not open, stopping ack loop"
           });
         }
       }, ackInterval);
       this.#ackInterval = ackLoop;
     });
     ws.addEventListener("message", async (ev) => {
-      var _a2, _b, _c, _d, _e;
+      var _a2, _b, _c, _d, _e, _f;
       let buf;
       if (ev.data instanceof Blob) {
         buf = new Uint8Array(await ev.data.arrayBuffer());
@@ -2257,15 +2232,16 @@ var Runner = class {
         const init = message.val;
         if (this.runnerId !== init.runnerId) {
           this.runnerId = init.runnerId;
-          this.#stopAllActors();
+          this.#eventHistory.length = 0;
         }
         this.#runnerLostThreshold = ((_b = init.metadata) == null ? void 0 : _b.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
         (_c = this.log) == null ? void 0 : _c.info({
           msg: "received init",
+          lastEventIdx: init.lastEventIdx,
           runnerLostThreshold: this.#runnerLostThreshold
         });
         this.#processUnsentKvRequests();
-        this.#resendUnacknowledgedEvents();
+        this.#resendUnacknowledgedEvents(init.lastEventIdx);
         (_d = this.#tunnel) == null ? void 0 : _d.resendBufferedEvents();
         this.#config.onConnected();
       } else if (message.tag === "ToClientCommands") {
@@ -2277,20 +2253,10 @@ var Runner = class {
         const kvResponse = message.val;
         this.#handleKvResponse(kvResponse);
       } else if (message.tag === "ToClientTunnelMessage") {
-        (_e = this.#tunnel) == null ? void 0 : _e.handleTunnelMessage(message.val).catch((err) => {
-          var _a3;
-          (_a3 = this.log) == null ? void 0 : _a3.error({
-            msg: "error handling tunnel message",
-            error: stringifyError(err)
-          });
-        });
-      } else if (message.tag === "ToClientPing") {
-        this.__sendToServer({
-          tag: "ToServerPong",
-          val: {
-            ts: message.val.ts
-          }
-        });
+        (_e = this.#tunnel) == null ? void 0 : _e.handleTunnelMessage(message.val);
+      } else if (message.tag === "ToClientClose") {
+        (_f = this.#tunnel) == null ? void 0 : _f.shutdown();
+        ws.close(1e3, "manual closure");
       } else {
         unreachable(message);
       }
@@ -2307,15 +2273,7 @@ var Runner = class {
             seconds: this.#runnerLostThreshold / 1e3
           });
           this.#runnerLostTimeout = setTimeout(() => {
-            var _a3;
-            try {
-              this.#handleLost();
-            } catch (err) {
-              (_a3 = this.log) == null ? void 0 : _a3.error({
-                msg: "error handling runner lost",
-                error: stringifyError(err)
-              });
-            }
+            this.#stopAllActors();
           }, this.#runnerLostThreshold);
         }
         this.#scheduleReconnect();
@@ -2341,6 +2299,10 @@ var Runner = class {
         }
         this.#config.onDisconnected(ev.code, ev.reason);
       }
+      if (this.#pingLoop) {
+        clearInterval(this.#pingLoop);
+        this.#pingLoop = void 0;
+      }
       if (this.#ackInterval) {
         clearInterval(this.#ackInterval);
         this.#ackInterval = void 0;
@@ -2352,15 +2314,7 @@ var Runner = class {
             seconds: this.#runnerLostThreshold / 1e3
           });
           this.#runnerLostTimeout = setTimeout(() => {
-            var _a3;
-            try {
-              this.#handleLost();
-            } catch (err) {
-              (_a3 = this.log) == null ? void 0 : _a3.error({
-                msg: "error handling runner lost",
-                error: stringifyError(err)
-              });
-            }
+            this.#stopAllActors();
           }, this.#runnerLostThreshold);
         }
         this.#scheduleReconnect();
@@ -2375,75 +2329,43 @@ var Runner = class {
     });
     for (const commandWrapper of commands) {
       if (commandWrapper.inner.tag === "CommandStartActor") {
-        this.#handleCommandStartActor(commandWrapper).catch((err) => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.error({
-            msg: "error handling start actor command",
-            actorId: commandWrapper.checkpoint.actorId,
-            error: stringifyError(err)
-          });
-        });
+        this.#handleCommandStartActor(commandWrapper);
       } else if (commandWrapper.inner.tag === "CommandStopActor") {
-        this.#handleCommandStopActor(commandWrapper).catch((err) => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.error({
-            msg: "error handling stop actor command",
-            actorId: commandWrapper.checkpoint.actorId,
-            error: stringifyError(err)
-          });
-        });
+        this.#handleCommandStopActor(commandWrapper);
       } else {
         unreachable(commandWrapper.inner);
       }
-      const actor = this.getActor(
-        commandWrapper.checkpoint.actorId,
-        commandWrapper.inner.val.generation
-      );
-      if (actor) actor.lastCommandIdx = commandWrapper.checkpoint.index;
+      this.#lastCommandIdx = Number(commandWrapper.index);
     }
   }
   #handleAckEvents(ack) {
     var _a;
-    let originalTotalEvents = Array.from(this.#actors).reduce(
-      (s, [_, actor]) => s + actor.eventHistory.length,
-      0
-    );
-    for (const [_, actor] of this.#actors) {
-      let checkpoint = ack.lastEventCheckpoints.find(
-        (x) => x.actorId == actor.actorId
-      );
-      if (checkpoint) actor.handleAckEvents(checkpoint.index);
-    }
-    const totalEvents = Array.from(this.#actors).reduce(
-      (s, [_, actor]) => s + actor.eventHistory.length,
-      0
+    const lastAckedIdx = ack.lastEventIdx;
+    const originalLength = this.#eventHistory.length;
+    this.#eventHistory = this.#eventHistory.filter(
+      (event) => event.index > lastAckedIdx
     );
-    const prunedCount = originalTotalEvents - totalEvents;
+    const prunedCount = originalLength - this.#eventHistory.length;
     if (prunedCount > 0) {
       (_a = this.log) == null ? void 0 : _a.info({
         msg: "pruned acknowledged events",
+        lastAckedIdx: lastAckedIdx.toString(),
         prunedCount
       });
     }
-    if (totalEvents <= EVENT_BACKLOG_WARN_THRESHOLD) {
+    if (this.#eventHistory.length <= EVENT_BACKLOG_WARN_THRESHOLD) {
       this.#eventBacklogWarned = false;
     }
   }
   /** Track events to send to the server in case we need to resend it on disconnect. */
   #recordEvent(eventWrapper) {
     var _a;
-    const actor = this.getActor(eventWrapper.checkpoint.actorId);
-    if (!actor) return;
-    actor.recordEvent(eventWrapper);
-    let totalEvents = Array.from(this.#actors).reduce(
-      (s, [_, actor2]) => s + actor2.eventHistory.length,
-      0
-    );
-    if (totalEvents > EVENT_BACKLOG_WARN_THRESHOLD && !this.#eventBacklogWarned) {
+    this.#eventHistory.push(eventWrapper);
+    if (this.#eventHistory.length > EVENT_BACKLOG_WARN_THRESHOLD && !this.#eventBacklogWarned) {
       this.#eventBacklogWarned = true;
       (_a = this.log) == null ? void 0 : _a.warn({
         msg: "unacknowledged event backlog exceeds threshold",
-        backlogSize: totalEvents,
+        backlogSize: this.#eventHistory.length,
         threshold: EVENT_BACKLOG_WARN_THRESHOLD
       });
     }
@@ -2452,7 +2374,7 @@ var Runner = class {
     var _a, _b, _c, _d;
     if (!this.#tunnel) throw new Error("missing tunnel on actor start");
     const startCommand = commandWrapper.inner.val;
-    const actorId = commandWrapper.checkpoint.actorId;
+    const actorId = startCommand.actorId;
     const generation = startCommand.generation;
     const config = startCommand.config;
     const actorConfig = {
@@ -2511,13 +2433,11 @@ var Runner = class {
   }
   async #handleCommandStopActor(commandWrapper) {
     const stopCommand = commandWrapper.inner.val;
-    const actorId = commandWrapper.checkpoint.actorId;
+    const actorId = stopCommand.actorId;
     const generation = stopCommand.generation;
     await this.forceStopActor(actorId, generation);
   }
   #sendActorIntent(actorId, generation, intentType) {
-    const actor = this.getActor(actorId, generation);
-    if (!actor) return;
     let actorIntent;
     if (intentType === "sleep") {
       actorIntent = { tag: "ActorIntentSleep", val: null };
@@ -2534,11 +2454,9 @@ var Runner = class {
       generation,
       intent: actorIntent
     };
+    const eventIndex = this.#nextEventIdx++;
     const eventWrapper = {
-      checkpoint: {
-        actorId,
-        index: actor.nextEventIdx++
-      },
+      index: eventIndex,
       inner: {
         tag: "EventActorIntent",
         val: intentEvent
@@ -2551,8 +2469,6 @@ var Runner = class {
     });
   }
   #sendActorStateUpdate(actorId, generation, stateType) {
-    const actor = this.getActor(actorId, generation);
-    if (!actor) return;
     let actorState;
     if (stateType === "running") {
       actorState = { tag: "ActorStateRunning", val: null };
@@ -2572,11 +2488,9 @@ var Runner = class {
       generation,
       state: actorState
     };
+    const eventIndex = this.#nextEventIdx++;
     const eventWrapper = {
-      checkpoint: {
-        actorId,
-        index: actor.nextEventIdx++
-      },
+      index: eventIndex,
       inner: {
         tag: "EventActorStateUpdate",
         val: stateUpdateEvent
@@ -2589,20 +2503,13 @@ var Runner = class {
     });
   }
   #sendCommandAcknowledgment() {
-    const lastCommandCheckpoints = [];
-    for (const [_, actor] of this.#actors) {
-      if (actor.lastCommandIdx < 0) {
-        continue;
-      }
-      lastCommandCheckpoints.push({
-        actorId: actor.actorId,
-        index: actor.lastCommandIdx
-      });
+    if (this.#lastCommandIdx < 0) {
+      return;
     }
     this.__sendToServer({
       tag: "ToServerAckCommands",
       val: {
-        lastCommandCheckpoints
+        lastCommandIdx: BigInt(this.#lastCommandIdx)
       }
     });
   }
@@ -2836,11 +2743,9 @@ var Runner = class {
       generation: actor.generation,
       alarmTs: alarmTs !== null ? BigInt(alarmTs) : null
     };
+    const eventIndex = this.#nextEventIdx++;
     const eventWrapper = {
-      checkpoint: {
-        actorId,
-        index: actor.nextEventIdx++
-      },
+      index: eventIndex,
       inner: {
         tag: "EventActorSetAlarm",
         val: alarmEvent
@@ -2967,8 +2872,7 @@ var Runner = class {
     const data = protocol.encodeToServerlessServer({
       tag: "ToServerlessServerInit",
       val: {
-        runnerId: this.runnerId,
-        runnerProtocolVersion: PROTOCOL_VERSION
+        runnerId: this.runnerId
       }
     });
     const buffer = Buffer.alloc(data.length + 2);
@@ -2993,33 +2897,26 @@ var Runner = class {
     (_b = this.log) == null ? void 0 : _b.debug({
       msg: `Scheduling reconnect attempt ${this.#reconnectAttempt + 1} in ${delay}ms`
     });
-    this.#reconnectTimeout = setTimeout(() => {
+    this.#reconnectTimeout = setTimeout(async () => {
       var _a2;
       if (!this.#shutdown) {
         this.#reconnectAttempt++;
         (_a2 = this.log) == null ? void 0 : _a2.debug({
           msg: `Attempting to reconnect (attempt ${this.#reconnectAttempt})...`
         });
-        this.#openPegboardWebSocket().catch((err) => {
-          var _a3;
-          (_a3 = this.log) == null ? void 0 : _a3.error({
-            msg: "error during websocket reconnection",
-            error: stringifyError(err)
-          });
-        });
+        await this.#openPegboardWebSocket();
       }
     }, delay);
   }
-  #resendUnacknowledgedEvents() {
+  #resendUnacknowledgedEvents(lastEventIdx) {
     var _a;
-    const eventsToResend = [];
-    for (const [_, actor] of this.#actors) {
-      eventsToResend.push(...actor.eventHistory);
-    }
+    const eventsToResend = this.#eventHistory.filter(
+      (event) => event.index > lastEventIdx
+    );
     if (eventsToResend.length === 0) return;
     (_a = this.log) == null ? void 0 : _a.info({
       msg: "resending unacknowledged events",
-      count: eventsToResend.length
+      fromIndex: lastEventIdx + 1n
     });
     this.__sendToServer({
       tag: "ToServerEvents",
@@ -3049,7 +2946,6 @@ var Runner = class {
 export {
   Runner,
   RunnerActor,
-  RunnerShutdownError,
   idToStr
 };
 //# sourceMappingURL=mod.js.map