@rivetkit/engine-envoy-protocol 0.0.0-main.72cbc7c → 0.0.0-main.78336a1

package/dist/index.js

@@ -582,6 +582,160 @@ function writeSqliteCommitResponse(bc, x) {
     }
   }
 }
+function readSqliteCommitStageBeginRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
+  };
+}
+function writeSqliteCommitStageBeginRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
+}
+function readSqliteCommitStageBeginOk(bc) {
+  return {
+    txid: bare.readU64(bc)
+  };
+}
+function writeSqliteCommitStageBeginOk(bc, x) {
+  bare.writeU64(bc, x.txid);
+}
+function readSqliteCommitStageBeginResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitStageBeginOk", val: readSqliteCommitStageBeginOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitStageBeginResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitStageBeginOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitStageBeginOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitStageSegmentRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    txid: bare.readU64(bc),
+    firstPgno: bare.readU32(bc),
+    dirtyPages: read8(bc)
+  };
+}
+function writeSqliteCommitStageSegmentRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  bare.writeU64(bc, x.txid);
+  bare.writeU32(bc, x.firstPgno);
+  write8(bc, x.dirtyPages);
+}
+function readSqliteCommitStageSegmentOk(bc) {
+  return {
+    stagedBytes: bare.readU64(bc)
+  };
+}
+function writeSqliteCommitStageSegmentOk(bc, x) {
+  bare.writeU64(bc, x.stagedBytes);
+}
+function readSqliteCommitStageSegmentResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitStageSegmentOk", val: readSqliteCommitStageSegmentOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitStageSegmentResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitStageSegmentOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitStageSegmentOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitFinalizeRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    txid: bare.readU64(bc),
+    newDbSizePages: bare.readU32(bc),
+    nowMs: bare.readI64(bc),
+    segmentFirstPgnos: bare.readU32Array(bc)
+  };
+}
+function writeSqliteCommitFinalizeRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  bare.writeU64(bc, x.txid);
+  bare.writeU32(bc, x.newDbSizePages);
+  bare.writeI64(bc, x.nowMs);
+  bare.writeU32Array(bc, x.segmentFirstPgnos);
+}
+function readSqliteCommitFinalizeOk(bc) {
+  return {
+    headTxid: read2(bc)
+  };
+}
+function writeSqliteCommitFinalizeOk(bc, x) {
+  write2(bc, x.headTxid);
+}
+function readSqliteCommitFinalizeResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitFinalizeOk", val: readSqliteCommitFinalizeOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitFinalizeResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitFinalizeOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitFinalizeOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
 function readSqliteValueInteger(bc) {
   return {
     value: bare.readI64(bc)
@@ -853,6 +1007,47 @@ function writeSqliteExecuteRequest(bc, x) {
   bare.writeString(bc, x.sql);
   write14(bc, x.params);
 }
+function readSqliteBatchStatement(bc) {
+  return {
+    sql: bare.readString(bc),
+    params: read14(bc)
+  };
+}
+function writeSqliteBatchStatement(bc, x) {
+  bare.writeString(bc, x.sql);
+  write14(bc, x.params);
+}
+function read15(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteBatchStatement(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteBatchStatement(bc);
+  }
+  return result;
+}
+function write15(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteBatchStatement(bc, x[i]);
+  }
+}
+function readSqliteExecuteBatchRequest(bc) {
+  return {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    statements: read15(bc)
+  };
+}
+function writeSqliteExecuteBatchRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  write15(bc, x.statements);
+}
 function readSqliteExecOk(bc) {
   return {
     result: readSqliteQueryResult(bc)
@@ -869,6 +1064,31 @@ function readSqliteExecuteOk(bc) {
 function writeSqliteExecuteOk(bc, x) {
   writeSqliteExecuteResult(bc, x.result);
 }
+function read16(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteExecuteResult(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteExecuteResult(bc);
+  }
+  return result;
+}
+function write16(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteExecuteResult(bc, x[i]);
+  }
+}
+function readSqliteExecuteBatchOk(bc) {
+  return {
+    results: read16(bc)
+  };
+}
+function writeSqliteExecuteBatchOk(bc, x) {
+  write16(bc, x.results);
+}
 function readSqliteExecResponse(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -925,6 +1145,34 @@ function writeSqliteExecuteResponse(bc, x) {
     }
   }
 }
+function readSqliteExecuteBatchResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteExecuteBatchOk", val: readSqliteExecuteBatchOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecuteBatchResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteExecuteBatchOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteExecuteBatchOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
 var StopCode = /* @__PURE__ */ ((StopCode2) => {
   StopCode2["Ok"] = "Ok";
   StopCode2["Error"] = "Error";
@@ -964,19 +1212,19 @@ function readActorName(bc) {
 function writeActorName(bc, x) {
   writeJson(bc, x.metadata);
 }
-function read15(bc) {
+function read17(bc) {
   return bare.readBool(bc) ? bare.readString(bc) : null;
 }
-function write15(bc, x) {
+function write17(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeString(bc, x);
   }
 }
-function read16(bc) {
+function read18(bc) {
   return bare.readBool(bc) ? bare.readData(bc) : null;
 }
-function write16(bc, x) {
+function write18(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeData(bc, x);
@@ -985,16 +1233,16 @@ function write16(bc, x) {
 function readActorConfig(bc) {
   return {
     name: bare.readString(bc),
-    key: read15(bc),
+    key: read17(bc),
     createTs: bare.readI64(bc),
-    input: read16(bc)
+    input: read18(bc)
   };
 }
 function writeActorConfig(bc, x) {
   bare.writeString(bc, x.name);
-  write15(bc, x.key);
+  write17(bc, x.key);
   bare.writeI64(bc, x.createTs);
-  write16(bc, x.input);
+  write18(bc, x.input);
 }
 function readActorCheckpoint(bc) {
   return {
@@ -1037,12 +1285,12 @@ function writeActorIntent(bc, x) {
 function readActorStateStopped(bc) {
   return {
     code: readStopCode(bc),
-    message: read15(bc)
+    message: read17(bc)
   };
 }
 function writeActorStateStopped(bc, x) {
   writeStopCode(bc, x.code);
-  write15(bc, x.message);
+  write17(bc, x.message);
 }
 function readActorState(bc) {
   const offset = bc.offset;
@@ -1152,7 +1400,7 @@ function writePreloadedKvEntry(bc, x) {
   writeKvValue(bc, x.value);
   writeKvMetadata(bc, x.metadata);
 }
-function read17(bc) {
+function read19(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1163,7 +1411,7 @@ function read17(bc) {
   }
   return result;
 }
-function write17(bc, x) {
+function write19(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePreloadedKvEntry(bc, x[i]);
@@ -1171,13 +1419,13 @@ function write17(bc, x) {
 }
 function readPreloadedKv(bc) {
   return {
-    entries: read17(bc),
+    entries: read19(bc),
     requestedGetKeys: read0(bc),
     requestedPrefixes: read0(bc)
   };
 }
 function writePreloadedKv(bc, x) {
-  write17(bc, x.entries);
+  write19(bc, x.entries);
   write0(bc, x.requestedGetKeys);
   write0(bc, x.requestedPrefixes);
 }
@@ -1191,7 +1439,7 @@ function writeHibernatingRequest(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
 }
-function read18(bc) {
+function read20(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1202,16 +1450,16 @@ function read18(bc) {
   }
   return result;
 }
-function write18(bc, x) {
+function write20(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeHibernatingRequest(bc, x[i]);
   }
 }
-function read19(bc) {
+function read21(bc) {
   return bare.readBool(bc) ? readPreloadedKv(bc) : null;
 }
-function write19(bc, x) {
+function write21(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writePreloadedKv(bc, x);
@@ -1220,14 +1468,14 @@ function write19(bc, x) {
 function readCommandStartActor(bc) {
   return {
     config: readActorConfig(bc),
-    hibernatingRequests: read18(bc),
-    preloadedKv: read19(bc)
+    hibernatingRequests: read20(bc),
+    preloadedKv: read21(bc)
   };
 }
 function writeCommandStartActor(bc, x) {
   writeActorConfig(bc, x.config);
-  write18(bc, x.hibernatingRequests);
-  write19(bc, x.preloadedKv);
+  write20(bc, x.hibernatingRequests);
+  write21(bc, x.preloadedKv);
 }
 var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
   StopActorReason2["SleepIntent"] = "SleepIntent";
@@ -1384,7 +1632,16 @@ function writeMessageId(bc, x) {
   writeRequestId(bc, x.requestId);
   writeMessageIndex(bc, x.messageIndex);
 }
-function read20(bc) {
+function read22(bc) {
+  return bare.readBool(bc) ? bare.readU32(bc) : null;
+}
+function write22(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU32(bc, x);
+  }
+}
+function read23(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1398,7 +1655,7 @@ function read20(bc) {
   }
   return result;
 }
-function write20(bc, x) {
+function write23(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
@@ -1408,20 +1665,24 @@ function write20(bc, x) {
 function readToEnvoyRequestStart(bc) {
   return {
     actorId: readId(bc),
+    actorGeneration: read22(bc),
     method: bare.readString(bc),
     path: bare.readString(bc),
-    headers: read20(bc),
-    body: read16(bc),
-    stream: bare.readBool(bc)
+    headers: read23(bc),
+    body: read18(bc),
+    stream: bare.readBool(bc),
+    responseStream: bare.readBool(bc)
   };
 }
 function writeToEnvoyRequestStart(bc, x) {
   writeId(bc, x.actorId);
+  write22(bc, x.actorGeneration);
   bare.writeString(bc, x.method);
   bare.writeString(bc, x.path);
-  write20(bc, x.headers);
-  write16(bc, x.body);
+  write23(bc, x.headers);
+  write18(bc, x.body);
   bare.writeBool(bc, x.stream);
+  bare.writeBool(bc, x.responseStream);
 }
 function readToEnvoyRequestChunk(bc) {
   return {
@@ -1433,18 +1694,102 @@ function writeToEnvoyRequestChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
 }
+function readToRivetRequestBodyWindowUpdate(bc) {
+  return {
+    consumedBytes: bare.readU64(bc)
+  };
+}
+function writeToRivetRequestBodyWindowUpdate(bc, x) {
+  bare.writeU64(bc, x.consumedBytes);
+}
+var HttpStreamAbortReasonKind = /* @__PURE__ */ ((HttpStreamAbortReasonKind2) => {
+  HttpStreamAbortReasonKind2["Unknown"] = "Unknown";
+  HttpStreamAbortReasonKind2["Cancelled"] = "Cancelled";
+  HttpStreamAbortReasonKind2["HandlerError"] = "HandlerError";
+  HttpStreamAbortReasonKind2["InternalError"] = "InternalError";
+  return HttpStreamAbortReasonKind2;
+})(HttpStreamAbortReasonKind || {});
+function readHttpStreamAbortReasonKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "Unknown" /* Unknown */;
+    case 1:
+      return "Cancelled" /* Cancelled */;
+    case 2:
+      return "HandlerError" /* HandlerError */;
+    case 3:
+      return "InternalError" /* InternalError */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeHttpStreamAbortReasonKind(bc, x) {
+  switch (x) {
+    case "Unknown" /* Unknown */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "Cancelled" /* Cancelled */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "HandlerError" /* HandlerError */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "InternalError" /* InternalError */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+  }
+}
+function readHttpStreamAbortReason(bc) {
+  return {
+    kind: readHttpStreamAbortReasonKind(bc),
+    detail: read17(bc)
+  };
+}
+function writeHttpStreamAbortReason(bc, x) {
+  writeHttpStreamAbortReasonKind(bc, x.kind);
+  write17(bc, x.detail);
+}
+function read24(bc) {
+  return bare.readBool(bc) ? readId(bc) : null;
+}
+function write24(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeId(bc, x);
+  }
+}
+function readToEnvoyRequestAbort(bc) {
+  return {
+    actorId: read24(bc),
+    actorGeneration: read22(bc),
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToEnvoyRequestAbort(bc, x) {
+  write24(bc, x.actorId);
+  write22(bc, x.actorGeneration);
+  writeHttpStreamAbortReason(bc, x.reason);
+}
 function readToRivetResponseStart(bc) {
   return {
     status: bare.readU16(bc),
-    headers: read20(bc),
-    body: read16(bc),
+    headers: read23(bc),
+    body: read18(bc),
     stream: bare.readBool(bc)
   };
 }
 function writeToRivetResponseStart(bc, x) {
   bare.writeU16(bc, x.status);
-  write20(bc, x.headers);
-  write16(bc, x.body);
+  write23(bc, x.headers);
+  write18(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToRivetResponseChunk(bc) {
@@ -1457,17 +1802,35 @@ function writeToRivetResponseChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
 }
+function readToEnvoyResponseBodyWindowUpdate(bc) {
+  return {
+    consumedBytes: bare.readU64(bc)
+  };
+}
+function writeToEnvoyResponseBodyWindowUpdate(bc, x) {
+  bare.writeU64(bc, x.consumedBytes);
+}
+function readToRivetResponseAbort(bc) {
+  return {
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToRivetResponseAbort(bc, x) {
+  writeHttpStreamAbortReason(bc, x.reason);
+}
 function readToEnvoyWebSocketOpen(bc) {
   return {
     actorId: readId(bc),
+    actorGeneration: read22(bc),
     path: bare.readString(bc),
-    headers: read20(bc)
+    headers: read23(bc)
   };
 }
 function writeToEnvoyWebSocketOpen(bc, x) {
   writeId(bc, x.actorId);
+  write22(bc, x.actorGeneration);
   bare.writeString(bc, x.path);
-  write20(bc, x.headers);
+  write23(bc, x.headers);
 }
 function readToEnvoyWebSocketMessage(bc) {
   return {
@@ -1479,10 +1842,10 @@ function writeToEnvoyWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function read21(bc) {
+function read25(bc) {
   return bare.readBool(bc) ? bare.readU16(bc) : null;
 }
-function write21(bc, x) {
+function write25(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeU16(bc, x);
@@ -1490,13 +1853,13 @@ function write21(bc, x) {
 }
 function readToEnvoyWebSocketClose(bc) {
   return {
-    code: read21(bc),
-    reason: read15(bc)
+    code: read25(bc),
+    reason: read17(bc)
   };
 }
 function writeToEnvoyWebSocketClose(bc, x) {
-  write21(bc, x.code);
-  write15(bc, x.reason);
+  write25(bc, x.code);
+  write17(bc, x.reason);
 }
 function readToRivetWebSocketOpen(bc) {
   return {
@@ -1526,14 +1889,14 @@ function writeToRivetWebSocketMessageAck(bc, x) {
 }
 function readToRivetWebSocketClose(bc) {
   return {
-    code: read21(bc),
-    reason: read15(bc),
+    code: read25(bc),
+    reason: read17(bc),
     hibernate: bare.readBool(bc)
   };
 }
 function writeToRivetWebSocketClose(bc, x) {
-  write21(bc, x.code);
-  write15(bc, x.reason);
+  write25(bc, x.code);
+  write17(bc, x.reason);
   bare.writeBool(bc, x.hibernate);
 }
 function readToRivetTunnelMessageKind(bc) {
@@ -1545,14 +1908,18 @@ function readToRivetTunnelMessageKind(bc) {
     case 1:
       return { tag: "ToRivetResponseChunk", val: readToRivetResponseChunk(bc) };
     case 2:
-      return { tag: "ToRivetResponseAbort", val: null };
+      return { tag: "ToRivetResponseAbort", val: readToRivetResponseAbort(bc) };
     case 3:
-      return { tag: "ToRivetWebSocketOpen", val: readToRivetWebSocketOpen(bc) };
+      return { tag: "ToRivetRequestBodyWindowUpdate", val: readToRivetRequestBodyWindowUpdate(bc) };
     case 4:
-      return { tag: "ToRivetWebSocketMessage", val: readToRivetWebSocketMessage(bc) };
+      return { tag: "ToRivetRequestBodyCancel", val: null };
     case 5:
-      return { tag: "ToRivetWebSocketMessageAck", val: readToRivetWebSocketMessageAck(bc) };
+      return { tag: "ToRivetWebSocketOpen", val: readToRivetWebSocketOpen(bc) };
     case 6:
+      return { tag: "ToRivetWebSocketMessage", val: readToRivetWebSocketMessage(bc) };
+    case 7:
+      return { tag: "ToRivetWebSocketMessageAck", val: readToRivetWebSocketMessageAck(bc) };
+    case 8:
       return { tag: "ToRivetWebSocketClose", val: readToRivetWebSocketClose(bc) };
     default: {
       bc.offset = offset;
@@ -1574,25 +1941,35 @@ function writeToRivetTunnelMessageKind(bc, x) {
     }
     case "ToRivetResponseAbort": {
       bare.writeU8(bc, 2);
+      writeToRivetResponseAbort(bc, x.val);
       break;
     }
-    case "ToRivetWebSocketOpen": {
+    case "ToRivetRequestBodyWindowUpdate": {
       bare.writeU8(bc, 3);
+      writeToRivetRequestBodyWindowUpdate(bc, x.val);
+      break;
+    }
+    case "ToRivetRequestBodyCancel": {
+      bare.writeU8(bc, 4);
+      break;
+    }
+    case "ToRivetWebSocketOpen": {
+      bare.writeU8(bc, 5);
       writeToRivetWebSocketOpen(bc, x.val);
       break;
     }
     case "ToRivetWebSocketMessage": {
-      bare.writeU8(bc, 4);
+      bare.writeU8(bc, 6);
       writeToRivetWebSocketMessage(bc, x.val);
       break;
     }
     case "ToRivetWebSocketMessageAck": {
-      bare.writeU8(bc, 5);
+      bare.writeU8(bc, 7);
       writeToRivetWebSocketMessageAck(bc, x.val);
       break;
     }
     case "ToRivetWebSocketClose": {
-      bare.writeU8(bc, 6);
+      bare.writeU8(bc, 8);
       writeToRivetWebSocketClose(bc, x.val);
       break;
     }
@@ -1617,12 +1994,16 @@ function readToEnvoyTunnelMessageKind(bc) {
     case 1:
       return { tag: "ToEnvoyRequestChunk", val: readToEnvoyRequestChunk(bc) };
     case 2:
-      return { tag: "ToEnvoyRequestAbort", val: null };
+      return { tag: "ToEnvoyRequestAbort", val: readToEnvoyRequestAbort(bc) };
     case 3:
-      return { tag: "ToEnvoyWebSocketOpen", val: readToEnvoyWebSocketOpen(bc) };
+      return { tag: "ToEnvoyRequestBodyCancel", val: null };
     case 4:
-      return { tag: "ToEnvoyWebSocketMessage", val: readToEnvoyWebSocketMessage(bc) };
+      return { tag: "ToEnvoyResponseBodyWindowUpdate", val: readToEnvoyResponseBodyWindowUpdate(bc) };
     case 5:
+      return { tag: "ToEnvoyWebSocketOpen", val: readToEnvoyWebSocketOpen(bc) };
+    case 6:
+      return { tag: "ToEnvoyWebSocketMessage", val: readToEnvoyWebSocketMessage(bc) };
+    case 7:
       return { tag: "ToEnvoyWebSocketClose", val: readToEnvoyWebSocketClose(bc) };
     default: {
       bc.offset = offset;
@@ -1644,20 +2025,30 @@ function writeToEnvoyTunnelMessageKind(bc, x) {
     }
     case "ToEnvoyRequestAbort": {
       bare.writeU8(bc, 2);
+      writeToEnvoyRequestAbort(bc, x.val);
       break;
     }
-    case "ToEnvoyWebSocketOpen": {
+    case "ToEnvoyRequestBodyCancel": {
       bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToEnvoyResponseBodyWindowUpdate": {
+      bare.writeU8(bc, 4);
+      writeToEnvoyResponseBodyWindowUpdate(bc, x.val);
+      break;
+    }
+    case "ToEnvoyWebSocketOpen": {
+      bare.writeU8(bc, 5);
       writeToEnvoyWebSocketOpen(bc, x.val);
       break;
     }
     case "ToEnvoyWebSocketMessage": {
-      bare.writeU8(bc, 4);
+      bare.writeU8(bc, 6);
       writeToEnvoyWebSocketMessage(bc, x.val);
       break;
     }
     case "ToEnvoyWebSocketClose": {
-      bare.writeU8(bc, 5);
+      bare.writeU8(bc, 7);
       writeToEnvoyWebSocketClose(bc, x.val);
       break;
     }
@@ -1681,7 +2072,7 @@ function readToEnvoyPing(bc) {
 function writeToEnvoyPing(bc, x) {
   bare.writeI64(bc, x.ts);
 }
-function read22(bc) {
+function read26(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1695,26 +2086,26 @@ function read22(bc) {
   }
   return result;
 }
-function write22(bc, x) {
+function write26(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
     writeActorName(bc, kv[1]);
   }
 }
-function read23(bc) {
-  return bare.readBool(bc) ? read22(bc) : null;
+function read27(bc) {
+  return bare.readBool(bc) ? read26(bc) : null;
 }
-function write23(bc, x) {
+function write27(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
-    write22(bc, x);
+    write26(bc, x);
   }
 }
-function read24(bc) {
+function read28(bc) {
   return bare.readBool(bc) ? readJson(bc) : null;
 }
-function write24(bc, x) {
+function write28(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeJson(bc, x);
@@ -1722,13 +2113,13 @@ function write24(bc, x) {
 }
 function readToRivetMetadata(bc) {
   return {
-    prepopulateActorNames: read23(bc),
-    metadata: read24(bc)
+    prepopulateActorNames: read27(bc),
+    metadata: read28(bc)
   };
 }
 function writeToRivetMetadata(bc, x) {
-  write23(bc, x.prepopulateActorNames);
-  write24(bc, x.metadata);
+  write27(bc, x.prepopulateActorNames);
+  write28(bc, x.metadata);
 }
 function readToRivetEvents(bc) {
   const len = bare.readUintSafe(bc);
@@ -1747,7 +2138,7 @@ function writeToRivetEvents(bc, x) {
     writeEventWrapper(bc, x[i]);
   }
 }
-function read25(bc) {
+function read29(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1758,7 +2149,7 @@ function read25(bc) {
   }
   return result;
 }
-function write25(bc, x) {
+function write29(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeActorCheckpoint(bc, x[i]);
@@ -1766,11 +2157,11 @@ function write25(bc, x) {
 }
 function readToRivetAckCommands(bc) {
   return {
-    lastCommandCheckpoints: read25(bc)
+    lastCommandCheckpoints: read29(bc)
   };
 }
 function writeToRivetAckCommands(bc, x) {
-  write25(bc, x.lastCommandCheckpoints);
+  write29(bc, x.lastCommandCheckpoints);
 }
 function readToRivetPong(bc) {
   return {
@@ -1812,6 +2203,36 @@ function writeToRivetSqliteCommitRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteCommitRequest(bc, x.data);
 }
+function readToRivetSqliteCommitStageBeginRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageBeginRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitStageBeginRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageBeginRequest(bc, x.data);
+}
+function readToRivetSqliteCommitStageSegmentRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageSegmentRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitStageSegmentRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageSegmentRequest(bc, x.data);
+}
+function readToRivetSqliteCommitFinalizeRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitFinalizeRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitFinalizeRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitFinalizeRequest(bc, x.data);
+}
 function readToRivetSqliteExecRequest(bc) {
   return {
     requestId: bare.readU32(bc),
@@ -1832,6 +2253,16 @@ function writeToRivetSqliteExecuteRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteExecuteRequest(bc, x.data);
 }
+function readToRivetSqliteExecuteBatchRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteBatchRequest(bc)
+  };
+}
+function writeToRivetSqliteExecuteBatchRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteBatchRequest(bc, x.data);
+}
 function readToRivet(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -1855,9 +2286,17 @@ function readToRivet(bc) {
     case 8:
       return { tag: "ToRivetSqliteCommitRequest", val: readToRivetSqliteCommitRequest(bc) };
     case 9:
-      return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) };
+      return { tag: "ToRivetSqliteCommitStageBeginRequest", val: readToRivetSqliteCommitStageBeginRequest(bc) };
     case 10:
+      return { tag: "ToRivetSqliteCommitStageSegmentRequest", val: readToRivetSqliteCommitStageSegmentRequest(bc) };
+    case 11:
+      return { tag: "ToRivetSqliteCommitFinalizeRequest", val: readToRivetSqliteCommitFinalizeRequest(bc) };
+    case 12:
+      return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) };
+    case 13:
       return { tag: "ToRivetSqliteExecuteRequest", val: readToRivetSqliteExecuteRequest(bc) };
+    case 14:
+      return { tag: "ToRivetSqliteExecuteBatchRequest", val: readToRivetSqliteExecuteBatchRequest(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -1910,16 +2349,36 @@ function writeToRivet(bc, x) {
       writeToRivetSqliteCommitRequest(bc, x.val);
       break;
     }
-    case "ToRivetSqliteExecRequest": {
+    case "ToRivetSqliteCommitStageBeginRequest": {
       bare.writeU8(bc, 9);
+      writeToRivetSqliteCommitStageBeginRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitStageSegmentRequest": {
+      bare.writeU8(bc, 10);
+      writeToRivetSqliteCommitStageSegmentRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitFinalizeRequest": {
+      bare.writeU8(bc, 11);
+      writeToRivetSqliteCommitFinalizeRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecRequest": {
+      bare.writeU8(bc, 12);
       writeToRivetSqliteExecRequest(bc, x.val);
       break;
     }
     case "ToRivetSqliteExecuteRequest": {
-      bare.writeU8(bc, 10);
+      bare.writeU8(bc, 13);
       writeToRivetSqliteExecuteRequest(bc, x.val);
       break;
     }
+    case "ToRivetSqliteExecuteBatchRequest": {
+      bare.writeU8(bc, 14);
+      writeToRivetSqliteExecuteBatchRequest(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToRivet(x, config) {
@@ -1978,11 +2437,11 @@ function writeToEnvoyCommands(bc, x) {
 }
 function readToEnvoyAckEvents(bc) {
   return {
-    lastEventCheckpoints: read25(bc)
+    lastEventCheckpoints: read29(bc)
   };
 }
 function writeToEnvoyAckEvents(bc, x) {
-  write25(bc, x.lastEventCheckpoints);
+  write29(bc, x.lastEventCheckpoints);
 }
 function readToEnvoyKvResponse(bc) {
   return {
@@ -2014,6 +2473,36 @@ function writeToEnvoySqliteCommitResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteCommitResponse(bc, x.data);
 }
+function readToEnvoySqliteCommitStageBeginResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageBeginResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitStageBeginResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageBeginResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitStageSegmentResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageSegmentResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitStageSegmentResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageSegmentResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitFinalizeResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitFinalizeResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitFinalizeResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitFinalizeResponse(bc, x.data);
+}
 function readToEnvoySqliteExecResponse(bc) {
   return {
     requestId: bare.readU32(bc),
@@ -2034,6 +2523,16 @@ function writeToEnvoySqliteExecuteResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteExecuteResponse(bc, x.data);
 }
+function readToEnvoySqliteExecuteBatchResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteBatchResponse(bc)
+  };
+}
+function writeToEnvoySqliteExecuteBatchResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteBatchResponse(bc, x.data);
+}
 function readToEnvoy(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -2055,9 +2554,17 @@ function readToEnvoy(bc) {
     case 7:
       return { tag: "ToEnvoySqliteCommitResponse", val: readToEnvoySqliteCommitResponse(bc) };
     case 8:
-      return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) };
+      return { tag: "ToEnvoySqliteCommitStageBeginResponse", val: readToEnvoySqliteCommitStageBeginResponse(bc) };
     case 9:
+      return { tag: "ToEnvoySqliteCommitStageSegmentResponse", val: readToEnvoySqliteCommitStageSegmentResponse(bc) };
+    case 10:
+      return { tag: "ToEnvoySqliteCommitFinalizeResponse", val: readToEnvoySqliteCommitFinalizeResponse(bc) };
+    case 11:
+      return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) };
+    case 12:
       return { tag: "ToEnvoySqliteExecuteResponse", val: readToEnvoySqliteExecuteResponse(bc) };
+    case 13:
+      return { tag: "ToEnvoySqliteExecuteBatchResponse", val: readToEnvoySqliteExecuteBatchResponse(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -2106,16 +2613,36 @@ function writeToEnvoy(bc, x) {
       writeToEnvoySqliteCommitResponse(bc, x.val);
       break;
     }
-    case "ToEnvoySqliteExecResponse": {
+    case "ToEnvoySqliteCommitStageBeginResponse": {
       bare.writeU8(bc, 8);
+      writeToEnvoySqliteCommitStageBeginResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitStageSegmentResponse": {
+      bare.writeU8(bc, 9);
+      writeToEnvoySqliteCommitStageSegmentResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitFinalizeResponse": {
+      bare.writeU8(bc, 10);
+      writeToEnvoySqliteCommitFinalizeResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecResponse": {
+      bare.writeU8(bc, 11);
       writeToEnvoySqliteExecResponse(bc, x.val);
       break;
     }
     case "ToEnvoySqliteExecuteResponse": {
-      bare.writeU8(bc, 9);
+      bare.writeU8(bc, 12);
       writeToEnvoySqliteExecuteResponse(bc, x.val);
       break;
     }
+    case "ToEnvoySqliteExecuteBatchResponse": {
+      bare.writeU8(bc, 13);
+      writeToEnvoySqliteExecuteBatchResponse(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToEnvoy(x, config) {
@@ -2322,8 +2849,9 @@ function decodeToOutbound(bytes) {
 function assert(condition, message) {
   if (!condition) throw new Error(message ?? "Assertion failed");
 }
-var VERSION = 5;
+var VERSION = 8;
 export {
+  HttpStreamAbortReasonKind,
   StopActorReason,
   StopCode,
   VERSION,
@@ -2357,6 +2885,8 @@ export {
   readEventWrapper,
   readGatewayId,
   readHibernatingRequest,
+  readHttpStreamAbortReason,
+  readHttpStreamAbortReasonKind,
   readId,
   readJson,
   readKvDeleteRangeRequest,
@@ -2381,16 +2911,29 @@ export {
   readPreloadedKvEntry,
   readProtocolMetadata,
   readRequestId,
+  readSqliteBatchStatement,
   readSqliteBindParam,
   readSqliteColumnValue,
+  readSqliteCommitFinalizeOk,
+  readSqliteCommitFinalizeRequest,
+  readSqliteCommitFinalizeResponse,
   readSqliteCommitOk,
   readSqliteCommitRequest,
   readSqliteCommitResponse,
+  readSqliteCommitStageBeginOk,
+  readSqliteCommitStageBeginRequest,
+  readSqliteCommitStageBeginResponse,
+  readSqliteCommitStageSegmentOk,
+  readSqliteCommitStageSegmentRequest,
+  readSqliteCommitStageSegmentResponse,
   readSqliteDirtyPage,
   readSqliteErrorResponse,
   readSqliteExecOk,
   readSqliteExecRequest,
   readSqliteExecResponse,
+  readSqliteExecuteBatchOk,
+  readSqliteExecuteBatchRequest,
+  readSqliteExecuteBatchResponse,
   readSqliteExecuteOk,
   readSqliteExecuteRequest,
   readSqliteExecuteResponse,
@@ -2417,10 +2960,16 @@ export {
   readToEnvoyInit,
   readToEnvoyKvResponse,
   readToEnvoyPing,
+  readToEnvoyRequestAbort,
   readToEnvoyRequestChunk,
   readToEnvoyRequestStart,
+  readToEnvoyResponseBodyWindowUpdate,
+  readToEnvoySqliteCommitFinalizeResponse,
   readToEnvoySqliteCommitResponse,
+  readToEnvoySqliteCommitStageBeginResponse,
+  readToEnvoySqliteCommitStageSegmentResponse,
   readToEnvoySqliteExecResponse,
+  readToEnvoySqliteExecuteBatchResponse,
   readToEnvoySqliteExecuteResponse,
   readToEnvoySqliteGetPagesResponse,
   readToEnvoyTunnelMessage,
@@ -2438,10 +2987,16 @@ export {
   readToRivetKvRequest,
   readToRivetMetadata,
   readToRivetPong,
+  readToRivetRequestBodyWindowUpdate,
+  readToRivetResponseAbort,
   readToRivetResponseChunk,
   readToRivetResponseStart,
+  readToRivetSqliteCommitFinalizeRequest,
   readToRivetSqliteCommitRequest,
+  readToRivetSqliteCommitStageBeginRequest,
+  readToRivetSqliteCommitStageSegmentRequest,
   readToRivetSqliteExecRequest,
+  readToRivetSqliteExecuteBatchRequest,
   readToRivetSqliteExecuteRequest,
   readToRivetSqliteGetPagesRequest,
   readToRivetTunnelMessage,
@@ -2468,6 +3023,8 @@ export {
   writeEventWrapper,
   writeGatewayId,
   writeHibernatingRequest,
+  writeHttpStreamAbortReason,
+  writeHttpStreamAbortReasonKind,
   writeId,
   writeJson,
   writeKvDeleteRangeRequest,
@@ -2492,16 +3049,29 @@ export {
   writePreloadedKvEntry,
   writeProtocolMetadata,
   writeRequestId,
+  writeSqliteBatchStatement,
   writeSqliteBindParam,
   writeSqliteColumnValue,
+  writeSqliteCommitFinalizeOk,
+  writeSqliteCommitFinalizeRequest,
+  writeSqliteCommitFinalizeResponse,
   writeSqliteCommitOk,
   writeSqliteCommitRequest,
   writeSqliteCommitResponse,
+  writeSqliteCommitStageBeginOk,
+  writeSqliteCommitStageBeginRequest,
+  writeSqliteCommitStageBeginResponse,
+  writeSqliteCommitStageSegmentOk,
+  writeSqliteCommitStageSegmentRequest,
+  writeSqliteCommitStageSegmentResponse,
   writeSqliteDirtyPage,
   writeSqliteErrorResponse,
   writeSqliteExecOk,
   writeSqliteExecRequest,
   writeSqliteExecResponse,
+  writeSqliteExecuteBatchOk,
+  writeSqliteExecuteBatchRequest,
+  writeSqliteExecuteBatchResponse,
   writeSqliteExecuteOk,
   writeSqliteExecuteRequest,
   writeSqliteExecuteResponse,
@@ -2528,10 +3098,16 @@ export {
   writeToEnvoyInit,
   writeToEnvoyKvResponse,
   writeToEnvoyPing,
+  writeToEnvoyRequestAbort,
   writeToEnvoyRequestChunk,
   writeToEnvoyRequestStart,
+  writeToEnvoyResponseBodyWindowUpdate,
+  writeToEnvoySqliteCommitFinalizeResponse,
   writeToEnvoySqliteCommitResponse,
+  writeToEnvoySqliteCommitStageBeginResponse,
+  writeToEnvoySqliteCommitStageSegmentResponse,
   writeToEnvoySqliteExecResponse,
+  writeToEnvoySqliteExecuteBatchResponse,
   writeToEnvoySqliteExecuteResponse,
   writeToEnvoySqliteGetPagesResponse,
   writeToEnvoyTunnelMessage,
@@ -2549,10 +3125,16 @@ export {
   writeToRivetKvRequest,
   writeToRivetMetadata,
   writeToRivetPong,
+  writeToRivetRequestBodyWindowUpdate,
+  writeToRivetResponseAbort,
   writeToRivetResponseChunk,
   writeToRivetResponseStart,
+  writeToRivetSqliteCommitFinalizeRequest,
   writeToRivetSqliteCommitRequest,
+  writeToRivetSqliteCommitStageBeginRequest,
+  writeToRivetSqliteCommitStageSegmentRequest,
   writeToRivetSqliteExecRequest,
+  writeToRivetSqliteExecuteBatchRequest,
   writeToRivetSqliteExecuteRequest,
   writeToRivetSqliteGetPagesRequest,
   writeToRivetTunnelMessage,