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

package/sdks/typescript/{runner-protocol → envoy-protocol}/dist/index.js

@@ -1,6 +1,5 @@
 // src/index.ts
-import assert from "assert";
-import * as bare from "@bare-ts/lib";
+import * as bare from "@rivetkit/bare-ts";
 var DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({});
 function readId(bc) {
   return bare.readString(bc);
@@ -49,12 +48,12 @@ function writeKvValue(bc, x) {
 function readKvMetadata(bc) {
   return {
     version: bare.readData(bc),
-    createTs: bare.readI64(bc)
+    updateTs: bare.readI64(bc)
   };
 }
 function writeKvMetadata(bc, x) {
   bare.writeData(bc, x.version);
-  bare.writeI64(bc, x.createTs);
+  bare.writeI64(bc, x.updateTs);
 }
 function readKvListRangeQuery(bc) {
   return {
@@ -200,6 +199,16 @@ function readKvDeleteRequest(bc) {
 function writeKvDeleteRequest(bc, x) {
   write0(bc, x.keys);
 }
+function readKvDeleteRangeRequest(bc) {
+  return {
+    start: readKvKey(bc),
+    end: readKvKey(bc)
+  };
+}
+function writeKvDeleteRangeRequest(bc, x) {
+  writeKvKey(bc, x.start);
+  writeKvKey(bc, x.end);
+}
 function readKvErrorResponse(bc) {
   return {
     message: bare.readString(bc)
@@ -262,6 +271,8 @@ function readKvRequestData(bc) {
     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;
@@ -291,8 +302,13 @@ function writeKvRequestData(bc, x) {
       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;
     }
   }
@@ -421,6 +437,18 @@ function writeActorConfig(bc, x) {
   bare.writeI64(bc, x.createTs);
   write6(bc, x.input);
 }
+function readActorCheckpoint(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    index: bare.readI64(bc)
+  };
+}
+function writeActorCheckpoint(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  bare.writeI64(bc, x.index);
+}
 function readActorIntent(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -486,26 +514,18 @@ function writeActorState(bc, x) {
 }
 function readEventActorIntent(bc) {
   return {
-    actorId: readId(bc),
-    generation: bare.readU32(bc),
     intent: readActorIntent(bc)
   };
 }
 function writeEventActorIntent(bc, x) {
-  writeId(bc, x.actorId);
-  bare.writeU32(bc, x.generation);
   writeActorIntent(bc, x.intent);
 }
 function readEventActorStateUpdate(bc) {
   return {
-    actorId: readId(bc),
-    generation: bare.readU32(bc),
     state: readActorState(bc)
   };
 }
 function writeEventActorStateUpdate(bc, x) {
-  writeId(bc, x.actorId);
-  bare.writeU32(bc, x.generation);
   writeActorState(bc, x.state);
 }
 function read7(bc) {
@@ -519,14 +539,10 @@ function write7(bc, x) {
 }
 function readEventActorSetAlarm(bc) {
   return {
-    actorId: readId(bc),
-    generation: bare.readU32(bc),
     alarmTs: read7(bc)
   };
 }
 function writeEventActorSetAlarm(bc, x) {
-  writeId(bc, x.actorId);
-  bare.writeU32(bc, x.generation);
   write7(bc, x.alarmTs);
 }
 function readEvent(bc) {
@@ -566,14 +582,55 @@ function writeEvent(bc, x) {
 }
 function readEventWrapper(bc) {
   return {
-    index: bare.readI64(bc),
+    checkpoint: readActorCheckpoint(bc),
     inner: readEvent(bc)
   };
 }
 function writeEventWrapper(bc, x) {
-  bare.writeI64(bc, x.index);
+  writeActorCheckpoint(bc, x.checkpoint);
   writeEvent(bc, x.inner);
 }
+function readPreloadedKvEntry(bc) {
+  return {
+    key: readKvKey(bc),
+    value: readKvValue(bc),
+    metadata: readKvMetadata(bc)
+  };
+}
+function writePreloadedKvEntry(bc, x) {
+  writeKvKey(bc, x.key);
+  writeKvValue(bc, x.value);
+  writeKvMetadata(bc, x.metadata);
+}
+function read8(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPreloadedKvEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPreloadedKvEntry(bc);
+  }
+  return result;
+}
+function write8(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePreloadedKvEntry(bc, x[i]);
+  }
+}
+function readPreloadedKv(bc) {
+  return {
+    entries: read8(bc),
+    requestedGetKeys: read0(bc),
+    requestedPrefixes: read0(bc)
+  };
+}
+function writePreloadedKv(bc, x) {
+  write8(bc, x.entries);
+  write0(bc, x.requestedGetKeys);
+  write0(bc, x.requestedPrefixes);
+}
 function readHibernatingRequest(bc) {
   return {
     gatewayId: readGatewayId(bc),
@@ -584,7 +641,7 @@ function writeHibernatingRequest(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
 }
-function read8(bc) {
+function read9(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -595,35 +652,92 @@ function read8(bc) {
   }
   return result;
 }
-function write8(bc, x) {
+function write9(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeHibernatingRequest(bc, x[i]);
   }
 }
+function read10(bc) {
+  return bare.readBool(bc) ? readPreloadedKv(bc) : null;
+}
+function write10(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writePreloadedKv(bc, x);
+  }
+}
 function readCommandStartActor(bc) {
   return {
-    actorId: readId(bc),
-    generation: bare.readU32(bc),
     config: readActorConfig(bc),
-    hibernatingRequests: read8(bc)
+    hibernatingRequests: read9(bc),
+    preloadedKv: read10(bc)
   };
 }
 function writeCommandStartActor(bc, x) {
-  writeId(bc, x.actorId);
-  bare.writeU32(bc, x.generation);
   writeActorConfig(bc, x.config);
-  write8(bc, x.hibernatingRequests);
+  write9(bc, x.hibernatingRequests);
+  write10(bc, x.preloadedKv);
+}
+var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
+  StopActorReason2["SleepIntent"] = "SleepIntent";
+  StopActorReason2["StopIntent"] = "StopIntent";
+  StopActorReason2["Destroy"] = "Destroy";
+  StopActorReason2["GoingAway"] = "GoingAway";
+  StopActorReason2["Lost"] = "Lost";
+  return StopActorReason2;
+})(StopActorReason || {});
+function readStopActorReason(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "SleepIntent" /* SleepIntent */;
+    case 1:
+      return "StopIntent" /* StopIntent */;
+    case 2:
+      return "Destroy" /* Destroy */;
+    case 3:
+      return "GoingAway" /* GoingAway */;
+    case 4:
+      return "Lost" /* Lost */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeStopActorReason(bc, x) {
+  switch (x) {
+    case "SleepIntent" /* SleepIntent */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "StopIntent" /* StopIntent */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "Destroy" /* Destroy */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "GoingAway" /* GoingAway */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "Lost" /* Lost */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+  }
 }
 function readCommandStopActor(bc) {
   return {
-    actorId: readId(bc),
-    generation: bare.readU32(bc)
+    reason: readStopActorReason(bc)
   };
 }
 function writeCommandStopActor(bc, x) {
-  writeId(bc, x.actorId);
-  bare.writeU32(bc, x.generation);
+  writeStopActorReason(bc, x.reason);
 }
 function readCommand(bc) {
   const offset = bc.offset;
@@ -655,14 +769,59 @@ function writeCommand(bc, x) {
 }
 function readCommandWrapper(bc) {
   return {
-    index: bare.readI64(bc),
+    checkpoint: readActorCheckpoint(bc),
     inner: readCommand(bc)
   };
 }
 function writeCommandWrapper(bc, x) {
-  bare.writeI64(bc, x.index);
+  writeActorCheckpoint(bc, x.checkpoint);
   writeCommand(bc, x.inner);
 }
+function readActorCommandKeyData(bc) {
+  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: readCommandStopActor(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeActorCommandKeyData(bc, x) {
+  switch (x.tag) {
+    case "CommandStartActor": {
+      bare.writeU8(bc, 0);
+      writeCommandStartActor(bc, x.val);
+      break;
+    }
+    case "CommandStopActor": {
+      bare.writeU8(bc, 1);
+      writeCommandStopActor(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeActorCommandKeyData(x, config) {
+  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);
+}
+function decodeActorCommandKeyData(bytes) {
+  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;
+}
 function readMessageId(bc) {
   return {
     gatewayId: readGatewayId(bc),
@@ -675,7 +834,7 @@ function writeMessageId(bc, x) {
   writeRequestId(bc, x.requestId);
   writeMessageIndex(bc, x.messageIndex);
 }
-function read9(bc) {
+function read11(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -689,294 +848,290 @@ function read9(bc) {
   }
   return result;
 }
-function write9(bc, x) {
+function write11(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
     bare.writeString(bc, kv[1]);
   }
 }
-function readToClientRequestStart(bc) {
+function readToEnvoyRequestStart(bc) {
   return {
     actorId: readId(bc),
     method: bare.readString(bc),
     path: bare.readString(bc),
-    headers: read9(bc),
+    headers: read11(bc),
     body: read6(bc),
     stream: bare.readBool(bc)
   };
 }
-function writeToClientRequestStart(bc, x) {
+function writeToEnvoyRequestStart(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.method);
   bare.writeString(bc, x.path);
-  write9(bc, x.headers);
+  write11(bc, x.headers);
   write6(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
-function readToClientRequestChunk(bc) {
+function readToEnvoyRequestChunk(bc) {
   return {
     body: bare.readData(bc),
     finish: bare.readBool(bc)
   };
 }
-function writeToClientRequestChunk(bc, x) {
+function writeToEnvoyRequestChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
 }
-function readToServerResponseStart(bc) {
+function readToRivetResponseStart(bc) {
   return {
     status: bare.readU16(bc),
-    headers: read9(bc),
+    headers: read11(bc),
     body: read6(bc),
     stream: bare.readBool(bc)
   };
 }
-function writeToServerResponseStart(bc, x) {
+function writeToRivetResponseStart(bc, x) {
   bare.writeU16(bc, x.status);
-  write9(bc, x.headers);
+  write11(bc, x.headers);
   write6(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
-function readToServerResponseChunk(bc) {
+function readToRivetResponseChunk(bc) {
   return {
     body: bare.readData(bc),
     finish: bare.readBool(bc)
   };
 }
-function writeToServerResponseChunk(bc, x) {
+function writeToRivetResponseChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
 }
-function readToClientWebSocketOpen(bc) {
+function readToEnvoyWebSocketOpen(bc) {
   return {
     actorId: readId(bc),
     path: bare.readString(bc),
-    headers: read9(bc)
+    headers: read11(bc)
   };
 }
-function writeToClientWebSocketOpen(bc, x) {
+function writeToEnvoyWebSocketOpen(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.path);
-  write9(bc, x.headers);
+  write11(bc, x.headers);
 }
-function readToClientWebSocketMessage(bc) {
+function readToEnvoyWebSocketMessage(bc) {
   return {
     data: bare.readData(bc),
     binary: bare.readBool(bc)
   };
 }
-function writeToClientWebSocketMessage(bc, x) {
+function writeToEnvoyWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function read10(bc) {
+function read12(bc) {
   return bare.readBool(bc) ? bare.readU16(bc) : null;
 }
-function write10(bc, x) {
+function write12(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeU16(bc, x);
   }
 }
-function readToClientWebSocketClose(bc) {
+function readToEnvoyWebSocketClose(bc) {
   return {
-    code: read10(bc),
+    code: read12(bc),
     reason: read5(bc)
   };
 }
-function writeToClientWebSocketClose(bc, x) {
-  write10(bc, x.code);
+function writeToEnvoyWebSocketClose(bc, x) {
+  write12(bc, x.code);
   write5(bc, x.reason);
 }
-function readToServerWebSocketOpen(bc) {
+function readToRivetWebSocketOpen(bc) {
   return {
     canHibernate: bare.readBool(bc)
   };
 }
-function writeToServerWebSocketOpen(bc, x) {
+function writeToRivetWebSocketOpen(bc, x) {
   bare.writeBool(bc, x.canHibernate);
 }
-function readToServerWebSocketMessage(bc) {
+function readToRivetWebSocketMessage(bc) {
   return {
     data: bare.readData(bc),
     binary: bare.readBool(bc)
   };
 }
-function writeToServerWebSocketMessage(bc, x) {
+function writeToRivetWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function readToServerWebSocketMessageAck(bc) {
+function readToRivetWebSocketMessageAck(bc) {
   return {
     index: readMessageIndex(bc)
   };
 }
-function writeToServerWebSocketMessageAck(bc, x) {
+function writeToRivetWebSocketMessageAck(bc, x) {
   writeMessageIndex(bc, x.index);
 }
-function readToServerWebSocketClose(bc) {
+function readToRivetWebSocketClose(bc) {
   return {
-    code: read10(bc),
+    code: read12(bc),
     reason: read5(bc),
     hibernate: bare.readBool(bc)
   };
 }
-function writeToServerWebSocketClose(bc, x) {
-  write10(bc, x.code);
+function writeToRivetWebSocketClose(bc, x) {
+  write12(bc, x.code);
   write5(bc, x.reason);
   bare.writeBool(bc, x.hibernate);
 }
-function readToServerTunnelMessageKind(bc) {
+function readToRivetTunnelMessageKind(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "DeprecatedTunnelAck", val: null };
+      return { tag: "ToRivetResponseStart", val: readToRivetResponseStart(bc) };
     case 1:
-      return { tag: "ToServerResponseStart", val: readToServerResponseStart(bc) };
+      return { tag: "ToRivetResponseChunk", val: readToRivetResponseChunk(bc) };
     case 2:
-      return { tag: "ToServerResponseChunk", val: readToServerResponseChunk(bc) };
+      return { tag: "ToRivetResponseAbort", val: null };
     case 3:
-      return { tag: "ToServerResponseAbort", val: null };
+      return { tag: "ToRivetWebSocketOpen", val: readToRivetWebSocketOpen(bc) };
     case 4:
-      return { tag: "ToServerWebSocketOpen", val: readToServerWebSocketOpen(bc) };
+      return { tag: "ToRivetWebSocketMessage", val: readToRivetWebSocketMessage(bc) };
     case 5:
-      return { tag: "ToServerWebSocketMessage", val: readToServerWebSocketMessage(bc) };
+      return { tag: "ToRivetWebSocketMessageAck", val: readToRivetWebSocketMessageAck(bc) };
     case 6:
-      return { tag: "ToServerWebSocketMessageAck", val: readToServerWebSocketMessageAck(bc) };
-    case 7:
-      return { tag: "ToServerWebSocketClose", val: readToServerWebSocketClose(bc) };
+      return { tag: "ToRivetWebSocketClose", val: readToRivetWebSocketClose(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToServerTunnelMessageKind(bc, x) {
+function writeToRivetTunnelMessageKind(bc, x) {
   switch (x.tag) {
-    case "DeprecatedTunnelAck": {
+    case "ToRivetResponseStart": {
       bare.writeU8(bc, 0);
+      writeToRivetResponseStart(bc, x.val);
       break;
     }
-    case "ToServerResponseStart": {
+    case "ToRivetResponseChunk": {
       bare.writeU8(bc, 1);
-      writeToServerResponseStart(bc, x.val);
+      writeToRivetResponseChunk(bc, x.val);
       break;
     }
-    case "ToServerResponseChunk": {
+    case "ToRivetResponseAbort": {
       bare.writeU8(bc, 2);
-      writeToServerResponseChunk(bc, x.val);
       break;
     }
-    case "ToServerResponseAbort": {
+    case "ToRivetWebSocketOpen": {
       bare.writeU8(bc, 3);
+      writeToRivetWebSocketOpen(bc, x.val);
       break;
     }
-    case "ToServerWebSocketOpen": {
+    case "ToRivetWebSocketMessage": {
       bare.writeU8(bc, 4);
-      writeToServerWebSocketOpen(bc, x.val);
+      writeToRivetWebSocketMessage(bc, x.val);
       break;
     }
-    case "ToServerWebSocketMessage": {
+    case "ToRivetWebSocketMessageAck": {
       bare.writeU8(bc, 5);
-      writeToServerWebSocketMessage(bc, x.val);
+      writeToRivetWebSocketMessageAck(bc, x.val);
       break;
     }
-    case "ToServerWebSocketMessageAck": {
+    case "ToRivetWebSocketClose": {
       bare.writeU8(bc, 6);
-      writeToServerWebSocketMessageAck(bc, x.val);
-      break;
-    }
-    case "ToServerWebSocketClose": {
-      bare.writeU8(bc, 7);
-      writeToServerWebSocketClose(bc, x.val);
+      writeToRivetWebSocketClose(bc, x.val);
       break;
     }
   }
 }
-function readToServerTunnelMessage(bc) {
+function readToRivetTunnelMessage(bc) {
   return {
     messageId: readMessageId(bc),
-    messageKind: readToServerTunnelMessageKind(bc)
+    messageKind: readToRivetTunnelMessageKind(bc)
   };
 }
-function writeToServerTunnelMessage(bc, x) {
+function writeToRivetTunnelMessage(bc, x) {
   writeMessageId(bc, x.messageId);
-  writeToServerTunnelMessageKind(bc, x.messageKind);
+  writeToRivetTunnelMessageKind(bc, x.messageKind);
 }
-function readToClientTunnelMessageKind(bc) {
+function readToEnvoyTunnelMessageKind(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "DeprecatedTunnelAck", val: null };
+      return { tag: "ToEnvoyRequestStart", val: readToEnvoyRequestStart(bc) };
     case 1:
-      return { tag: "ToClientRequestStart", val: readToClientRequestStart(bc) };
+      return { tag: "ToEnvoyRequestChunk", val: readToEnvoyRequestChunk(bc) };
     case 2:
-      return { tag: "ToClientRequestChunk", val: readToClientRequestChunk(bc) };
+      return { tag: "ToEnvoyRequestAbort", val: null };
     case 3:
-      return { tag: "ToClientRequestAbort", val: null };
+      return { tag: "ToEnvoyWebSocketOpen", val: readToEnvoyWebSocketOpen(bc) };
     case 4:
-      return { tag: "ToClientWebSocketOpen", val: readToClientWebSocketOpen(bc) };
+      return { tag: "ToEnvoyWebSocketMessage", val: readToEnvoyWebSocketMessage(bc) };
     case 5:
-      return { tag: "ToClientWebSocketMessage", val: readToClientWebSocketMessage(bc) };
-    case 6:
-      return { tag: "ToClientWebSocketClose", val: readToClientWebSocketClose(bc) };
+      return { tag: "ToEnvoyWebSocketClose", val: readToEnvoyWebSocketClose(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToClientTunnelMessageKind(bc, x) {
+function writeToEnvoyTunnelMessageKind(bc, x) {
   switch (x.tag) {
-    case "DeprecatedTunnelAck": {
+    case "ToEnvoyRequestStart": {
       bare.writeU8(bc, 0);
+      writeToEnvoyRequestStart(bc, x.val);
       break;
     }
-    case "ToClientRequestStart": {
+    case "ToEnvoyRequestChunk": {
       bare.writeU8(bc, 1);
-      writeToClientRequestStart(bc, x.val);
+      writeToEnvoyRequestChunk(bc, x.val);
       break;
     }
-    case "ToClientRequestChunk": {
+    case "ToEnvoyRequestAbort": {
       bare.writeU8(bc, 2);
-      writeToClientRequestChunk(bc, x.val);
       break;
     }
-    case "ToClientRequestAbort": {
+    case "ToEnvoyWebSocketOpen": {
       bare.writeU8(bc, 3);
+      writeToEnvoyWebSocketOpen(bc, x.val);
       break;
     }
-    case "ToClientWebSocketOpen": {
+    case "ToEnvoyWebSocketMessage": {
       bare.writeU8(bc, 4);
-      writeToClientWebSocketOpen(bc, x.val);
+      writeToEnvoyWebSocketMessage(bc, x.val);
       break;
     }
-    case "ToClientWebSocketMessage": {
+    case "ToEnvoyWebSocketClose": {
       bare.writeU8(bc, 5);
-      writeToClientWebSocketMessage(bc, x.val);
-      break;
-    }
-    case "ToClientWebSocketClose": {
-      bare.writeU8(bc, 6);
-      writeToClientWebSocketClose(bc, x.val);
+      writeToEnvoyWebSocketClose(bc, x.val);
       break;
     }
   }
 }
-function readToClientTunnelMessage(bc) {
+function readToEnvoyTunnelMessage(bc) {
   return {
     messageId: readMessageId(bc),
-    messageKind: readToClientTunnelMessageKind(bc)
+    messageKind: readToEnvoyTunnelMessageKind(bc)
   };
 }
-function writeToClientTunnelMessage(bc, x) {
+function writeToEnvoyTunnelMessage(bc, x) {
   writeMessageId(bc, x.messageId);
-  writeToClientTunnelMessageKind(bc, x.messageKind);
+  writeToEnvoyTunnelMessageKind(bc, x.messageKind);
 }
-function read11(bc) {
+function readToEnvoyPing(bc) {
+  return {
+    ts: bare.readI64(bc)
+  };
+}
+function writeToEnvoyPing(bc, x) {
+  bare.writeI64(bc, x.ts);
+}
+function read13(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -990,50 +1145,46 @@ function read11(bc) {
   }
   return result;
 }
-function write11(bc, x) {
+function write13(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
     writeActorName(bc, kv[1]);
   }
 }
-function read12(bc) {
-  return bare.readBool(bc) ? read11(bc) : null;
+function read14(bc) {
+  return bare.readBool(bc) ? read13(bc) : null;
 }
-function write12(bc, x) {
+function write14(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
-    write11(bc, x);
+    write13(bc, x);
   }
 }
-function read13(bc) {
+function read15(bc) {
   return bare.readBool(bc) ? readJson(bc) : null;
 }
-function write13(bc, x) {
+function write15(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeJson(bc, x);
   }
 }
-function readToServerInit(bc) {
+function readToRivetInit(bc) {
   return {
-    name: bare.readString(bc),
+    envoyKey: bare.readString(bc),
     version: bare.readU32(bc),
-    totalSlots: bare.readU32(bc),
-    lastCommandIdx: read7(bc),
-    prepopulateActorNames: read12(bc),
-    metadata: read13(bc)
+    prepopulateActorNames: read14(bc),
+    metadata: read15(bc)
   };
 }
-function writeToServerInit(bc, x) {
-  bare.writeString(bc, x.name);
+function writeToRivetInit(bc, x) {
+  bare.writeString(bc, x.envoyKey);
   bare.writeU32(bc, x.version);
-  bare.writeU32(bc, x.totalSlots);
-  write7(bc, x.lastCommandIdx);
-  write12(bc, x.prepopulateActorNames);
-  write13(bc, x.metadata);
+  write14(bc, x.prepopulateActorNames);
+  write15(bc, x.metadata);
 }
-function readToServerEvents(bc) {
+function readToRivetEvents(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1044,114 +1195,131 @@ function readToServerEvents(bc) {
   }
   return result;
 }
-function writeToServerEvents(bc, x) {
+function writeToRivetEvents(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeEventWrapper(bc, x[i]);
   }
 }
-function readToServerAckCommands(bc) {
+function read16(bc) {
+  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 write16(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeActorCheckpoint(bc, x[i]);
+  }
+}
+function readToRivetAckCommands(bc) {
   return {
-    lastCommandIdx: bare.readI64(bc)
+    lastCommandCheckpoints: read16(bc)
   };
 }
-function writeToServerAckCommands(bc, x) {
-  bare.writeI64(bc, x.lastCommandIdx);
+function writeToRivetAckCommands(bc, x) {
+  write16(bc, x.lastCommandCheckpoints);
 }
-function readToServerPing(bc) {
+function readToRivetPong(bc) {
   return {
     ts: bare.readI64(bc)
   };
 }
-function writeToServerPing(bc, x) {
+function writeToRivetPong(bc, x) {
   bare.writeI64(bc, x.ts);
 }
-function readToServerKvRequest(bc) {
+function readToRivetKvRequest(bc) {
   return {
     actorId: readId(bc),
     requestId: bare.readU32(bc),
     data: readKvRequestData(bc)
   };
 }
-function writeToServerKvRequest(bc, x) {
+function writeToRivetKvRequest(bc, x) {
   writeId(bc, x.actorId);
   bare.writeU32(bc, x.requestId);
   writeKvRequestData(bc, x.data);
 }
-function readToServer(bc) {
+function readToRivet(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "ToServerInit", val: readToServerInit(bc) };
+      return { tag: "ToRivetInit", val: readToRivetInit(bc) };
     case 1:
-      return { tag: "ToServerEvents", val: readToServerEvents(bc) };
+      return { tag: "ToRivetEvents", val: readToRivetEvents(bc) };
     case 2:
-      return { tag: "ToServerAckCommands", val: readToServerAckCommands(bc) };
+      return { tag: "ToRivetAckCommands", val: readToRivetAckCommands(bc) };
     case 3:
-      return { tag: "ToServerStopping", val: null };
+      return { tag: "ToRivetStopping", val: null };
     case 4:
-      return { tag: "ToServerPing", val: readToServerPing(bc) };
+      return { tag: "ToRivetPong", val: readToRivetPong(bc) };
     case 5:
-      return { tag: "ToServerKvRequest", val: readToServerKvRequest(bc) };
+      return { tag: "ToRivetKvRequest", val: readToRivetKvRequest(bc) };
     case 6:
-      return { tag: "ToServerTunnelMessage", val: readToServerTunnelMessage(bc) };
+      return { tag: "ToRivetTunnelMessage", val: readToRivetTunnelMessage(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToServer(bc, x) {
+function writeToRivet(bc, x) {
   switch (x.tag) {
-    case "ToServerInit": {
+    case "ToRivetInit": {
       bare.writeU8(bc, 0);
-      writeToServerInit(bc, x.val);
+      writeToRivetInit(bc, x.val);
       break;
     }
-    case "ToServerEvents": {
+    case "ToRivetEvents": {
       bare.writeU8(bc, 1);
-      writeToServerEvents(bc, x.val);
+      writeToRivetEvents(bc, x.val);
       break;
     }
-    case "ToServerAckCommands": {
+    case "ToRivetAckCommands": {
       bare.writeU8(bc, 2);
-      writeToServerAckCommands(bc, x.val);
+      writeToRivetAckCommands(bc, x.val);
       break;
     }
-    case "ToServerStopping": {
+    case "ToRivetStopping": {
       bare.writeU8(bc, 3);
       break;
     }
-    case "ToServerPing": {
+    case "ToRivetPong": {
       bare.writeU8(bc, 4);
-      writeToServerPing(bc, x.val);
+      writeToRivetPong(bc, x.val);
       break;
     }
-    case "ToServerKvRequest": {
+    case "ToRivetKvRequest": {
       bare.writeU8(bc, 5);
-      writeToServerKvRequest(bc, x.val);
+      writeToRivetKvRequest(bc, x.val);
       break;
     }
-    case "ToServerTunnelMessage": {
+    case "ToRivetTunnelMessage": {
       bare.writeU8(bc, 6);
-      writeToServerTunnelMessage(bc, x.val);
+      writeToRivetTunnelMessage(bc, x.val);
       break;
     }
   }
 }
-function encodeToServer(x, config) {
+function encodeToRivet(x, config) {
   const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
   const bc = new bare.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeToServer(bc, x);
+  writeToRivet(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeToServer(bytes) {
+function decodeToRivet(bytes) {
   const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
-  const result = readToServer(bc);
+  const result = readToRivet(bc);
   if (bc.offset < bc.view.byteLength) {
     throw new bare.BareError(bc.offset, "remaining bytes");
   }
@@ -1159,25 +1327,27 @@ function decodeToServer(bytes) {
 }
 function readProtocolMetadata(bc) {
   return {
-    runnerLostThreshold: bare.readI64(bc)
+    envoyLostThreshold: bare.readI64(bc),
+    actorStopThreshold: bare.readI64(bc),
+    serverlessDrainGracePeriod: read7(bc),
+    maxResponsePayloadSize: bare.readU64(bc)
   };
 }
 function writeProtocolMetadata(bc, x) {
-  bare.writeI64(bc, x.runnerLostThreshold);
+  bare.writeI64(bc, x.envoyLostThreshold);
+  bare.writeI64(bc, x.actorStopThreshold);
+  write7(bc, x.serverlessDrainGracePeriod);
+  bare.writeU64(bc, x.maxResponsePayloadSize);
 }
-function readToClientInit(bc) {
+function readToEnvoyInit(bc) {
   return {
-    runnerId: readId(bc),
-    lastEventIdx: bare.readI64(bc),
     metadata: readProtocolMetadata(bc)
   };
 }
-function writeToClientInit(bc, x) {
-  writeId(bc, x.runnerId);
-  bare.writeI64(bc, x.lastEventIdx);
+function writeToEnvoyInit(bc, x) {
   writeProtocolMetadata(bc, x.metadata);
 }
-function readToClientCommands(bc) {
+function readToEnvoyCommands(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1188,188 +1358,175 @@ function readToClientCommands(bc) {
   }
   return result;
 }
-function writeToClientCommands(bc, x) {
+function writeToEnvoyCommands(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeCommandWrapper(bc, x[i]);
   }
 }
-function readToClientAckEvents(bc) {
+function readToEnvoyAckEvents(bc) {
   return {
-    lastEventIdx: bare.readI64(bc)
+    lastEventCheckpoints: read16(bc)
   };
 }
-function writeToClientAckEvents(bc, x) {
-  bare.writeI64(bc, x.lastEventIdx);
+function writeToEnvoyAckEvents(bc, x) {
+  write16(bc, x.lastEventCheckpoints);
 }
-function readToClientKvResponse(bc) {
+function readToEnvoyKvResponse(bc) {
   return {
     requestId: bare.readU32(bc),
     data: readKvResponseData(bc)
   };
 }
-function writeToClientKvResponse(bc, x) {
+function writeToEnvoyKvResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeKvResponseData(bc, x.data);
 }
-function readToClient(bc) {
+function readToEnvoy(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "ToClientInit", val: readToClientInit(bc) };
+      return { tag: "ToEnvoyInit", val: readToEnvoyInit(bc) };
     case 1:
-      return { tag: "ToClientClose", val: null };
+      return { tag: "ToEnvoyCommands", val: readToEnvoyCommands(bc) };
     case 2:
-      return { tag: "ToClientCommands", val: readToClientCommands(bc) };
+      return { tag: "ToEnvoyAckEvents", val: readToEnvoyAckEvents(bc) };
     case 3:
-      return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) };
+      return { tag: "ToEnvoyKvResponse", val: readToEnvoyKvResponse(bc) };
     case 4:
-      return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) };
+      return { tag: "ToEnvoyTunnelMessage", val: readToEnvoyTunnelMessage(bc) };
     case 5:
-      return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) };
+      return { tag: "ToEnvoyPing", val: readToEnvoyPing(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToClient(bc, x) {
+function writeToEnvoy(bc, x) {
   switch (x.tag) {
-    case "ToClientInit": {
+    case "ToEnvoyInit": {
       bare.writeU8(bc, 0);
-      writeToClientInit(bc, x.val);
+      writeToEnvoyInit(bc, x.val);
       break;
     }
-    case "ToClientClose": {
+    case "ToEnvoyCommands": {
       bare.writeU8(bc, 1);
+      writeToEnvoyCommands(bc, x.val);
       break;
     }
-    case "ToClientCommands": {
+    case "ToEnvoyAckEvents": {
       bare.writeU8(bc, 2);
-      writeToClientCommands(bc, x.val);
+      writeToEnvoyAckEvents(bc, x.val);
       break;
     }
-    case "ToClientAckEvents": {
+    case "ToEnvoyKvResponse": {
       bare.writeU8(bc, 3);
-      writeToClientAckEvents(bc, x.val);
+      writeToEnvoyKvResponse(bc, x.val);
       break;
     }
-    case "ToClientKvResponse": {
+    case "ToEnvoyTunnelMessage": {
       bare.writeU8(bc, 4);
-      writeToClientKvResponse(bc, x.val);
+      writeToEnvoyTunnelMessage(bc, x.val);
       break;
     }
-    case "ToClientTunnelMessage": {
+    case "ToEnvoyPing": {
       bare.writeU8(bc, 5);
-      writeToClientTunnelMessage(bc, x.val);
+      writeToEnvoyPing(bc, x.val);
       break;
     }
   }
 }
-function encodeToClient(x, config) {
+function encodeToEnvoy(x, config) {
   const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
   const bc = new bare.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeToClient(bc, x);
+  writeToEnvoy(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeToClient(bytes) {
+function decodeToEnvoy(bytes) {
   const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
-  const result = readToClient(bc);
+  const result = readToEnvoy(bc);
   if (bc.offset < bc.view.byteLength) {
     throw new bare.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
-function readToRunnerPing(bc) {
+function readToEnvoyConnPing(bc) {
   return {
     gatewayId: readGatewayId(bc),
     requestId: readRequestId(bc),
     ts: bare.readI64(bc)
   };
 }
-function writeToRunnerPing(bc, x) {
+function writeToEnvoyConnPing(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
   bare.writeI64(bc, x.ts);
 }
-function readToRunner(bc) {
+function readToEnvoyConn(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "ToRunnerPing", val: readToRunnerPing(bc) };
+      return { tag: "ToEnvoyConnPing", val: readToEnvoyConnPing(bc) };
     case 1:
-      return { tag: "ToClientInit", val: readToClientInit(bc) };
+      return { tag: "ToEnvoyConnClose", val: null };
     case 2:
-      return { tag: "ToClientClose", val: null };
+      return { tag: "ToEnvoyCommands", val: readToEnvoyCommands(bc) };
     case 3:
-      return { tag: "ToClientCommands", val: readToClientCommands(bc) };
+      return { tag: "ToEnvoyAckEvents", val: readToEnvoyAckEvents(bc) };
     case 4:
-      return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) };
-    case 5:
-      return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) };
-    case 6:
-      return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) };
+      return { tag: "ToEnvoyTunnelMessage", val: readToEnvoyTunnelMessage(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToRunner(bc, x) {
+function writeToEnvoyConn(bc, x) {
   switch (x.tag) {
-    case "ToRunnerPing": {
+    case "ToEnvoyConnPing": {
       bare.writeU8(bc, 0);
-      writeToRunnerPing(bc, x.val);
+      writeToEnvoyConnPing(bc, x.val);
       break;
     }
-    case "ToClientInit": {
+    case "ToEnvoyConnClose": {
       bare.writeU8(bc, 1);
-      writeToClientInit(bc, x.val);
       break;
     }
-    case "ToClientClose": {
+    case "ToEnvoyCommands": {
       bare.writeU8(bc, 2);
+      writeToEnvoyCommands(bc, x.val);
       break;
     }
-    case "ToClientCommands": {
+    case "ToEnvoyAckEvents": {
       bare.writeU8(bc, 3);
-      writeToClientCommands(bc, x.val);
+      writeToEnvoyAckEvents(bc, x.val);
       break;
     }
-    case "ToClientAckEvents": {
+    case "ToEnvoyTunnelMessage": {
       bare.writeU8(bc, 4);
-      writeToClientAckEvents(bc, x.val);
-      break;
-    }
-    case "ToClientKvResponse": {
-      bare.writeU8(bc, 5);
-      writeToClientKvResponse(bc, x.val);
-      break;
-    }
-    case "ToClientTunnelMessage": {
-      bare.writeU8(bc, 6);
-      writeToClientTunnelMessage(bc, x.val);
+      writeToEnvoyTunnelMessage(bc, x.val);
       break;
     }
   }
 }
-function encodeToRunner(x, config) {
+function encodeToEnvoyConn(x, config) {
   const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
   const bc = new bare.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeToRunner(bc, x);
+  writeToEnvoyConn(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeToRunner(bytes) {
+function decodeToEnvoyConn(bytes) {
   const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
-  const result = readToRunner(bc);
+  const result = readToEnvoyConn(bc);
   if (bc.offset < bc.view.byteLength) {
     throw new bare.BareError(bc.offset, "remaining bytes");
   }
@@ -1392,7 +1549,7 @@ function readToGateway(bc) {
     case 0:
       return { tag: "ToGatewayPong", val: readToGatewayPong(bc) };
     case 1:
-      return { tag: "ToServerTunnelMessage", val: readToServerTunnelMessage(bc) };
+      return { tag: "ToRivetTunnelMessage", val: readToRivetTunnelMessage(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -1406,9 +1563,9 @@ function writeToGateway(bc, x) {
       writeToGatewayPong(bc, x.val);
       break;
     }
-    case "ToServerTunnelMessage": {
+    case "ToRivetTunnelMessage": {
       bare.writeU8(bc, 1);
-      writeToServerTunnelMessage(bc, x.val);
+      writeToRivetTunnelMessage(bc, x.val);
       break;
     }
   }
@@ -1430,64 +1587,80 @@ function decodeToGateway(bytes) {
   }
   return result;
 }
-function readToServerlessServerInit(bc) {
+function readToOutboundActorStart(bc) {
   return {
-    runnerId: readId(bc)
+    namespaceId: readId(bc),
+    poolName: bare.readString(bc),
+    checkpoint: readActorCheckpoint(bc),
+    actorConfig: readActorConfig(bc)
   };
 }
-function writeToServerlessServerInit(bc, x) {
-  writeId(bc, x.runnerId);
+function writeToOutboundActorStart(bc, x) {
+  writeId(bc, x.namespaceId);
+  bare.writeString(bc, x.poolName);
+  writeActorCheckpoint(bc, x.checkpoint);
+  writeActorConfig(bc, x.actorConfig);
 }
-function readToServerlessServer(bc) {
+function readToOutbound(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "ToServerlessServerInit", val: readToServerlessServerInit(bc) };
+      return { tag: "ToOutboundActorStart", val: readToOutboundActorStart(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeToServerlessServer(bc, x) {
+function writeToOutbound(bc, x) {
   switch (x.tag) {
-    case "ToServerlessServerInit": {
+    case "ToOutboundActorStart": {
       bare.writeU8(bc, 0);
-      writeToServerlessServerInit(bc, x.val);
+      writeToOutboundActorStart(bc, x.val);
       break;
     }
   }
 }
-function encodeToServerlessServer(x, config) {
+function encodeToOutbound(x, config) {
   const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
   const bc = new bare.ByteCursor(
     new Uint8Array(fullConfig.initialBufferLength),
     fullConfig
   );
-  writeToServerlessServer(bc, x);
+  writeToOutbound(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
-function decodeToServerlessServer(bytes) {
+function decodeToOutbound(bytes) {
   const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
-  const result = readToServerlessServer(bc);
+  const result = readToOutbound(bc);
   if (bc.offset < bc.view.byteLength) {
     throw new bare.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
+function assert(condition, message) {
+  if (!condition) throw new Error(message ?? "Assertion failed");
+}
+var VERSION = 1;
 export {
+  StopActorReason,
   StopCode,
-  decodeToClient,
+  VERSION,
+  decodeActorCommandKeyData,
+  decodeToEnvoy,
+  decodeToEnvoyConn,
   decodeToGateway,
-  decodeToRunner,
-  decodeToServer,
-  decodeToServerlessServer,
-  encodeToClient,
+  decodeToOutbound,
+  decodeToRivet,
+  encodeActorCommandKeyData,
+  encodeToEnvoy,
+  encodeToEnvoyConn,
   encodeToGateway,
-  encodeToRunner,
-  encodeToServer,
-  encodeToServerlessServer,
+  encodeToOutbound,
+  encodeToRivet,
+  readActorCheckpoint,
+  readActorCommandKeyData,
   readActorConfig,
   readActorIntent,
   readActorName,
@@ -1506,6 +1679,7 @@ export {
   readHibernatingRequest,
   readId,
   readJson,
+  readKvDeleteRangeRequest,
   readKvDeleteRequest,
   readKvErrorResponse,
   readKvGetRequest,
@@ -1523,41 +1697,47 @@ export {
   readKvValue,
   readMessageId,
   readMessageIndex,
+  readPreloadedKv,
+  readPreloadedKvEntry,
   readProtocolMetadata,
   readRequestId,
+  readStopActorReason,
   readStopCode,
-  readToClient,
-  readToClientAckEvents,
-  readToClientCommands,
-  readToClientInit,
-  readToClientKvResponse,
-  readToClientRequestChunk,
-  readToClientRequestStart,
-  readToClientTunnelMessage,
-  readToClientTunnelMessageKind,
-  readToClientWebSocketClose,
-  readToClientWebSocketMessage,
-  readToClientWebSocketOpen,
+  readToEnvoy,
+  readToEnvoyAckEvents,
+  readToEnvoyCommands,
+  readToEnvoyConn,
+  readToEnvoyConnPing,
+  readToEnvoyInit,
+  readToEnvoyKvResponse,
+  readToEnvoyPing,
+  readToEnvoyRequestChunk,
+  readToEnvoyRequestStart,
+  readToEnvoyTunnelMessage,
+  readToEnvoyTunnelMessageKind,
+  readToEnvoyWebSocketClose,
+  readToEnvoyWebSocketMessage,
+  readToEnvoyWebSocketOpen,
   readToGateway,
   readToGatewayPong,
-  readToRunner,
-  readToRunnerPing,
-  readToServer,
-  readToServerAckCommands,
-  readToServerEvents,
-  readToServerInit,
-  readToServerKvRequest,
-  readToServerPing,
-  readToServerResponseChunk,
-  readToServerResponseStart,
-  readToServerTunnelMessage,
-  readToServerTunnelMessageKind,
-  readToServerWebSocketClose,
-  readToServerWebSocketMessage,
-  readToServerWebSocketMessageAck,
-  readToServerWebSocketOpen,
-  readToServerlessServer,
-  readToServerlessServerInit,
+  readToOutbound,
+  readToOutboundActorStart,
+  readToRivet,
+  readToRivetAckCommands,
+  readToRivetEvents,
+  readToRivetInit,
+  readToRivetKvRequest,
+  readToRivetPong,
+  readToRivetResponseChunk,
+  readToRivetResponseStart,
+  readToRivetTunnelMessage,
+  readToRivetTunnelMessageKind,
+  readToRivetWebSocketClose,
+  readToRivetWebSocketMessage,
+  readToRivetWebSocketMessageAck,
+  readToRivetWebSocketOpen,
+  writeActorCheckpoint,
+  writeActorCommandKeyData,
   writeActorConfig,
   writeActorIntent,
   writeActorName,
@@ -1576,6 +1756,7 @@ export {
   writeHibernatingRequest,
   writeId,
   writeJson,
+  writeKvDeleteRangeRequest,
   writeKvDeleteRequest,
   writeKvErrorResponse,
   writeKvGetRequest,
@@ -1593,40 +1774,44 @@ export {
   writeKvValue,
   writeMessageId,
   writeMessageIndex,
+  writePreloadedKv,
+  writePreloadedKvEntry,
   writeProtocolMetadata,
   writeRequestId,
+  writeStopActorReason,
   writeStopCode,
-  writeToClient,
-  writeToClientAckEvents,
-  writeToClientCommands,
-  writeToClientInit,
-  writeToClientKvResponse,
-  writeToClientRequestChunk,
-  writeToClientRequestStart,
-  writeToClientTunnelMessage,
-  writeToClientTunnelMessageKind,
-  writeToClientWebSocketClose,
-  writeToClientWebSocketMessage,
-  writeToClientWebSocketOpen,
+  writeToEnvoy,
+  writeToEnvoyAckEvents,
+  writeToEnvoyCommands,
+  writeToEnvoyConn,
+  writeToEnvoyConnPing,
+  writeToEnvoyInit,
+  writeToEnvoyKvResponse,
+  writeToEnvoyPing,
+  writeToEnvoyRequestChunk,
+  writeToEnvoyRequestStart,
+  writeToEnvoyTunnelMessage,
+  writeToEnvoyTunnelMessageKind,
+  writeToEnvoyWebSocketClose,
+  writeToEnvoyWebSocketMessage,
+  writeToEnvoyWebSocketOpen,
   writeToGateway,
   writeToGatewayPong,
-  writeToRunner,
-  writeToRunnerPing,
-  writeToServer,
-  writeToServerAckCommands,
-  writeToServerEvents,
-  writeToServerInit,
-  writeToServerKvRequest,
-  writeToServerPing,
-  writeToServerResponseChunk,
-  writeToServerResponseStart,
-  writeToServerTunnelMessage,
-  writeToServerTunnelMessageKind,
-  writeToServerWebSocketClose,
-  writeToServerWebSocketMessage,
-  writeToServerWebSocketMessageAck,
-  writeToServerWebSocketOpen,
-  writeToServerlessServer,
-  writeToServerlessServerInit
+  writeToOutbound,
+  writeToOutboundActorStart,
+  writeToRivet,
+  writeToRivetAckCommands,
+  writeToRivetEvents,
+  writeToRivetInit,
+  writeToRivetKvRequest,
+  writeToRivetPong,
+  writeToRivetResponseChunk,
+  writeToRivetResponseStart,
+  writeToRivetTunnelMessage,
+  writeToRivetTunnelMessageKind,
+  writeToRivetWebSocketClose,
+  writeToRivetWebSocketMessage,
+  writeToRivetWebSocketMessageAck,
+  writeToRivetWebSocketOpen
 };
 //# sourceMappingURL=index.js.map