@rivetkit/engine-envoy-protocol 0.0.0-main.41efcce → 0.0.0-main.4994268

package/dist/index.js

@@ -366,28 +366,16 @@ function writeKvResponseData(bc, x) {
     }
   }
 }
-function readSqliteGeneration(bc) {
-  return bare.readU64(bc);
-}
-function writeSqliteGeneration(bc, x) {
-  bare.writeU64(bc, x);
-}
-function readSqliteTxid(bc) {
-  return bare.readU64(bc);
-}
-function writeSqliteTxid(bc, x) {
-  bare.writeU64(bc, x);
-}
 function readSqlitePgno(bc) {
   return bare.readU32(bc);
 }
 function writeSqlitePgno(bc, x) {
   bare.writeU32(bc, x);
 }
-function readSqliteStageId(bc) {
+function readSqliteGeneration(bc) {
   return bare.readU64(bc);
 }
-function writeSqliteStageId(bc, x) {
+function writeSqliteGeneration(bc, x) {
   bare.writeU64(bc, x);
 }
 function readSqlitePageBytes(bc) {
@@ -396,36 +384,6 @@ function readSqlitePageBytes(bc) {
 function writeSqlitePageBytes(bc, x) {
   bare.writeData(bc, x);
 }
-function readSqliteMeta(bc) {
-  return {
-    generation: readSqliteGeneration(bc),
-    headTxid: readSqliteTxid(bc),
-    materializedTxid: readSqliteTxid(bc),
-    dbSizePages: bare.readU32(bc),
-    pageSize: bare.readU32(bc),
-    creationTsMs: bare.readI64(bc),
-    maxDeltaBytes: bare.readU64(bc)
-  };
-}
-function writeSqliteMeta(bc, x) {
-  writeSqliteGeneration(bc, x.generation);
-  writeSqliteTxid(bc, x.headTxid);
-  writeSqliteTxid(bc, x.materializedTxid);
-  bare.writeU32(bc, x.dbSizePages);
-  bare.writeU32(bc, x.pageSize);
-  bare.writeI64(bc, x.creationTsMs);
-  bare.writeU64(bc, x.maxDeltaBytes);
-}
-function readSqliteFenceMismatch(bc) {
-  return {
-    actualMeta: readSqliteMeta(bc),
-    reason: bare.readString(bc)
-  };
-}
-function writeSqliteFenceMismatch(bc, x) {
-  writeSqliteMeta(bc, x.actualMeta);
-  bare.writeString(bc, x.reason);
-}
 function readSqliteDirtyPage(bc) {
   return {
     pgno: readSqlitePgno(bc),
@@ -475,14 +433,16 @@ function write6(bc, x) {
 function readSqliteGetPagesRequest(bc) {
   return {
     actorId: readId(bc),
-    generation: readSqliteGeneration(bc),
-    pgnos: read6(bc)
+    pgnos: read6(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
   };
 }
 function writeSqliteGetPagesRequest(bc, x) {
   writeId(bc, x.actorId);
-  writeSqliteGeneration(bc, x.generation);
   write6(bc, x.pgnos);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
 }
 function read7(bc) {
   const len = bare.readUintSafe(bc);
@@ -504,19 +464,23 @@ function write7(bc, x) {
 function readSqliteGetPagesOk(bc) {
   return {
     pages: read7(bc),
-    meta: readSqliteMeta(bc)
+    headTxid: read2(bc)
   };
 }
 function writeSqliteGetPagesOk(bc, x) {
   write7(bc, x.pages);
-  writeSqliteMeta(bc, x.meta);
+  write2(bc, x.headTxid);
 }
 function readSqliteErrorResponse(bc) {
   return {
+    group: bare.readString(bc),
+    code: bare.readString(bc),
     message: bare.readString(bc)
   };
 }
 function writeSqliteErrorResponse(bc, x) {
+  bare.writeString(bc, x.group);
+  bare.writeString(bc, x.code);
   bare.writeString(bc, x.message);
 }
 function readSqliteGetPagesResponse(bc) {
@@ -526,8 +490,6 @@ function readSqliteGetPagesResponse(bc) {
     case 0:
       return { tag: "SqliteGetPagesOk", val: readSqliteGetPagesOk(bc) };
     case 1:
-      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
-    case 2:
       return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
     default: {
       bc.offset = offset;
@@ -542,13 +504,8 @@ function writeSqliteGetPagesResponse(bc, x) {
       writeSqliteGetPagesOk(bc, x.val);
       break;
     }
-    case "SqliteFenceMismatch": {
-      bare.writeU8(bc, 1);
-      writeSqliteFenceMismatch(bc, x.val);
-      break;
-    }
     case "SqliteErrorResponse": {
-      bare.writeU8(bc, 2);
+      bare.writeU8(bc, 1);
       writeSqliteErrorResponse(bc, x.val);
       break;
     }
@@ -574,38 +531,28 @@ function write8(bc, x) {
 function readSqliteCommitRequest(bc) {
   return {
     actorId: readId(bc),
-    generation: readSqliteGeneration(bc),
-    expectedHeadTxid: readSqliteTxid(bc),
     dirtyPages: read8(bc),
-    newDbSizePages: bare.readU32(bc)
+    dbSizePages: bare.readU32(bc),
+    nowMs: bare.readI64(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
   };
 }
 function writeSqliteCommitRequest(bc, x) {
   writeId(bc, x.actorId);
-  writeSqliteGeneration(bc, x.generation);
-  writeSqliteTxid(bc, x.expectedHeadTxid);
   write8(bc, x.dirtyPages);
-  bare.writeU32(bc, x.newDbSizePages);
+  bare.writeU32(bc, x.dbSizePages);
+  bare.writeI64(bc, x.nowMs);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
 }
 function readSqliteCommitOk(bc) {
   return {
-    newHeadTxid: readSqliteTxid(bc),
-    meta: readSqliteMeta(bc)
+    headTxid: read2(bc)
   };
 }
 function writeSqliteCommitOk(bc, x) {
-  writeSqliteTxid(bc, x.newHeadTxid);
-  writeSqliteMeta(bc, x.meta);
-}
-function readSqliteCommitTooLarge(bc) {
-  return {
-    actualSizeBytes: bare.readU64(bc),
-    maxSizeBytes: bare.readU64(bc)
-  };
-}
-function writeSqliteCommitTooLarge(bc, x) {
-  bare.writeU64(bc, x.actualSizeBytes);
-  bare.writeU64(bc, x.maxSizeBytes);
+  write2(bc, x.headTxid);
 }
 function readSqliteCommitResponse(bc) {
   const offset = bc.offset;
@@ -614,10 +561,6 @@ function readSqliteCommitResponse(bc) {
     case 0:
       return { tag: "SqliteCommitOk", val: readSqliteCommitOk(bc) };
     case 1:
-      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
-    case 2:
-      return { tag: "SqliteCommitTooLarge", val: readSqliteCommitTooLarge(bc) };
-    case 3:
       return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
     default: {
       bc.offset = offset;
@@ -632,182 +575,373 @@ function writeSqliteCommitResponse(bc, x) {
       writeSqliteCommitOk(bc, x.val);
       break;
     }
-    case "SqliteFenceMismatch": {
-      bare.writeU8(bc, 1);
-      writeSqliteFenceMismatch(bc, x.val);
-      break;
-    }
-    case "SqliteCommitTooLarge": {
-      bare.writeU8(bc, 2);
-      writeSqliteCommitTooLarge(bc, x.val);
-      break;
-    }
     case "SqliteErrorResponse": {
-      bare.writeU8(bc, 3);
+      bare.writeU8(bc, 1);
       writeSqliteErrorResponse(bc, x.val);
       break;
     }
   }
 }
-function readSqliteCommitStageBeginRequest(bc) {
+function readSqliteValueInteger(bc) {
   return {
-    actorId: readId(bc),
-    generation: readSqliteGeneration(bc)
+    value: bare.readI64(bc)
   };
 }
-function writeSqliteCommitStageBeginRequest(bc, x) {
-  writeId(bc, x.actorId);
-  writeSqliteGeneration(bc, x.generation);
+function writeSqliteValueInteger(bc, x) {
+  bare.writeI64(bc, x.value);
+}
+function readSqliteValueFloat(bc) {
+  return {
+    value: bare.readFixedData(bc, 8)
+  };
+}
+function writeSqliteValueFloat(bc, x) {
+  {
+    assert(x.value.byteLength === 8);
+    bare.writeFixedData(bc, x.value);
+  }
+}
+function readSqliteValueText(bc) {
+  return {
+    value: bare.readString(bc)
+  };
+}
+function writeSqliteValueText(bc, x) {
+  bare.writeString(bc, x.value);
 }
-function readSqliteCommitStageBeginOk(bc) {
+function readSqliteValueBlob(bc) {
   return {
-    txid: readSqliteTxid(bc)
+    value: bare.readData(bc)
   };
 }
-function writeSqliteCommitStageBeginOk(bc, x) {
-  writeSqliteTxid(bc, x.txid);
+function writeSqliteValueBlob(bc, x) {
+  bare.writeData(bc, x.value);
 }
-function readSqliteCommitStageBeginResponse(bc) {
+function readSqliteBindParam(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "SqliteCommitStageBeginOk", val: readSqliteCommitStageBeginOk(bc) };
+      return { tag: "SqliteValueNull", val: null };
     case 1:
-      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+      return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) };
     case 2:
-      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+      return { tag: "SqliteValueFloat", val: readSqliteValueFloat(bc) };
+    case 3:
+      return { tag: "SqliteValueText", val: readSqliteValueText(bc) };
+    case 4:
+      return { tag: "SqliteValueBlob", val: readSqliteValueBlob(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeSqliteCommitStageBeginResponse(bc, x) {
+function writeSqliteBindParam(bc, x) {
   switch (x.tag) {
-    case "SqliteCommitStageBeginOk": {
+    case "SqliteValueNull": {
       bare.writeU8(bc, 0);
-      writeSqliteCommitStageBeginOk(bc, x.val);
       break;
     }
-    case "SqliteFenceMismatch": {
+    case "SqliteValueInteger": {
       bare.writeU8(bc, 1);
-      writeSqliteFenceMismatch(bc, x.val);
+      writeSqliteValueInteger(bc, x.val);
       break;
     }
-    case "SqliteErrorResponse": {
+    case "SqliteValueFloat": {
       bare.writeU8(bc, 2);
-      writeSqliteErrorResponse(bc, x.val);
+      writeSqliteValueFloat(bc, x.val);
+      break;
+    }
+    case "SqliteValueText": {
+      bare.writeU8(bc, 3);
+      writeSqliteValueText(bc, x.val);
+      break;
+    }
+    case "SqliteValueBlob": {
+      bare.writeU8(bc, 4);
+      writeSqliteValueBlob(bc, x.val);
       break;
     }
   }
 }
-function readSqliteCommitStageRequest(bc) {
-  return {
-    actorId: readId(bc),
-    generation: readSqliteGeneration(bc),
-    txid: readSqliteTxid(bc),
-    chunkIdx: bare.readU32(bc),
-    bytes: bare.readData(bc),
-    isLast: bare.readBool(bc)
-  };
-}
-function writeSqliteCommitStageRequest(bc, x) {
-  writeId(bc, x.actorId);
-  writeSqliteGeneration(bc, x.generation);
-  writeSqliteTxid(bc, x.txid);
-  bare.writeU32(bc, x.chunkIdx);
-  bare.writeData(bc, x.bytes);
-  bare.writeBool(bc, x.isLast);
-}
-function readSqliteCommitStageOk(bc) {
-  return {
-    chunkIdxCommitted: bare.readU32(bc)
-  };
-}
-function writeSqliteCommitStageOk(bc, x) {
-  bare.writeU32(bc, x.chunkIdxCommitted);
-}
-function readSqliteCommitStageResponse(bc) {
+function readSqliteColumnValue(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
   switch (tag) {
     case 0:
-      return { tag: "SqliteCommitStageOk", val: readSqliteCommitStageOk(bc) };
+      return { tag: "SqliteValueNull", val: null };
     case 1:
-      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+      return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) };
     case 2:
-      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+      return { tag: "SqliteValueFloat", val: readSqliteValueFloat(bc) };
+    case 3:
+      return { tag: "SqliteValueText", val: readSqliteValueText(bc) };
+    case 4:
+      return { tag: "SqliteValueBlob", val: readSqliteValueBlob(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
     }
   }
 }
-function writeSqliteCommitStageResponse(bc, x) {
+function writeSqliteColumnValue(bc, x) {
   switch (x.tag) {
-    case "SqliteCommitStageOk": {
+    case "SqliteValueNull": {
       bare.writeU8(bc, 0);
-      writeSqliteCommitStageOk(bc, x.val);
       break;
     }
-    case "SqliteFenceMismatch": {
+    case "SqliteValueInteger": {
       bare.writeU8(bc, 1);
-      writeSqliteFenceMismatch(bc, x.val);
+      writeSqliteValueInteger(bc, x.val);
       break;
     }
-    case "SqliteErrorResponse": {
+    case "SqliteValueFloat": {
       bare.writeU8(bc, 2);
-      writeSqliteErrorResponse(bc, x.val);
+      writeSqliteValueFloat(bc, x.val);
+      break;
+    }
+    case "SqliteValueText": {
+      bare.writeU8(bc, 3);
+      writeSqliteValueText(bc, x.val);
+      break;
+    }
+    case "SqliteValueBlob": {
+      bare.writeU8(bc, 4);
+      writeSqliteValueBlob(bc, x.val);
       break;
     }
   }
 }
-function readSqliteCommitFinalizeRequest(bc) {
+function read9(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare.readString(bc);
+  }
+  return result;
+}
+function write9(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare.writeString(bc, x[i]);
+  }
+}
+function read10(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteColumnValue(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteColumnValue(bc);
+  }
+  return result;
+}
+function write10(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteColumnValue(bc, x[i]);
+  }
+}
+function read11(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [read10(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = read10(bc);
+  }
+  return result;
+}
+function write11(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    write10(bc, x[i]);
+  }
+}
+function readSqliteQueryResult(bc) {
+  return {
+    columns: read9(bc),
+    rows: read11(bc)
+  };
+}
+function writeSqliteQueryResult(bc, x) {
+  write9(bc, x.columns);
+  write11(bc, x.rows);
+}
+function read12(bc) {
+  return bare.readBool(bc) ? bare.readI64(bc) : null;
+}
+function write12(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeI64(bc, x);
+  }
+}
+function readSqliteExecuteResult(bc) {
   return {
+    columns: read9(bc),
+    rows: read11(bc),
+    changes: bare.readI64(bc),
+    lastInsertRowId: read12(bc)
+  };
+}
+function writeSqliteExecuteResult(bc, x) {
+  write9(bc, x.columns);
+  write11(bc, x.rows);
+  bare.writeI64(bc, x.changes);
+  write12(bc, x.lastInsertRowId);
+}
+function readSqliteExecRequest(bc) {
+  return {
+    namespaceId: readId(bc),
     actorId: readId(bc),
     generation: readSqliteGeneration(bc),
-    expectedHeadTxid: readSqliteTxid(bc),
-    txid: readSqliteTxid(bc),
-    newDbSizePages: bare.readU32(bc)
+    sql: bare.readString(bc)
   };
 }
-function writeSqliteCommitFinalizeRequest(bc, x) {
+function writeSqliteExecRequest(bc, x) {
+  writeId(bc, x.namespaceId);
   writeId(bc, x.actorId);
   writeSqliteGeneration(bc, x.generation);
-  writeSqliteTxid(bc, x.expectedHeadTxid);
-  writeSqliteTxid(bc, x.txid);
-  bare.writeU32(bc, x.newDbSizePages);
+  bare.writeString(bc, x.sql);
 }
-function readSqliteCommitFinalizeOk(bc) {
+function read13(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteBindParam(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteBindParam(bc);
+  }
+  return result;
+}
+function write13(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteBindParam(bc, x[i]);
+  }
+}
+function read14(bc) {
+  return bare.readBool(bc) ? read13(bc) : null;
+}
+function write14(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    write13(bc, x);
+  }
+}
+function readSqliteExecuteRequest(bc) {
   return {
-    newHeadTxid: readSqliteTxid(bc),
-    meta: readSqliteMeta(bc)
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    sql: bare.readString(bc),
+    params: read14(bc)
   };
 }
-function writeSqliteCommitFinalizeOk(bc, x) {
-  writeSqliteTxid(bc, x.newHeadTxid);
-  writeSqliteMeta(bc, x.meta);
+function writeSqliteExecuteRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  bare.writeString(bc, x.sql);
+  write14(bc, x.params);
 }
-function readSqliteStageNotFound(bc) {
+function readSqliteBatchStatement(bc) {
   return {
-    stageId: readSqliteStageId(bc)
+    sql: bare.readString(bc),
+    params: read14(bc)
   };
 }
-function writeSqliteStageNotFound(bc, x) {
-  writeSqliteStageId(bc, x.stageId);
+function writeSqliteBatchStatement(bc, x) {
+  bare.writeString(bc, x.sql);
+  write14(bc, x.params);
 }
-function readSqliteCommitFinalizeResponse(bc) {
+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)
+  };
+}
+function writeSqliteExecOk(bc, x) {
+  writeSqliteQueryResult(bc, x.result);
+}
+function readSqliteExecuteOk(bc) {
+  return {
+    result: readSqliteExecuteResult(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);
   switch (tag) {
     case 0:
-      return { tag: "SqliteCommitFinalizeOk", val: readSqliteCommitFinalizeOk(bc) };
+      return { tag: "SqliteExecOk", val: readSqliteExecOk(bc) };
     case 1:
-      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
-    case 2:
-      return { tag: "SqliteStageNotFound", val: readSqliteStageNotFound(bc) };
-    case 3:
       return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
     default: {
       bc.offset = offset;
@@ -815,41 +949,75 @@ function readSqliteCommitFinalizeResponse(bc) {
     }
   }
 }
-function writeSqliteCommitFinalizeResponse(bc, x) {
+function writeSqliteExecResponse(bc, x) {
   switch (x.tag) {
-    case "SqliteCommitFinalizeOk": {
+    case "SqliteExecOk": {
       bare.writeU8(bc, 0);
-      writeSqliteCommitFinalizeOk(bc, x.val);
+      writeSqliteExecOk(bc, x.val);
       break;
     }
-    case "SqliteFenceMismatch": {
+    case "SqliteErrorResponse": {
       bare.writeU8(bc, 1);
-      writeSqliteFenceMismatch(bc, x.val);
+      writeSqliteErrorResponse(bc, x.val);
       break;
     }
-    case "SqliteStageNotFound": {
-      bare.writeU8(bc, 2);
-      writeSqliteStageNotFound(bc, x.val);
+  }
+}
+function readSqliteExecuteResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteExecuteOk", val: readSqliteExecuteOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecuteResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteExecuteOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteExecuteOk(bc, x.val);
       break;
     }
     case "SqliteErrorResponse": {
-      bare.writeU8(bc, 3);
+      bare.writeU8(bc, 1);
       writeSqliteErrorResponse(bc, x.val);
       break;
     }
   }
 }
-function readSqliteStartupData(bc) {
-  return {
-    generation: readSqliteGeneration(bc),
-    meta: readSqliteMeta(bc),
-    preloadedPages: read7(bc)
-  };
+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 writeSqliteStartupData(bc, x) {
-  writeSqliteGeneration(bc, x.generation);
-  writeSqliteMeta(bc, x.meta);
-  write7(bc, x.preloadedPages);
+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";
@@ -890,19 +1058,19 @@ function readActorName(bc) {
 function writeActorName(bc, x) {
   writeJson(bc, x.metadata);
 }
-function read9(bc) {
+function read17(bc) {
   return bare.readBool(bc) ? bare.readString(bc) : null;
 }
-function write9(bc, x) {
+function write17(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeString(bc, x);
   }
 }
-function read10(bc) {
+function read18(bc) {
   return bare.readBool(bc) ? bare.readData(bc) : null;
 }
-function write10(bc, x) {
+function write18(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeData(bc, x);
@@ -911,16 +1079,16 @@ function write10(bc, x) {
 function readActorConfig(bc) {
   return {
     name: bare.readString(bc),
-    key: read9(bc),
+    key: read17(bc),
     createTs: bare.readI64(bc),
-    input: read10(bc)
+    input: read18(bc)
   };
 }
 function writeActorConfig(bc, x) {
   bare.writeString(bc, x.name);
-  write9(bc, x.key);
+  write17(bc, x.key);
   bare.writeI64(bc, x.createTs);
-  write10(bc, x.input);
+  write18(bc, x.input);
 }
 function readActorCheckpoint(bc) {
   return {
@@ -963,12 +1131,12 @@ function writeActorIntent(bc, x) {
 function readActorStateStopped(bc) {
   return {
     code: readStopCode(bc),
-    message: read9(bc)
+    message: read17(bc)
   };
 }
 function writeActorStateStopped(bc, x) {
   writeStopCode(bc, x.code);
-  write9(bc, x.message);
+  write17(bc, x.message);
 }
 function readActorState(bc) {
   const offset = bc.offset;
@@ -1013,22 +1181,13 @@ function readEventActorStateUpdate(bc) {
 function writeEventActorStateUpdate(bc, x) {
   writeActorState(bc, x.state);
 }
-function read11(bc) {
-  return bare.readBool(bc) ? bare.readI64(bc) : null;
-}
-function write11(bc, x) {
-  bare.writeBool(bc, x != null);
-  if (x != null) {
-    bare.writeI64(bc, x);
-  }
-}
 function readEventActorSetAlarm(bc) {
   return {
-    alarmTs: read11(bc)
+    alarmTs: read12(bc)
   };
 }
 function writeEventActorSetAlarm(bc, x) {
-  write11(bc, x.alarmTs);
+  write12(bc, x.alarmTs);
 }
 function readEvent(bc) {
   const offset = bc.offset;
@@ -1087,7 +1246,7 @@ function writePreloadedKvEntry(bc, x) {
   writeKvValue(bc, x.value);
   writeKvMetadata(bc, x.metadata);
 }
-function read12(bc) {
+function read19(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1098,7 +1257,7 @@ function read12(bc) {
   }
   return result;
 }
-function write12(bc, x) {
+function write19(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePreloadedKvEntry(bc, x[i]);
@@ -1106,13 +1265,13 @@ function write12(bc, x) {
 }
 function readPreloadedKv(bc) {
   return {
-    entries: read12(bc),
+    entries: read19(bc),
     requestedGetKeys: read0(bc),
     requestedPrefixes: read0(bc)
   };
 }
 function writePreloadedKv(bc, x) {
-  write12(bc, x.entries);
+  write19(bc, x.entries);
   write0(bc, x.requestedGetKeys);
   write0(bc, x.requestedPrefixes);
 }
@@ -1126,7 +1285,7 @@ function writeHibernatingRequest(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
 }
-function read13(bc) {
+function read20(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1137,43 +1296,32 @@ function read13(bc) {
   }
   return result;
 }
-function write13(bc, x) {
+function write20(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeHibernatingRequest(bc, x[i]);
   }
 }
-function read14(bc) {
+function read21(bc) {
   return bare.readBool(bc) ? readPreloadedKv(bc) : null;
 }
-function write14(bc, x) {
+function write21(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writePreloadedKv(bc, x);
   }
 }
-function read15(bc) {
-  return bare.readBool(bc) ? readSqliteStartupData(bc) : null;
-}
-function write15(bc, x) {
-  bare.writeBool(bc, x != null);
-  if (x != null) {
-    writeSqliteStartupData(bc, x);
-  }
-}
 function readCommandStartActor(bc) {
   return {
     config: readActorConfig(bc),
-    hibernatingRequests: read13(bc),
-    preloadedKv: read14(bc),
-    sqliteStartupData: read15(bc)
+    hibernatingRequests: read20(bc),
+    preloadedKv: read21(bc)
   };
 }
 function writeCommandStartActor(bc, x) {
   writeActorConfig(bc, x.config);
-  write13(bc, x.hibernatingRequests);
-  write14(bc, x.preloadedKv);
-  write15(bc, x.sqliteStartupData);
+  write20(bc, x.hibernatingRequests);
+  write21(bc, x.preloadedKv);
 }
 var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
   StopActorReason2["SleepIntent"] = "SleepIntent";
@@ -1330,7 +1478,7 @@ function writeMessageId(bc, x) {
   writeRequestId(bc, x.requestId);
   writeMessageIndex(bc, x.messageIndex);
 }
-function read16(bc) {
+function read22(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1344,7 +1492,7 @@ function read16(bc) {
   }
   return result;
 }
-function write16(bc, x) {
+function write22(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
@@ -1356,41 +1504,143 @@ function readToEnvoyRequestStart(bc) {
     actorId: readId(bc),
     method: bare.readString(bc),
     path: bare.readString(bc),
-    headers: read16(bc),
-    body: read10(bc),
-    stream: bare.readBool(bc)
+    headers: read22(bc),
+    body: read18(bc),
+    stream: bare.readBool(bc),
+    maxBodySize: bare.readU64(bc)
   };
 }
 function writeToEnvoyRequestStart(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.method);
   bare.writeString(bc, x.path);
-  write16(bc, x.headers);
-  write10(bc, x.body);
+  write22(bc, x.headers);
+  write18(bc, x.body);
   bare.writeBool(bc, x.stream);
+  bare.writeU64(bc, x.maxBodySize);
 }
 function readToEnvoyRequestChunk(bc) {
   return {
     body: bare.readData(bc),
-    finish: bare.readBool(bc)
+    finish: bare.readBool(bc),
+    maxBodySize: bare.readU64(bc)
   };
 }
 function writeToEnvoyRequestChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
+  bare.writeU64(bc, x.maxBodySize);
+}
+var HttpStreamAbortReasonKind = /* @__PURE__ */ ((HttpStreamAbortReasonKind2) => {
+  HttpStreamAbortReasonKind2["Unknown"] = "Unknown";
+  HttpStreamAbortReasonKind2["ClientDisconnect"] = "ClientDisconnect";
+  HttpStreamAbortReasonKind2["HandlerError"] = "HandlerError";
+  HttpStreamAbortReasonKind2["IdleTimeout"] = "IdleTimeout";
+  HttpStreamAbortReasonKind2["Overloaded"] = "Overloaded";
+  HttpStreamAbortReasonKind2["BodyTooLarge"] = "BodyTooLarge";
+  HttpStreamAbortReasonKind2["OutOfMemory"] = "OutOfMemory";
+  HttpStreamAbortReasonKind2["Shutdown"] = "Shutdown";
+  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 "ClientDisconnect" /* ClientDisconnect */;
+    case 2:
+      return "HandlerError" /* HandlerError */;
+    case 3:
+      return "IdleTimeout" /* IdleTimeout */;
+    case 4:
+      return "Overloaded" /* Overloaded */;
+    case 5:
+      return "BodyTooLarge" /* BodyTooLarge */;
+    case 6:
+      return "OutOfMemory" /* OutOfMemory */;
+    case 7:
+      return "Shutdown" /* Shutdown */;
+    case 8:
+      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 "ClientDisconnect" /* ClientDisconnect */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "HandlerError" /* HandlerError */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "IdleTimeout" /* IdleTimeout */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "Overloaded" /* Overloaded */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+    case "BodyTooLarge" /* BodyTooLarge */: {
+      bare.writeU8(bc, 5);
+      break;
+    }
+    case "OutOfMemory" /* OutOfMemory */: {
+      bare.writeU8(bc, 6);
+      break;
+    }
+    case "Shutdown" /* Shutdown */: {
+      bare.writeU8(bc, 7);
+      break;
+    }
+    case "InternalError" /* InternalError */: {
+      bare.writeU8(bc, 8);
+      break;
+    }
+  }
+}
+function readHttpStreamAbortReason(bc) {
+  return {
+    kind: readHttpStreamAbortReasonKind(bc),
+    detail: read17(bc)
+  };
+}
+function writeHttpStreamAbortReason(bc, x) {
+  writeHttpStreamAbortReasonKind(bc, x.kind);
+  write17(bc, x.detail);
+}
+function readToEnvoyRequestAbort(bc) {
+  return {
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToEnvoyRequestAbort(bc, x) {
+  writeHttpStreamAbortReason(bc, x.reason);
 }
 function readToRivetResponseStart(bc) {
   return {
     status: bare.readU16(bc),
-    headers: read16(bc),
-    body: read10(bc),
+    headers: read22(bc),
+    body: read18(bc),
     stream: bare.readBool(bc)
   };
 }
 function writeToRivetResponseStart(bc, x) {
   bare.writeU16(bc, x.status);
-  write16(bc, x.headers);
-  write10(bc, x.body);
+  write22(bc, x.headers);
+  write18(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToRivetResponseChunk(bc) {
@@ -1403,17 +1653,25 @@ function writeToRivetResponseChunk(bc, x) {
   bare.writeData(bc, x.body);
   bare.writeBool(bc, x.finish);
 }
+function readToRivetResponseAbort(bc) {
+  return {
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToRivetResponseAbort(bc, x) {
+  writeHttpStreamAbortReason(bc, x.reason);
+}
 function readToEnvoyWebSocketOpen(bc) {
   return {
     actorId: readId(bc),
     path: bare.readString(bc),
-    headers: read16(bc)
+    headers: read22(bc)
   };
 }
 function writeToEnvoyWebSocketOpen(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.path);
-  write16(bc, x.headers);
+  write22(bc, x.headers);
 }
 function readToEnvoyWebSocketMessage(bc) {
   return {
@@ -1425,10 +1683,10 @@ function writeToEnvoyWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function read17(bc) {
+function read23(bc) {
   return bare.readBool(bc) ? bare.readU16(bc) : null;
 }
-function write17(bc, x) {
+function write23(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeU16(bc, x);
@@ -1436,13 +1694,13 @@ function write17(bc, x) {
 }
 function readToEnvoyWebSocketClose(bc) {
   return {
-    code: read17(bc),
-    reason: read9(bc)
+    code: read23(bc),
+    reason: read17(bc)
   };
 }
 function writeToEnvoyWebSocketClose(bc, x) {
-  write17(bc, x.code);
-  write9(bc, x.reason);
+  write23(bc, x.code);
+  write17(bc, x.reason);
 }
 function readToRivetWebSocketOpen(bc) {
   return {
@@ -1472,14 +1730,14 @@ function writeToRivetWebSocketMessageAck(bc, x) {
 }
 function readToRivetWebSocketClose(bc) {
   return {
-    code: read17(bc),
-    reason: read9(bc),
+    code: read23(bc),
+    reason: read17(bc),
     hibernate: bare.readBool(bc)
   };
 }
 function writeToRivetWebSocketClose(bc, x) {
-  write17(bc, x.code);
-  write9(bc, x.reason);
+  write23(bc, x.code);
+  write17(bc, x.reason);
   bare.writeBool(bc, x.hibernate);
 }
 function readToRivetTunnelMessageKind(bc) {
@@ -1491,7 +1749,7 @@ 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) };
     case 4:
@@ -1520,6 +1778,7 @@ function writeToRivetTunnelMessageKind(bc, x) {
     }
     case "ToRivetResponseAbort": {
       bare.writeU8(bc, 2);
+      writeToRivetResponseAbort(bc, x.val);
       break;
     }
     case "ToRivetWebSocketOpen": {
@@ -1563,7 +1822,7 @@ 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) };
     case 4:
@@ -1590,6 +1849,7 @@ function writeToEnvoyTunnelMessageKind(bc, x) {
     }
     case "ToEnvoyRequestAbort": {
       bare.writeU8(bc, 2);
+      writeToEnvoyRequestAbort(bc, x.val);
       break;
     }
     case "ToEnvoyWebSocketOpen": {
@@ -1627,7 +1887,7 @@ function readToEnvoyPing(bc) {
 function writeToEnvoyPing(bc, x) {
   bare.writeI64(bc, x.ts);
 }
-function read18(bc) {
+function read24(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1641,26 +1901,26 @@ function read18(bc) {
   }
   return result;
 }
-function write18(bc, x) {
+function write24(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
     writeActorName(bc, kv[1]);
   }
 }
-function read19(bc) {
-  return bare.readBool(bc) ? read18(bc) : null;
+function read25(bc) {
+  return bare.readBool(bc) ? read24(bc) : null;
 }
-function write19(bc, x) {
+function write25(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
-    write18(bc, x);
+    write24(bc, x);
   }
 }
-function read20(bc) {
+function read26(bc) {
   return bare.readBool(bc) ? readJson(bc) : null;
 }
-function write20(bc, x) {
+function write26(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeJson(bc, x);
@@ -1668,13 +1928,13 @@ function write20(bc, x) {
 }
 function readToRivetMetadata(bc) {
   return {
-    prepopulateActorNames: read19(bc),
-    metadata: read20(bc)
+    prepopulateActorNames: read25(bc),
+    metadata: read26(bc)
   };
 }
 function writeToRivetMetadata(bc, x) {
-  write19(bc, x.prepopulateActorNames);
-  write20(bc, x.metadata);
+  write25(bc, x.prepopulateActorNames);
+  write26(bc, x.metadata);
 }
 function readToRivetEvents(bc) {
   const len = bare.readUintSafe(bc);
@@ -1693,7 +1953,7 @@ function writeToRivetEvents(bc, x) {
     writeEventWrapper(bc, x[i]);
   }
 }
-function read21(bc) {
+function read27(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1704,7 +1964,7 @@ function read21(bc) {
   }
   return result;
 }
-function write21(bc, x) {
+function write27(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeActorCheckpoint(bc, x[i]);
@@ -1712,11 +1972,11 @@ function write21(bc, x) {
 }
 function readToRivetAckCommands(bc) {
   return {
-    lastCommandCheckpoints: read21(bc)
+    lastCommandCheckpoints: read27(bc)
   };
 }
 function writeToRivetAckCommands(bc, x) {
-  write21(bc, x.lastCommandCheckpoints);
+  write27(bc, x.lastCommandCheckpoints);
 }
 function readToRivetPong(bc) {
   return {
@@ -1758,35 +2018,35 @@ function writeToRivetSqliteCommitRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteCommitRequest(bc, x.data);
 }
-function readToRivetSqliteCommitStageBeginRequest(bc) {
+function readToRivetSqliteExecRequest(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitStageBeginRequest(bc)
+    data: readSqliteExecRequest(bc)
   };
 }
-function writeToRivetSqliteCommitStageBeginRequest(bc, x) {
+function writeToRivetSqliteExecRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitStageBeginRequest(bc, x.data);
+  writeSqliteExecRequest(bc, x.data);
 }
-function readToRivetSqliteCommitStageRequest(bc) {
+function readToRivetSqliteExecuteRequest(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitStageRequest(bc)
+    data: readSqliteExecuteRequest(bc)
   };
 }
-function writeToRivetSqliteCommitStageRequest(bc, x) {
+function writeToRivetSqliteExecuteRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitStageRequest(bc, x.data);
+  writeSqliteExecuteRequest(bc, x.data);
 }
-function readToRivetSqliteCommitFinalizeRequest(bc) {
+function readToRivetSqliteExecuteBatchRequest(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitFinalizeRequest(bc)
+    data: readSqliteExecuteBatchRequest(bc)
   };
 }
-function writeToRivetSqliteCommitFinalizeRequest(bc, x) {
+function writeToRivetSqliteExecuteBatchRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitFinalizeRequest(bc, x.data);
+  writeSqliteExecuteBatchRequest(bc, x.data);
 }
 function readToRivet(bc) {
   const offset = bc.offset;
@@ -1811,11 +2071,11 @@ function readToRivet(bc) {
     case 8:
       return { tag: "ToRivetSqliteCommitRequest", val: readToRivetSqliteCommitRequest(bc) };
     case 9:
-      return { tag: "ToRivetSqliteCommitStageBeginRequest", val: readToRivetSqliteCommitStageBeginRequest(bc) };
+      return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) };
     case 10:
-      return { tag: "ToRivetSqliteCommitStageRequest", val: readToRivetSqliteCommitStageRequest(bc) };
+      return { tag: "ToRivetSqliteExecuteRequest", val: readToRivetSqliteExecuteRequest(bc) };
     case 11:
-      return { tag: "ToRivetSqliteCommitFinalizeRequest", val: readToRivetSqliteCommitFinalizeRequest(bc) };
+      return { tag: "ToRivetSqliteExecuteBatchRequest", val: readToRivetSqliteExecuteBatchRequest(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -1868,19 +2128,19 @@ function writeToRivet(bc, x) {
       writeToRivetSqliteCommitRequest(bc, x.val);
       break;
     }
-    case "ToRivetSqliteCommitStageBeginRequest": {
+    case "ToRivetSqliteExecRequest": {
       bare.writeU8(bc, 9);
-      writeToRivetSqliteCommitStageBeginRequest(bc, x.val);
+      writeToRivetSqliteExecRequest(bc, x.val);
       break;
     }
-    case "ToRivetSqliteCommitStageRequest": {
+    case "ToRivetSqliteExecuteRequest": {
       bare.writeU8(bc, 10);
-      writeToRivetSqliteCommitStageRequest(bc, x.val);
+      writeToRivetSqliteExecuteRequest(bc, x.val);
       break;
     }
-    case "ToRivetSqliteCommitFinalizeRequest": {
+    case "ToRivetSqliteExecuteBatchRequest": {
       bare.writeU8(bc, 11);
-      writeToRivetSqliteCommitFinalizeRequest(bc, x.val);
+      writeToRivetSqliteExecuteBatchRequest(bc, x.val);
       break;
     }
   }
@@ -1941,11 +2201,11 @@ function writeToEnvoyCommands(bc, x) {
 }
 function readToEnvoyAckEvents(bc) {
   return {
-    lastEventCheckpoints: read21(bc)
+    lastEventCheckpoints: read27(bc)
   };
 }
 function writeToEnvoyAckEvents(bc, x) {
-  write21(bc, x.lastEventCheckpoints);
+  write27(bc, x.lastEventCheckpoints);
 }
 function readToEnvoyKvResponse(bc) {
   return {
@@ -1977,35 +2237,35 @@ function writeToEnvoySqliteCommitResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqliteCommitResponse(bc, x.data);
 }
-function readToEnvoySqliteCommitStageBeginResponse(bc) {
+function readToEnvoySqliteExecResponse(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitStageBeginResponse(bc)
+    data: readSqliteExecResponse(bc)
   };
 }
-function writeToEnvoySqliteCommitStageBeginResponse(bc, x) {
+function writeToEnvoySqliteExecResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitStageBeginResponse(bc, x.data);
+  writeSqliteExecResponse(bc, x.data);
 }
-function readToEnvoySqliteCommitStageResponse(bc) {
+function readToEnvoySqliteExecuteResponse(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitStageResponse(bc)
+    data: readSqliteExecuteResponse(bc)
   };
 }
-function writeToEnvoySqliteCommitStageResponse(bc, x) {
+function writeToEnvoySqliteExecuteResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitStageResponse(bc, x.data);
+  writeSqliteExecuteResponse(bc, x.data);
 }
-function readToEnvoySqliteCommitFinalizeResponse(bc) {
+function readToEnvoySqliteExecuteBatchResponse(bc) {
   return {
     requestId: bare.readU32(bc),
-    data: readSqliteCommitFinalizeResponse(bc)
+    data: readSqliteExecuteBatchResponse(bc)
   };
 }
-function writeToEnvoySqliteCommitFinalizeResponse(bc, x) {
+function writeToEnvoySqliteExecuteBatchResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
-  writeSqliteCommitFinalizeResponse(bc, x.data);
+  writeSqliteExecuteBatchResponse(bc, x.data);
 }
 function readToEnvoy(bc) {
   const offset = bc.offset;
@@ -2028,11 +2288,11 @@ function readToEnvoy(bc) {
     case 7:
       return { tag: "ToEnvoySqliteCommitResponse", val: readToEnvoySqliteCommitResponse(bc) };
     case 8:
-      return { tag: "ToEnvoySqliteCommitStageBeginResponse", val: readToEnvoySqliteCommitStageBeginResponse(bc) };
+      return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) };
     case 9:
-      return { tag: "ToEnvoySqliteCommitStageResponse", val: readToEnvoySqliteCommitStageResponse(bc) };
+      return { tag: "ToEnvoySqliteExecuteResponse", val: readToEnvoySqliteExecuteResponse(bc) };
     case 10:
-      return { tag: "ToEnvoySqliteCommitFinalizeResponse", val: readToEnvoySqliteCommitFinalizeResponse(bc) };
+      return { tag: "ToEnvoySqliteExecuteBatchResponse", val: readToEnvoySqliteExecuteBatchResponse(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -2081,19 +2341,19 @@ function writeToEnvoy(bc, x) {
       writeToEnvoySqliteCommitResponse(bc, x.val);
       break;
     }
-    case "ToEnvoySqliteCommitStageBeginResponse": {
+    case "ToEnvoySqliteExecResponse": {
       bare.writeU8(bc, 8);
-      writeToEnvoySqliteCommitStageBeginResponse(bc, x.val);
+      writeToEnvoySqliteExecResponse(bc, x.val);
       break;
     }
-    case "ToEnvoySqliteCommitStageResponse": {
+    case "ToEnvoySqliteExecuteResponse": {
       bare.writeU8(bc, 9);
-      writeToEnvoySqliteCommitStageResponse(bc, x.val);
+      writeToEnvoySqliteExecuteResponse(bc, x.val);
       break;
     }
-    case "ToEnvoySqliteCommitFinalizeResponse": {
+    case "ToEnvoySqliteExecuteBatchResponse": {
       bare.writeU8(bc, 10);
-      writeToEnvoySqliteCommitFinalizeResponse(bc, x.val);
+      writeToEnvoySqliteExecuteBatchResponse(bc, x.val);
       break;
     }
   }
@@ -2302,8 +2562,9 @@ function decodeToOutbound(bytes) {
 function assert(condition, message) {
   if (!condition) throw new Error(message ?? "Assertion failed");
 }
-var VERSION = 2;
+var VERSION = 8;
 export {
+  HttpStreamAbortReasonKind,
   StopActorReason,
   StopCode,
   VERSION,
@@ -2337,6 +2598,8 @@ export {
   readEventWrapper,
   readGatewayId,
   readHibernatingRequest,
+  readHttpStreamAbortReason,
+  readHttpStreamAbortReasonKind,
   readId,
   readJson,
   readKvDeleteRangeRequest,
@@ -2361,34 +2624,36 @@ export {
   readPreloadedKvEntry,
   readProtocolMetadata,
   readRequestId,
-  readSqliteCommitFinalizeOk,
-  readSqliteCommitFinalizeRequest,
-  readSqliteCommitFinalizeResponse,
+  readSqliteBatchStatement,
+  readSqliteBindParam,
+  readSqliteColumnValue,
   readSqliteCommitOk,
   readSqliteCommitRequest,
   readSqliteCommitResponse,
-  readSqliteCommitStageBeginOk,
-  readSqliteCommitStageBeginRequest,
-  readSqliteCommitStageBeginResponse,
-  readSqliteCommitStageOk,
-  readSqliteCommitStageRequest,
-  readSqliteCommitStageResponse,
-  readSqliteCommitTooLarge,
   readSqliteDirtyPage,
   readSqliteErrorResponse,
-  readSqliteFenceMismatch,
+  readSqliteExecOk,
+  readSqliteExecRequest,
+  readSqliteExecResponse,
+  readSqliteExecuteBatchOk,
+  readSqliteExecuteBatchRequest,
+  readSqliteExecuteBatchResponse,
+  readSqliteExecuteOk,
+  readSqliteExecuteRequest,
+  readSqliteExecuteResponse,
+  readSqliteExecuteResult,
   readSqliteFetchedPage,
   readSqliteGeneration,
   readSqliteGetPagesOk,
   readSqliteGetPagesRequest,
   readSqliteGetPagesResponse,
-  readSqliteMeta,
   readSqlitePageBytes,
   readSqlitePgno,
-  readSqliteStageId,
-  readSqliteStageNotFound,
-  readSqliteStartupData,
-  readSqliteTxid,
+  readSqliteQueryResult,
+  readSqliteValueBlob,
+  readSqliteValueFloat,
+  readSqliteValueInteger,
+  readSqliteValueText,
   readStopActorReason,
   readStopCode,
   readToEnvoy,
@@ -2399,12 +2664,13 @@ export {
   readToEnvoyInit,
   readToEnvoyKvResponse,
   readToEnvoyPing,
+  readToEnvoyRequestAbort,
   readToEnvoyRequestChunk,
   readToEnvoyRequestStart,
-  readToEnvoySqliteCommitFinalizeResponse,
   readToEnvoySqliteCommitResponse,
-  readToEnvoySqliteCommitStageBeginResponse,
-  readToEnvoySqliteCommitStageResponse,
+  readToEnvoySqliteExecResponse,
+  readToEnvoySqliteExecuteBatchResponse,
+  readToEnvoySqliteExecuteResponse,
   readToEnvoySqliteGetPagesResponse,
   readToEnvoyTunnelMessage,
   readToEnvoyTunnelMessageKind,
@@ -2421,12 +2687,13 @@ export {
   readToRivetKvRequest,
   readToRivetMetadata,
   readToRivetPong,
+  readToRivetResponseAbort,
   readToRivetResponseChunk,
   readToRivetResponseStart,
-  readToRivetSqliteCommitFinalizeRequest,
   readToRivetSqliteCommitRequest,
-  readToRivetSqliteCommitStageBeginRequest,
-  readToRivetSqliteCommitStageRequest,
+  readToRivetSqliteExecRequest,
+  readToRivetSqliteExecuteBatchRequest,
+  readToRivetSqliteExecuteRequest,
   readToRivetSqliteGetPagesRequest,
   readToRivetTunnelMessage,
   readToRivetTunnelMessageKind,
@@ -2452,6 +2719,8 @@ export {
   writeEventWrapper,
   writeGatewayId,
   writeHibernatingRequest,
+  writeHttpStreamAbortReason,
+  writeHttpStreamAbortReasonKind,
   writeId,
   writeJson,
   writeKvDeleteRangeRequest,
@@ -2476,34 +2745,36 @@ export {
   writePreloadedKvEntry,
   writeProtocolMetadata,
   writeRequestId,
-  writeSqliteCommitFinalizeOk,
-  writeSqliteCommitFinalizeRequest,
-  writeSqliteCommitFinalizeResponse,
+  writeSqliteBatchStatement,
+  writeSqliteBindParam,
+  writeSqliteColumnValue,
   writeSqliteCommitOk,
   writeSqliteCommitRequest,
   writeSqliteCommitResponse,
-  writeSqliteCommitStageBeginOk,
-  writeSqliteCommitStageBeginRequest,
-  writeSqliteCommitStageBeginResponse,
-  writeSqliteCommitStageOk,
-  writeSqliteCommitStageRequest,
-  writeSqliteCommitStageResponse,
-  writeSqliteCommitTooLarge,
   writeSqliteDirtyPage,
   writeSqliteErrorResponse,
-  writeSqliteFenceMismatch,
+  writeSqliteExecOk,
+  writeSqliteExecRequest,
+  writeSqliteExecResponse,
+  writeSqliteExecuteBatchOk,
+  writeSqliteExecuteBatchRequest,
+  writeSqliteExecuteBatchResponse,
+  writeSqliteExecuteOk,
+  writeSqliteExecuteRequest,
+  writeSqliteExecuteResponse,
+  writeSqliteExecuteResult,
   writeSqliteFetchedPage,
   writeSqliteGeneration,
   writeSqliteGetPagesOk,
   writeSqliteGetPagesRequest,
   writeSqliteGetPagesResponse,
-  writeSqliteMeta,
   writeSqlitePageBytes,
   writeSqlitePgno,
-  writeSqliteStageId,
-  writeSqliteStageNotFound,
-  writeSqliteStartupData,
-  writeSqliteTxid,
+  writeSqliteQueryResult,
+  writeSqliteValueBlob,
+  writeSqliteValueFloat,
+  writeSqliteValueInteger,
+  writeSqliteValueText,
   writeStopActorReason,
   writeStopCode,
   writeToEnvoy,
@@ -2514,12 +2785,13 @@ export {
   writeToEnvoyInit,
   writeToEnvoyKvResponse,
   writeToEnvoyPing,
+  writeToEnvoyRequestAbort,
   writeToEnvoyRequestChunk,
   writeToEnvoyRequestStart,
-  writeToEnvoySqliteCommitFinalizeResponse,
   writeToEnvoySqliteCommitResponse,
-  writeToEnvoySqliteCommitStageBeginResponse,
-  writeToEnvoySqliteCommitStageResponse,
+  writeToEnvoySqliteExecResponse,
+  writeToEnvoySqliteExecuteBatchResponse,
+  writeToEnvoySqliteExecuteResponse,
   writeToEnvoySqliteGetPagesResponse,
   writeToEnvoyTunnelMessage,
   writeToEnvoyTunnelMessageKind,
@@ -2536,12 +2808,13 @@ export {
   writeToRivetKvRequest,
   writeToRivetMetadata,
   writeToRivetPong,
+  writeToRivetResponseAbort,
   writeToRivetResponseChunk,
   writeToRivetResponseStart,
-  writeToRivetSqliteCommitFinalizeRequest,
   writeToRivetSqliteCommitRequest,
-  writeToRivetSqliteCommitStageBeginRequest,
-  writeToRivetSqliteCommitStageRequest,
+  writeToRivetSqliteExecRequest,
+  writeToRivetSqliteExecuteBatchRequest,
+  writeToRivetSqliteExecuteRequest,
   writeToRivetSqliteGetPagesRequest,
   writeToRivetTunnelMessage,
   writeToRivetTunnelMessageKind,