@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/sdks/typescript/runner-protocol/src/index.ts

@@ -1,5 +1,6 @@
-import assert from "node:assert"
-import * as bare from "@bare-ts/lib"
+// @generated - post-processed by build.rs
+
+import * as bare from "@rivetkit/bare-ts"
 
 const DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({})
 
@@ -85,22 +86,19 @@ export function writeKvValue(bc: bare.ByteCursor, x: KvValue): void {
 
 export type KvMetadata = {
     readonly version: ArrayBuffer
-    /**
-     * TODO: Rename to update_ts
-     */
-    readonly createTs: i64
+    readonly updateTs: i64
 }
 
 export function readKvMetadata(bc: bare.ByteCursor): KvMetadata {
     return {
         version: bare.readData(bc),
-        createTs: bare.readI64(bc),
+        updateTs: bare.readI64(bc),
     }
 }
 
 export function writeKvMetadata(bc: bare.ByteCursor, x: KvMetadata): void {
     bare.writeData(bc, x.version)
-    bare.writeI64(bc, x.createTs)
+    bare.writeI64(bc, x.updateTs)
 }
 
 /**
@@ -311,6 +309,23 @@ export function writeKvDeleteRequest(bc: bare.ByteCursor, x: KvDeleteRequest): v
     write0(bc, x.keys)
 }
 
+export type KvDeleteRangeRequest = {
+    readonly start: KvKey
+    readonly end: KvKey
+}
+
+export function readKvDeleteRangeRequest(bc: bare.ByteCursor): KvDeleteRangeRequest {
+    return {
+        start: readKvKey(bc),
+        end: readKvKey(bc),
+    }
+}
+
+export function writeKvDeleteRangeRequest(bc: bare.ByteCursor, x: KvDeleteRangeRequest): void {
+    writeKvKey(bc, x.start)
+    writeKvKey(bc, x.end)
+}
+
 export type KvDropRequest = null
 
 /**
@@ -403,6 +418,7 @@ export type KvRequestData =
     | { readonly tag: "KvListRequest"; readonly val: KvListRequest }
     | { readonly tag: "KvPutRequest"; readonly val: KvPutRequest }
     | { readonly tag: "KvDeleteRequest"; readonly val: KvDeleteRequest }
+    | { readonly tag: "KvDeleteRangeRequest"; readonly val: KvDeleteRangeRequest }
     | { readonly tag: "KvDropRequest"; readonly val: KvDropRequest }
 
 export function readKvRequestData(bc: bare.ByteCursor): KvRequestData {
@@ -418,6 +434,8 @@ export function readKvRequestData(bc: bare.ByteCursor): KvRequestData {
         case 3:
             return { tag: "KvDeleteRequest", val: readKvDeleteRequest(bc) }
         case 4:
+            return { tag: "KvDeleteRangeRequest", val: readKvDeleteRangeRequest(bc) }
+        case 5:
             return { tag: "KvDropRequest", val: null }
         default: {
             bc.offset = offset
@@ -448,8 +466,13 @@ export function writeKvRequestData(bc: bare.ByteCursor, x: KvRequestData): void
             writeKvDeleteRequest(bc, x.val)
             break
         }
-        case "KvDropRequest": {
+        case "KvDeleteRangeRequest": {
             bare.writeU8(bc, 4)
+            writeKvDeleteRangeRequest(bc, x.val)
+            break
+        }
+        case "KvDropRequest": {
+            bare.writeU8(bc, 5)
             break
         }
     }
@@ -613,6 +636,26 @@ export function writeActorConfig(bc: bare.ByteCursor, x: ActorConfig): void {
     write6(bc, x.input)
 }
 
+export type ActorCheckpoint = {
+    readonly actorId: Id
+    readonly generation: u32
+    readonly index: i64
+}
+
+export function readActorCheckpoint(bc: bare.ByteCursor): ActorCheckpoint {
+    return {
+        actorId: readId(bc),
+        generation: bare.readU32(bc),
+        index: bare.readI64(bc),
+    }
+}
+
+export function writeActorCheckpoint(bc: bare.ByteCursor, x: ActorCheckpoint): void {
+    writeId(bc, x.actorId)
+    bare.writeU32(bc, x.generation)
+    bare.writeI64(bc, x.index)
+}
+
 /**
  * Intent
  */
@@ -711,42 +754,30 @@ export function writeActorState(bc: bare.ByteCursor, x: ActorState): void {
  * MARK: Events
  */
 export type EventActorIntent = {
-    readonly actorId: Id
-    readonly generation: u32
     readonly intent: ActorIntent
 }
 
 export function readEventActorIntent(bc: bare.ByteCursor): EventActorIntent {
     return {
-        actorId: readId(bc),
-        generation: bare.readU32(bc),
         intent: readActorIntent(bc),
     }
 }
 
 export function writeEventActorIntent(bc: bare.ByteCursor, x: EventActorIntent): void {
-    writeId(bc, x.actorId)
-    bare.writeU32(bc, x.generation)
     writeActorIntent(bc, x.intent)
 }
 
 export type EventActorStateUpdate = {
-    readonly actorId: Id
-    readonly generation: u32
     readonly state: ActorState
 }
 
 export function readEventActorStateUpdate(bc: bare.ByteCursor): EventActorStateUpdate {
     return {
-        actorId: readId(bc),
-        generation: bare.readU32(bc),
         state: readActorState(bc),
     }
 }
 
 export function writeEventActorStateUpdate(bc: bare.ByteCursor, x: EventActorStateUpdate): void {
-    writeId(bc, x.actorId)
-    bare.writeU32(bc, x.generation)
     writeActorState(bc, x.state)
 }
 
@@ -762,22 +793,16 @@ function write7(bc: bare.ByteCursor, x: i64 | null): void {
 }
 
 export type EventActorSetAlarm = {
-    readonly actorId: Id
-    readonly generation: u32
     readonly alarmTs: i64 | null
 }
 
 export function readEventActorSetAlarm(bc: bare.ByteCursor): EventActorSetAlarm {
     return {
-        actorId: readId(bc),
-        generation: bare.readU32(bc),
         alarmTs: read7(bc),
     }
 }
 
 export function writeEventActorSetAlarm(bc: bare.ByteCursor, x: EventActorSetAlarm): void {
-    writeId(bc, x.actorId)
-    bare.writeU32(bc, x.generation)
     write7(bc, x.alarmTs)
 }
 
@@ -824,19 +849,19 @@ export function writeEvent(bc: bare.ByteCursor, x: Event): void {
 }
 
 export type EventWrapper = {
-    readonly index: i64
+    readonly checkpoint: ActorCheckpoint
     readonly inner: Event
 }
 
 export function readEventWrapper(bc: bare.ByteCursor): EventWrapper {
     return {
-        index: bare.readI64(bc),
+        checkpoint: readActorCheckpoint(bc),
         inner: readEvent(bc),
     }
 }
 
 export function writeEventWrapper(bc: bare.ByteCursor, x: EventWrapper): void {
-    bare.writeI64(bc, x.index)
+    writeActorCheckpoint(bc, x.checkpoint)
     writeEvent(bc, x.inner)
 }
 
@@ -877,44 +902,23 @@ function write8(bc: bare.ByteCursor, x: readonly HibernatingRequest[]): void {
 }
 
 export type CommandStartActor = {
-    readonly actorId: Id
-    readonly generation: u32
     readonly config: ActorConfig
     readonly hibernatingRequests: readonly HibernatingRequest[]
 }
 
 export function readCommandStartActor(bc: bare.ByteCursor): CommandStartActor {
     return {
-        actorId: readId(bc),
-        generation: bare.readU32(bc),
         config: readActorConfig(bc),
         hibernatingRequests: read8(bc),
     }
 }
 
 export function writeCommandStartActor(bc: bare.ByteCursor, x: CommandStartActor): void {
-    writeId(bc, x.actorId)
-    bare.writeU32(bc, x.generation)
     writeActorConfig(bc, x.config)
     write8(bc, x.hibernatingRequests)
 }
 
-export type CommandStopActor = {
-    readonly actorId: Id
-    readonly generation: u32
-}
-
-export function readCommandStopActor(bc: bare.ByteCursor): CommandStopActor {
-    return {
-        actorId: readId(bc),
-        generation: bare.readU32(bc),
-    }
-}
-
-export function writeCommandStopActor(bc: bare.ByteCursor, x: CommandStopActor): void {
-    writeId(bc, x.actorId)
-    bare.writeU32(bc, x.generation)
-}
+export type CommandStopActor = null
 
 export type Command =
     | { readonly tag: "CommandStartActor"; readonly val: CommandStartActor }
@@ -927,7 +931,7 @@ export function readCommand(bc: bare.ByteCursor): Command {
         case 0:
             return { tag: "CommandStartActor", val: readCommandStartActor(bc) }
         case 1:
-            return { tag: "CommandStopActor", val: readCommandStopActor(bc) }
+            return { tag: "CommandStopActor", val: null }
         default: {
             bc.offset = offset
             throw new bare.BareError(offset, "invalid tag")
@@ -944,29 +948,83 @@ export function writeCommand(bc: bare.ByteCursor, x: Command): void {
         }
         case "CommandStopActor": {
             bare.writeU8(bc, 1)
-            writeCommandStopActor(bc, x.val)
             break
         }
     }
 }
 
 export type CommandWrapper = {
-    readonly index: i64
+    readonly checkpoint: ActorCheckpoint
     readonly inner: Command
 }
 
 export function readCommandWrapper(bc: bare.ByteCursor): CommandWrapper {
     return {
-        index: bare.readI64(bc),
+        checkpoint: readActorCheckpoint(bc),
         inner: readCommand(bc),
     }
 }
 
 export function writeCommandWrapper(bc: bare.ByteCursor, x: CommandWrapper): void {
-    bare.writeI64(bc, x.index)
+    writeActorCheckpoint(bc, x.checkpoint)
     writeCommand(bc, x.inner)
 }
 
+/**
+ * We redeclare this so its top level
+ */
+export type ActorCommandKeyData =
+    | { readonly tag: "CommandStartActor"; readonly val: CommandStartActor }
+    | { readonly tag: "CommandStopActor"; readonly val: CommandStopActor }
+
+export function readActorCommandKeyData(bc: bare.ByteCursor): ActorCommandKeyData {
+    const offset = bc.offset
+    const tag = bare.readU8(bc)
+    switch (tag) {
+        case 0:
+            return { tag: "CommandStartActor", val: readCommandStartActor(bc) }
+        case 1:
+            return { tag: "CommandStopActor", val: null }
+        default: {
+            bc.offset = offset
+            throw new bare.BareError(offset, "invalid tag")
+        }
+    }
+}
+
+export function writeActorCommandKeyData(bc: bare.ByteCursor, x: ActorCommandKeyData): void {
+    switch (x.tag) {
+        case "CommandStartActor": {
+            bare.writeU8(bc, 0)
+            writeCommandStartActor(bc, x.val)
+            break
+        }
+        case "CommandStopActor": {
+            bare.writeU8(bc, 1)
+            break
+        }
+    }
+}
+
+export function encodeActorCommandKeyData(x: ActorCommandKeyData, config?: Partial<bare.Config>): Uint8Array {
+    const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG
+    const bc = new bare.ByteCursor(
+        new Uint8Array(fullConfig.initialBufferLength),
+        fullConfig,
+    )
+    writeActorCommandKeyData(bc, x)
+    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)
+}
+
+export function decodeActorCommandKeyData(bytes: Uint8Array): ActorCommandKeyData {
+    const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG)
+    const result = readActorCommandKeyData(bc)
+    if (bc.offset < bc.view.byteLength) {
+        throw new bare.BareError(bc.offset, "remaining bytes")
+    }
+    return result
+}
+
 export type MessageId = {
     /**
      * Globally unique ID
@@ -996,8 +1054,6 @@ export function writeMessageId(bc: bare.ByteCursor, x: MessageId): void {
     writeMessageIndex(bc, x.messageIndex)
 }
 
-export type DeprecatedTunnelAck = null
-
 function read9(bc: bare.ByteCursor): ReadonlyMap<string, string> {
     const len = bare.readUintSafe(bc)
     const result = new Map<string, string>()
@@ -1251,7 +1307,6 @@ export function writeToServerWebSocketClose(bc: bare.ByteCursor, x: ToServerWebS
  * To Server
  */
 export type ToServerTunnelMessageKind =
-    | { readonly tag: "DeprecatedTunnelAck"; readonly val: DeprecatedTunnelAck }
     /**
      * HTTP
      */
@@ -1271,20 +1326,18 @@ export function readToServerTunnelMessageKind(bc: bare.ByteCursor): ToServerTunn
     const tag = bare.readU8(bc)
     switch (tag) {
         case 0:
-            return { tag: "DeprecatedTunnelAck", val: null }
-        case 1:
             return { tag: "ToServerResponseStart", val: readToServerResponseStart(bc) }
-        case 2:
+        case 1:
             return { tag: "ToServerResponseChunk", val: readToServerResponseChunk(bc) }
-        case 3:
+        case 2:
             return { tag: "ToServerResponseAbort", val: null }
-        case 4:
+        case 3:
             return { tag: "ToServerWebSocketOpen", val: readToServerWebSocketOpen(bc) }
-        case 5:
+        case 4:
             return { tag: "ToServerWebSocketMessage", val: readToServerWebSocketMessage(bc) }
-        case 6:
+        case 5:
             return { tag: "ToServerWebSocketMessageAck", val: readToServerWebSocketMessageAck(bc) }
-        case 7:
+        case 6:
             return { tag: "ToServerWebSocketClose", val: readToServerWebSocketClose(bc) }
         default: {
             bc.offset = offset
@@ -1295,41 +1348,37 @@ export function readToServerTunnelMessageKind(bc: bare.ByteCursor): ToServerTunn
 
 export function writeToServerTunnelMessageKind(bc: bare.ByteCursor, x: ToServerTunnelMessageKind): void {
     switch (x.tag) {
-        case "DeprecatedTunnelAck": {
-            bare.writeU8(bc, 0)
-            break
-        }
         case "ToServerResponseStart": {
-            bare.writeU8(bc, 1)
+            bare.writeU8(bc, 0)
             writeToServerResponseStart(bc, x.val)
             break
         }
         case "ToServerResponseChunk": {
-            bare.writeU8(bc, 2)
+            bare.writeU8(bc, 1)
             writeToServerResponseChunk(bc, x.val)
             break
         }
         case "ToServerResponseAbort": {
-            bare.writeU8(bc, 3)
+            bare.writeU8(bc, 2)
             break
         }
         case "ToServerWebSocketOpen": {
-            bare.writeU8(bc, 4)
+            bare.writeU8(bc, 3)
             writeToServerWebSocketOpen(bc, x.val)
             break
         }
         case "ToServerWebSocketMessage": {
-            bare.writeU8(bc, 5)
+            bare.writeU8(bc, 4)
             writeToServerWebSocketMessage(bc, x.val)
             break
         }
         case "ToServerWebSocketMessageAck": {
-            bare.writeU8(bc, 6)
+            bare.writeU8(bc, 5)
             writeToServerWebSocketMessageAck(bc, x.val)
             break
         }
         case "ToServerWebSocketClose": {
-            bare.writeU8(bc, 7)
+            bare.writeU8(bc, 6)
             writeToServerWebSocketClose(bc, x.val)
             break
         }
@@ -1357,7 +1406,6 @@ export function writeToServerTunnelMessage(bc: bare.ByteCursor, x: ToServerTunne
  * To Client
  */
 export type ToClientTunnelMessageKind =
-    | { readonly tag: "DeprecatedTunnelAck"; readonly val: DeprecatedTunnelAck }
     /**
      * HTTP
      */
@@ -1376,18 +1424,16 @@ export function readToClientTunnelMessageKind(bc: bare.ByteCursor): ToClientTunn
     const tag = bare.readU8(bc)
     switch (tag) {
         case 0:
-            return { tag: "DeprecatedTunnelAck", val: null }
-        case 1:
             return { tag: "ToClientRequestStart", val: readToClientRequestStart(bc) }
-        case 2:
+        case 1:
             return { tag: "ToClientRequestChunk", val: readToClientRequestChunk(bc) }
-        case 3:
+        case 2:
             return { tag: "ToClientRequestAbort", val: null }
-        case 4:
+        case 3:
             return { tag: "ToClientWebSocketOpen", val: readToClientWebSocketOpen(bc) }
-        case 5:
+        case 4:
             return { tag: "ToClientWebSocketMessage", val: readToClientWebSocketMessage(bc) }
-        case 6:
+        case 5:
             return { tag: "ToClientWebSocketClose", val: readToClientWebSocketClose(bc) }
         default: {
             bc.offset = offset
@@ -1398,36 +1444,32 @@ export function readToClientTunnelMessageKind(bc: bare.ByteCursor): ToClientTunn
 
 export function writeToClientTunnelMessageKind(bc: bare.ByteCursor, x: ToClientTunnelMessageKind): void {
     switch (x.tag) {
-        case "DeprecatedTunnelAck": {
-            bare.writeU8(bc, 0)
-            break
-        }
         case "ToClientRequestStart": {
-            bare.writeU8(bc, 1)
+            bare.writeU8(bc, 0)
             writeToClientRequestStart(bc, x.val)
             break
         }
         case "ToClientRequestChunk": {
-            bare.writeU8(bc, 2)
+            bare.writeU8(bc, 1)
             writeToClientRequestChunk(bc, x.val)
             break
         }
         case "ToClientRequestAbort": {
-            bare.writeU8(bc, 3)
+            bare.writeU8(bc, 2)
             break
         }
         case "ToClientWebSocketOpen": {
-            bare.writeU8(bc, 4)
+            bare.writeU8(bc, 3)
             writeToClientWebSocketOpen(bc, x.val)
             break
         }
         case "ToClientWebSocketMessage": {
-            bare.writeU8(bc, 5)
+            bare.writeU8(bc, 4)
             writeToClientWebSocketMessage(bc, x.val)
             break
         }
         case "ToClientWebSocketClose": {
-            bare.writeU8(bc, 6)
+            bare.writeU8(bc, 5)
             writeToClientWebSocketClose(bc, x.val)
             break
         }
@@ -1451,6 +1493,20 @@ export function writeToClientTunnelMessage(bc: bare.ByteCursor, x: ToClientTunne
     writeToClientTunnelMessageKind(bc, x.messageKind)
 }
 
+export type ToClientPing = {
+    readonly ts: i64
+}
+
+export function readToClientPing(bc: bare.ByteCursor): ToClientPing {
+    return {
+        ts: bare.readI64(bc),
+    }
+}
+
+export function writeToClientPing(bc: bare.ByteCursor, x: ToClientPing): void {
+    bare.writeI64(bc, x.ts)
+}
+
 function read11(bc: bare.ByteCursor): ReadonlyMap<string, ActorName> {
     const len = bare.readUintSafe(bc)
     const result = new Map<string, ActorName>()
@@ -1503,7 +1559,6 @@ export type ToServerInit = {
     readonly name: string
     readonly version: u32
     readonly totalSlots: u32
-    readonly lastCommandIdx: i64 | null
     readonly prepopulateActorNames: ReadonlyMap<string, ActorName> | null
     readonly metadata: Json | null
 }
@@ -1513,7 +1568,6 @@ export function readToServerInit(bc: bare.ByteCursor): ToServerInit {
         name: bare.readString(bc),
         version: bare.readU32(bc),
         totalSlots: bare.readU32(bc),
-        lastCommandIdx: read7(bc),
         prepopulateActorNames: read12(bc),
         metadata: read13(bc),
     }
@@ -1523,7 +1577,6 @@ export function writeToServerInit(bc: bare.ByteCursor, x: ToServerInit): void {
     bare.writeString(bc, x.name)
     bare.writeU32(bc, x.version)
     bare.writeU32(bc, x.totalSlots)
-    write7(bc, x.lastCommandIdx)
     write12(bc, x.prepopulateActorNames)
     write13(bc, x.metadata)
 }
@@ -1549,33 +1602,52 @@ export function writeToServerEvents(bc: bare.ByteCursor, x: ToServerEvents): voi
     }
 }
 
+function read14(bc: bare.ByteCursor): readonly ActorCheckpoint[] {
+    const len = bare.readUintSafe(bc)
+    if (len === 0) {
+        return []
+    }
+    const result = [readActorCheckpoint(bc)]
+    for (let i = 1; i < len; i++) {
+        result[i] = readActorCheckpoint(bc)
+    }
+    return result
+}
+
+function write14(bc: bare.ByteCursor, x: readonly ActorCheckpoint[]): void {
+    bare.writeUintSafe(bc, x.length)
+    for (let i = 0; i < x.length; i++) {
+        writeActorCheckpoint(bc, x[i])
+    }
+}
+
 export type ToServerAckCommands = {
-    readonly lastCommandIdx: i64
+    readonly lastCommandCheckpoints: readonly ActorCheckpoint[]
 }
 
 export function readToServerAckCommands(bc: bare.ByteCursor): ToServerAckCommands {
     return {
-        lastCommandIdx: bare.readI64(bc),
+        lastCommandCheckpoints: read14(bc),
     }
 }
 
 export function writeToServerAckCommands(bc: bare.ByteCursor, x: ToServerAckCommands): void {
-    bare.writeI64(bc, x.lastCommandIdx)
+    write14(bc, x.lastCommandCheckpoints)
 }
 
 export type ToServerStopping = null
 
-export type ToServerPing = {
+export type ToServerPong = {
     readonly ts: i64
 }
 
-export function readToServerPing(bc: bare.ByteCursor): ToServerPing {
+export function readToServerPong(bc: bare.ByteCursor): ToServerPong {
     return {
         ts: bare.readI64(bc),
     }
 }
 
-export function writeToServerPing(bc: bare.ByteCursor, x: ToServerPing): void {
+export function writeToServerPong(bc: bare.ByteCursor, x: ToServerPong): void {
     bare.writeI64(bc, x.ts)
 }
 
@@ -1604,7 +1676,7 @@ export type ToServer =
     | { readonly tag: "ToServerEvents"; readonly val: ToServerEvents }
     | { readonly tag: "ToServerAckCommands"; readonly val: ToServerAckCommands }
     | { readonly tag: "ToServerStopping"; readonly val: ToServerStopping }
-    | { readonly tag: "ToServerPing"; readonly val: ToServerPing }
+    | { readonly tag: "ToServerPong"; readonly val: ToServerPong }
     | { readonly tag: "ToServerKvRequest"; readonly val: ToServerKvRequest }
     | { readonly tag: "ToServerTunnelMessage"; readonly val: ToServerTunnelMessage }
 
@@ -1621,7 +1693,7 @@ export function readToServer(bc: bare.ByteCursor): ToServer {
         case 3:
             return { tag: "ToServerStopping", val: null }
         case 4:
-            return { tag: "ToServerPing", val: readToServerPing(bc) }
+            return { tag: "ToServerPong", val: readToServerPong(bc) }
         case 5:
             return { tag: "ToServerKvRequest", val: readToServerKvRequest(bc) }
         case 6:
@@ -1654,9 +1726,9 @@ export function writeToServer(bc: bare.ByteCursor, x: ToServer): void {
             bare.writeU8(bc, 3)
             break
         }
-        case "ToServerPing": {
+        case "ToServerPong": {
             bare.writeU8(bc, 4)
-            writeToServerPing(bc, x.val)
+            writeToServerPong(bc, x.val)
             break
         }
         case "ToServerKvRequest": {
@@ -1696,35 +1768,38 @@ export function decodeToServer(bytes: Uint8Array): ToServer {
  */
 export type ProtocolMetadata = {
     readonly runnerLostThreshold: i64
+    readonly actorStopThreshold: i64
+    readonly serverlessDrainGracePeriod: i64 | null
 }
 
 export function readProtocolMetadata(bc: bare.ByteCursor): ProtocolMetadata {
     return {
         runnerLostThreshold: bare.readI64(bc),
+        actorStopThreshold: bare.readI64(bc),
+        serverlessDrainGracePeriod: read7(bc),
     }
 }
 
 export function writeProtocolMetadata(bc: bare.ByteCursor, x: ProtocolMetadata): void {
     bare.writeI64(bc, x.runnerLostThreshold)
+    bare.writeI64(bc, x.actorStopThreshold)
+    write7(bc, x.serverlessDrainGracePeriod)
 }
 
 export type ToClientInit = {
     readonly runnerId: Id
-    readonly lastEventIdx: i64
     readonly metadata: ProtocolMetadata
 }
 
 export function readToClientInit(bc: bare.ByteCursor): ToClientInit {
     return {
         runnerId: readId(bc),
-        lastEventIdx: bare.readI64(bc),
         metadata: readProtocolMetadata(bc),
     }
 }
 
 export function writeToClientInit(bc: bare.ByteCursor, x: ToClientInit): void {
     writeId(bc, x.runnerId)
-    bare.writeI64(bc, x.lastEventIdx)
     writeProtocolMetadata(bc, x.metadata)
 }
 
@@ -1750,17 +1825,17 @@ export function writeToClientCommands(bc: bare.ByteCursor, x: ToClientCommands):
 }
 
 export type ToClientAckEvents = {
-    readonly lastEventIdx: i64
+    readonly lastEventCheckpoints: readonly ActorCheckpoint[]
 }
 
 export function readToClientAckEvents(bc: bare.ByteCursor): ToClientAckEvents {
     return {
-        lastEventIdx: bare.readI64(bc),
+        lastEventCheckpoints: read14(bc),
     }
 }
 
 export function writeToClientAckEvents(bc: bare.ByteCursor, x: ToClientAckEvents): void {
-    bare.writeI64(bc, x.lastEventIdx)
+    write14(bc, x.lastEventCheckpoints)
 }
 
 export type ToClientKvResponse = {
@@ -1780,15 +1855,13 @@ export function writeToClientKvResponse(bc: bare.ByteCursor, x: ToClientKvRespon
     writeKvResponseData(bc, x.data)
 }
 
-export type ToClientClose = null
-
 export type ToClient =
     | { readonly tag: "ToClientInit"; readonly val: ToClientInit }
-    | { readonly tag: "ToClientClose"; readonly val: ToClientClose }
     | { readonly tag: "ToClientCommands"; readonly val: ToClientCommands }
     | { readonly tag: "ToClientAckEvents"; readonly val: ToClientAckEvents }
     | { readonly tag: "ToClientKvResponse"; readonly val: ToClientKvResponse }
     | { readonly tag: "ToClientTunnelMessage"; readonly val: ToClientTunnelMessage }
+    | { readonly tag: "ToClientPing"; readonly val: ToClientPing }
 
 export function readToClient(bc: bare.ByteCursor): ToClient {
     const offset = bc.offset
@@ -1797,15 +1870,15 @@ export function readToClient(bc: bare.ByteCursor): ToClient {
         case 0:
             return { tag: "ToClientInit", val: readToClientInit(bc) }
         case 1:
-            return { tag: "ToClientClose", val: null }
-        case 2:
             return { tag: "ToClientCommands", val: readToClientCommands(bc) }
-        case 3:
+        case 2:
             return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) }
-        case 4:
+        case 3:
             return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) }
-        case 5:
+        case 4:
             return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) }
+        case 5:
+            return { tag: "ToClientPing", val: readToClientPing(bc) }
         default: {
             bc.offset = offset
             throw new bare.BareError(offset, "invalid tag")
@@ -1820,30 +1893,31 @@ export function writeToClient(bc: bare.ByteCursor, x: ToClient): void {
             writeToClientInit(bc, x.val)
             break
         }
-        case "ToClientClose": {
-            bare.writeU8(bc, 1)
-            break
-        }
         case "ToClientCommands": {
-            bare.writeU8(bc, 2)
+            bare.writeU8(bc, 1)
             writeToClientCommands(bc, x.val)
             break
         }
         case "ToClientAckEvents": {
-            bare.writeU8(bc, 3)
+            bare.writeU8(bc, 2)
             writeToClientAckEvents(bc, x.val)
             break
         }
         case "ToClientKvResponse": {
-            bare.writeU8(bc, 4)
+            bare.writeU8(bc, 3)
             writeToClientKvResponse(bc, x.val)
             break
         }
         case "ToClientTunnelMessage": {
-            bare.writeU8(bc, 5)
+            bare.writeU8(bc, 4)
             writeToClientTunnelMessage(bc, x.val)
             break
         }
+        case "ToClientPing": {
+            bare.writeU8(bc, 5)
+            writeToClientPing(bc, x.val)
+            break
+        }
     }
 }
 
@@ -1889,17 +1963,17 @@ export function writeToRunnerPing(bc: bare.ByteCursor, x: ToRunnerPing): void {
     bare.writeI64(bc, x.ts)
 }
 
+export type ToRunnerClose = null
+
 /**
  * We have to re-declare the entire union since BARE will not generate the
  * ser/de for ToClient if it's not a top-level type
  */
 export type ToRunner =
     | { readonly tag: "ToRunnerPing"; readonly val: ToRunnerPing }
-    | { readonly tag: "ToClientInit"; readonly val: ToClientInit }
-    | { readonly tag: "ToClientClose"; readonly val: ToClientClose }
+    | { readonly tag: "ToRunnerClose"; readonly val: ToRunnerClose }
     | { readonly tag: "ToClientCommands"; readonly val: ToClientCommands }
     | { readonly tag: "ToClientAckEvents"; readonly val: ToClientAckEvents }
-    | { readonly tag: "ToClientKvResponse"; readonly val: ToClientKvResponse }
     | { readonly tag: "ToClientTunnelMessage"; readonly val: ToClientTunnelMessage }
 
 export function readToRunner(bc: bare.ByteCursor): ToRunner {
@@ -1909,16 +1983,12 @@ export function readToRunner(bc: bare.ByteCursor): ToRunner {
         case 0:
             return { tag: "ToRunnerPing", val: readToRunnerPing(bc) }
         case 1:
-            return { tag: "ToClientInit", val: readToClientInit(bc) }
+            return { tag: "ToRunnerClose", val: null }
         case 2:
-            return { tag: "ToClientClose", val: null }
-        case 3:
             return { tag: "ToClientCommands", val: readToClientCommands(bc) }
-        case 4:
+        case 3:
             return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) }
-        case 5:
-            return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) }
-        case 6:
+        case 4:
             return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) }
         default: {
             bc.offset = offset
@@ -1934,32 +2004,22 @@ export function writeToRunner(bc: bare.ByteCursor, x: ToRunner): void {
             writeToRunnerPing(bc, x.val)
             break
         }
-        case "ToClientInit": {
+        case "ToRunnerClose": {
             bare.writeU8(bc, 1)
-            writeToClientInit(bc, x.val)
-            break
-        }
-        case "ToClientClose": {
-            bare.writeU8(bc, 2)
             break
         }
         case "ToClientCommands": {
-            bare.writeU8(bc, 3)
+            bare.writeU8(bc, 2)
             writeToClientCommands(bc, x.val)
             break
         }
         case "ToClientAckEvents": {
-            bare.writeU8(bc, 4)
+            bare.writeU8(bc, 3)
             writeToClientAckEvents(bc, x.val)
             break
         }
-        case "ToClientKvResponse": {
-            bare.writeU8(bc, 5)
-            writeToClientKvResponse(bc, x.val)
-            break
-        }
         case "ToClientTunnelMessage": {
-            bare.writeU8(bc, 6)
+            bare.writeU8(bc, 4)
             writeToClientTunnelMessage(bc, x.val)
             break
         }
@@ -2063,16 +2123,19 @@ export function decodeToGateway(bytes: Uint8Array): ToGateway {
  */
 export type ToServerlessServerInit = {
     readonly runnerId: Id
+    readonly runnerProtocolVersion: u16
 }
 
 export function readToServerlessServerInit(bc: bare.ByteCursor): ToServerlessServerInit {
     return {
         runnerId: readId(bc),
+        runnerProtocolVersion: bare.readU16(bc),
     }
 }
 
 export function writeToServerlessServerInit(bc: bare.ByteCursor, x: ToServerlessServerInit): void {
     writeId(bc, x.runnerId)
+    bare.writeU16(bc, x.runnerProtocolVersion)
 }
 
 export type ToServerlessServer =
@@ -2119,3 +2182,8 @@ export function decodeToServerlessServer(bytes: Uint8Array): ToServerlessServer
     }
     return result
 }
+
+
+function assert(condition: boolean, message?: string): asserts condition {
+    if (!condition) throw new Error(message ?? "Assertion failed")
+}