@rivetkit/engine-envoy-protocol 0.0.0-pr.4672.159c9b3 → 0.0.0-pr.4673.d7d209b

package/dist/index.js

@@ -209,82 +209,6 @@ function writeKvDeleteRangeRequest(bc, x) {
   writeKvKey(bc, x.start);
   writeKvKey(bc, x.end);
 }
-function readSqliteFastPathFence(bc) {
-  return {
-    expectedFence: read2(bc),
-    requestFence: bare.readU64(bc)
-  };
-}
-function writeSqliteFastPathFence(bc, x) {
-  write2(bc, x.expectedFence);
-  bare.writeU64(bc, x.requestFence);
-}
-function readSqlitePageUpdate(bc) {
-  return {
-    chunkIndex: bare.readU32(bc),
-    data: readKvValue(bc)
-  };
-}
-function writeSqlitePageUpdate(bc, x) {
-  bare.writeU32(bc, x.chunkIndex);
-  writeKvValue(bc, x.data);
-}
-function read4(bc) {
-  const len = bare.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readSqlitePageUpdate(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readSqlitePageUpdate(bc);
-  }
-  return result;
-}
-function write4(bc, x) {
-  bare.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    writeSqlitePageUpdate(bc, x[i]);
-  }
-}
-function readKvSqliteWriteBatchRequest(bc) {
-  return {
-    fileTag: bare.readU8(bc),
-    metaValue: readKvValue(bc),
-    pageUpdates: read4(bc),
-    fence: readSqliteFastPathFence(bc)
-  };
-}
-function writeKvSqliteWriteBatchRequest(bc, x) {
-  bare.writeU8(bc, x.fileTag);
-  writeKvValue(bc, x.metaValue);
-  write4(bc, x.pageUpdates);
-  writeSqliteFastPathFence(bc, x.fence);
-}
-function read5(bc) {
-  return bare.readBool(bc) ? readSqlitePageUpdate(bc) : null;
-}
-function write5(bc, x) {
-  bare.writeBool(bc, x != null);
-  if (x != null) {
-    writeSqlitePageUpdate(bc, x);
-  }
-}
-function readKvSqliteTruncateRequest(bc) {
-  return {
-    fileTag: bare.readU8(bc),
-    metaValue: readKvValue(bc),
-    deleteChunksFrom: bare.readU32(bc),
-    tailChunk: read5(bc),
-    fence: readSqliteFastPathFence(bc)
-  };
-}
-function writeKvSqliteTruncateRequest(bc, x) {
-  bare.writeU8(bc, x.fileTag);
-  writeKvValue(bc, x.metaValue);
-  bare.writeU32(bc, x.deleteChunksFrom);
-  write5(bc, x.tailChunk);
-  writeSqliteFastPathFence(bc, x.fence);
-}
 function readKvErrorResponse(bc) {
   return {
     message: bare.readString(bc)
@@ -293,7 +217,7 @@ function readKvErrorResponse(bc) {
 function writeKvErrorResponse(bc, x) {
   bare.writeString(bc, x.message);
 }
-function read6(bc) {
+function read4(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -304,7 +228,7 @@ function read6(bc) {
   }
   return result;
 }
-function write6(bc, x) {
+function write4(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeKvMetadata(bc, x[i]);
@@ -314,25 +238,25 @@ function readKvGetResponse(bc) {
   return {
     keys: read0(bc),
     values: read3(bc),
-    metadata: read6(bc)
+    metadata: read4(bc)
   };
 }
 function writeKvGetResponse(bc, x) {
   write0(bc, x.keys);
   write3(bc, x.values);
-  write6(bc, x.metadata);
+  write4(bc, x.metadata);
 }
 function readKvListResponse(bc) {
   return {
     keys: read0(bc),
     values: read3(bc),
-    metadata: read6(bc)
+    metadata: read4(bc)
   };
 }
 function writeKvListResponse(bc, x) {
   write0(bc, x.keys);
   write3(bc, x.values);
-  write6(bc, x.metadata);
+  write4(bc, x.metadata);
 }
 function readKvRequestData(bc) {
   const offset = bc.offset;
@@ -349,10 +273,6 @@ function readKvRequestData(bc) {
     case 4:
       return { tag: "KvDeleteRangeRequest", val: readKvDeleteRangeRequest(bc) };
     case 5:
-      return { tag: "KvSqliteWriteBatchRequest", val: readKvSqliteWriteBatchRequest(bc) };
-    case 6:
-      return { tag: "KvSqliteTruncateRequest", val: readKvSqliteTruncateRequest(bc) };
-    case 7:
       return { tag: "KvDropRequest", val: null };
     default: {
       bc.offset = offset;
@@ -387,18 +307,8 @@ function writeKvRequestData(bc, x) {
       writeKvDeleteRangeRequest(bc, x.val);
       break;
     }
-    case "KvSqliteWriteBatchRequest": {
-      bare.writeU8(bc, 5);
-      writeKvSqliteWriteBatchRequest(bc, x.val);
-      break;
-    }
-    case "KvSqliteTruncateRequest": {
-      bare.writeU8(bc, 6);
-      writeKvSqliteTruncateRequest(bc, x.val);
-      break;
-    }
     case "KvDropRequest": {
-      bare.writeU8(bc, 7);
+      bare.writeU8(bc, 5);
       break;
     }
   }
@@ -456,6 +366,404 @@ 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) {
+  return bare.readU64(bc);
+}
+function writeSqliteStageId(bc, x) {
+  bare.writeU64(bc, x);
+}
+function readSqlitePageBytes(bc) {
+  return bare.readData(bc);
+}
+function writeSqlitePageBytes(bc, x) {
+  bare.writeData(bc, x);
+}
+function readSqliteMeta(bc) {
+  return {
+    schemaVersion: bare.readU32(bc),
+    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) {
+  bare.writeU32(bc, x.schemaVersion);
+  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),
+    bytes: readSqlitePageBytes(bc)
+  };
+}
+function writeSqliteDirtyPage(bc, x) {
+  writeSqlitePgno(bc, x.pgno);
+  writeSqlitePageBytes(bc, x.bytes);
+}
+function read5(bc) {
+  return bare.readBool(bc) ? readSqlitePageBytes(bc) : null;
+}
+function write5(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeSqlitePageBytes(bc, x);
+  }
+}
+function readSqliteFetchedPage(bc) {
+  return {
+    pgno: readSqlitePgno(bc),
+    bytes: read5(bc)
+  };
+}
+function writeSqliteFetchedPage(bc, x) {
+  writeSqlitePgno(bc, x.pgno);
+  write5(bc, x.bytes);
+}
+function read6(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqlitePgno(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqlitePgno(bc);
+  }
+  return result;
+}
+function write6(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqlitePgno(bc, x[i]);
+  }
+}
+function readSqliteGetPagesRequest(bc) {
+  return {
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    pgnos: read6(bc)
+  };
+}
+function writeSqliteGetPagesRequest(bc, x) {
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  write6(bc, x.pgnos);
+}
+function read7(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteFetchedPage(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteFetchedPage(bc);
+  }
+  return result;
+}
+function write7(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteFetchedPage(bc, x[i]);
+  }
+}
+function readSqliteGetPagesOk(bc) {
+  return {
+    pages: read7(bc),
+    meta: readSqliteMeta(bc)
+  };
+}
+function writeSqliteGetPagesOk(bc, x) {
+  write7(bc, x.pages);
+  writeSqliteMeta(bc, x.meta);
+}
+function readSqliteGetPagesResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteGetPagesOk", val: readSqliteGetPagesOk(bc) };
+    case 1:
+      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteGetPagesResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteGetPagesOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteGetPagesOk(bc, x.val);
+      break;
+    }
+    case "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+  }
+}
+function read8(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteDirtyPage(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteDirtyPage(bc);
+  }
+  return result;
+}
+function write8(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteDirtyPage(bc, x[i]);
+  }
+}
+function readSqliteCommitRequest(bc) {
+  return {
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    expectedHeadTxid: readSqliteTxid(bc),
+    dirtyPages: read8(bc),
+    newDbSizePages: bare.readU32(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);
+}
+function readSqliteCommitOk(bc) {
+  return {
+    newHeadTxid: readSqliteTxid(bc),
+    meta: readSqliteMeta(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);
+}
+function readSqliteCommitResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitOk", val: readSqliteCommitOk(bc) };
+    case 1:
+      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    case 2:
+      return { tag: "SqliteCommitTooLarge", val: readSqliteCommitTooLarge(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitOk": {
+      bare.writeU8(bc, 0);
+      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;
+    }
+  }
+}
+function readSqliteCommitStageRequest(bc) {
+  return {
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    stageId: readSqliteStageId(bc),
+    chunkIdx: bare.readU16(bc),
+    dirtyPages: read8(bc),
+    isLast: bare.readBool(bc)
+  };
+}
+function writeSqliteCommitStageRequest(bc, x) {
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  writeSqliteStageId(bc, x.stageId);
+  bare.writeU16(bc, x.chunkIdx);
+  write8(bc, x.dirtyPages);
+  bare.writeBool(bc, x.isLast);
+}
+function readSqliteCommitStageOk(bc) {
+  return {
+    chunkIdxCommitted: bare.readU16(bc)
+  };
+}
+function writeSqliteCommitStageOk(bc, x) {
+  bare.writeU16(bc, x.chunkIdxCommitted);
+}
+function readSqliteCommitStageResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitStageOk", val: readSqliteCommitStageOk(bc) };
+    case 1:
+      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitStageResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitStageOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitStageOk(bc, x.val);
+      break;
+    }
+    case "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitFinalizeRequest(bc) {
+  return {
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    expectedHeadTxid: readSqliteTxid(bc),
+    stageId: readSqliteStageId(bc),
+    newDbSizePages: bare.readU32(bc)
+  };
+}
+function writeSqliteCommitFinalizeRequest(bc, x) {
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  writeSqliteTxid(bc, x.expectedHeadTxid);
+  writeSqliteStageId(bc, x.stageId);
+  bare.writeU32(bc, x.newDbSizePages);
+}
+function readSqliteCommitFinalizeOk(bc) {
+  return {
+    newHeadTxid: readSqliteTxid(bc),
+    meta: readSqliteMeta(bc)
+  };
+}
+function writeSqliteCommitFinalizeOk(bc, x) {
+  writeSqliteTxid(bc, x.newHeadTxid);
+  writeSqliteMeta(bc, x.meta);
+}
+function readSqliteStageNotFound(bc) {
+  return {
+    stageId: readSqliteStageId(bc)
+  };
+}
+function writeSqliteStageNotFound(bc, x) {
+  writeSqliteStageId(bc, x.stageId);
+}
+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: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    case 2:
+      return { tag: "SqliteStageNotFound", val: readSqliteStageNotFound(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 "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+    case "SqliteStageNotFound": {
+      bare.writeU8(bc, 2);
+      writeSqliteStageNotFound(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteStartupData(bc) {
+  return {
+    generation: readSqliteGeneration(bc),
+    meta: readSqliteMeta(bc),
+    preloadedPages: read7(bc)
+  };
+}
+function writeSqliteStartupData(bc, x) {
+  writeSqliteGeneration(bc, x.generation);
+  writeSqliteMeta(bc, x.meta);
+  write7(bc, x.preloadedPages);
+}
 var StopCode = /* @__PURE__ */ ((StopCode2) => {
   StopCode2["Ok"] = "Ok";
   StopCode2["Error"] = "Error";
@@ -495,19 +803,19 @@ function readActorName(bc) {
 function writeActorName(bc, x) {
   writeJson(bc, x.metadata);
 }
-function read7(bc) {
+function read9(bc) {
   return bare.readBool(bc) ? bare.readString(bc) : null;
 }
-function write7(bc, x) {
+function write9(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeString(bc, x);
   }
 }
-function read8(bc) {
+function read10(bc) {
   return bare.readBool(bc) ? bare.readData(bc) : null;
 }
-function write8(bc, x) {
+function write10(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeData(bc, x);
@@ -516,16 +824,16 @@ function write8(bc, x) {
 function readActorConfig(bc) {
   return {
     name: bare.readString(bc),
-    key: read7(bc),
+    key: read9(bc),
     createTs: bare.readI64(bc),
-    input: read8(bc)
+    input: read10(bc)
   };
 }
 function writeActorConfig(bc, x) {
   bare.writeString(bc, x.name);
-  write7(bc, x.key);
+  write9(bc, x.key);
   bare.writeI64(bc, x.createTs);
-  write8(bc, x.input);
+  write10(bc, x.input);
 }
 function readActorCheckpoint(bc) {
   return {
@@ -568,12 +876,12 @@ function writeActorIntent(bc, x) {
 function readActorStateStopped(bc) {
   return {
     code: readStopCode(bc),
-    message: read7(bc)
+    message: read9(bc)
   };
 }
 function writeActorStateStopped(bc, x) {
   writeStopCode(bc, x.code);
-  write7(bc, x.message);
+  write9(bc, x.message);
 }
 function readActorState(bc) {
   const offset = bc.offset;
@@ -618,10 +926,10 @@ function readEventActorStateUpdate(bc) {
 function writeEventActorStateUpdate(bc, x) {
   writeActorState(bc, x.state);
 }
-function read9(bc) {
+function read11(bc) {
   return bare.readBool(bc) ? bare.readI64(bc) : null;
 }
-function write9(bc, x) {
+function write11(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeI64(bc, x);
@@ -629,11 +937,11 @@ function write9(bc, x) {
 }
 function readEventActorSetAlarm(bc) {
   return {
-    alarmTs: read9(bc)
+    alarmTs: read11(bc)
   };
 }
 function writeEventActorSetAlarm(bc, x) {
-  write9(bc, x.alarmTs);
+  write11(bc, x.alarmTs);
 }
 function readEvent(bc) {
   const offset = bc.offset;
@@ -692,7 +1000,7 @@ function writePreloadedKvEntry(bc, x) {
   writeKvValue(bc, x.value);
   writeKvMetadata(bc, x.metadata);
 }
-function read10(bc) {
+function read12(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -703,7 +1011,7 @@ function read10(bc) {
   }
   return result;
 }
-function write10(bc, x) {
+function write12(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePreloadedKvEntry(bc, x[i]);
@@ -711,13 +1019,13 @@ function write10(bc, x) {
 }
 function readPreloadedKv(bc) {
   return {
-    entries: read10(bc),
+    entries: read12(bc),
     requestedGetKeys: read0(bc),
     requestedPrefixes: read0(bc)
   };
 }
 function writePreloadedKv(bc, x) {
-  write10(bc, x.entries);
+  write12(bc, x.entries);
   write0(bc, x.requestedGetKeys);
   write0(bc, x.requestedPrefixes);
 }
@@ -731,7 +1039,7 @@ function writeHibernatingRequest(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
 }
-function read11(bc) {
+function read13(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -742,32 +1050,45 @@ function read11(bc) {
   }
   return result;
 }
-function write11(bc, x) {
+function write13(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeHibernatingRequest(bc, x[i]);
   }
 }
-function read12(bc) {
+function read14(bc) {
   return bare.readBool(bc) ? readPreloadedKv(bc) : null;
 }
-function write12(bc, x) {
+function write14(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: read11(bc),
-    preloadedKv: read12(bc)
+    hibernatingRequests: read13(bc),
+    preloadedKv: read14(bc),
+    sqliteSchemaVersion: bare.readU32(bc),
+    sqliteStartupData: read15(bc)
   };
 }
 function writeCommandStartActor(bc, x) {
   writeActorConfig(bc, x.config);
-  write11(bc, x.hibernatingRequests);
-  write12(bc, x.preloadedKv);
+  write13(bc, x.hibernatingRequests);
+  write14(bc, x.preloadedKv);
+  bare.writeU32(bc, x.sqliteSchemaVersion);
+  write15(bc, x.sqliteStartupData);
 }
 var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
   StopActorReason2["SleepIntent"] = "SleepIntent";
@@ -924,7 +1245,7 @@ function writeMessageId(bc, x) {
   writeRequestId(bc, x.requestId);
   writeMessageIndex(bc, x.messageIndex);
 }
-function read13(bc) {
+function read16(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -938,7 +1259,7 @@ function read13(bc) {
   }
   return result;
 }
-function write13(bc, x) {
+function write16(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
@@ -950,8 +1271,8 @@ function readToEnvoyRequestStart(bc) {
     actorId: readId(bc),
     method: bare.readString(bc),
     path: bare.readString(bc),
-    headers: read13(bc),
-    body: read8(bc),
+    headers: read16(bc),
+    body: read10(bc),
     stream: bare.readBool(bc)
   };
 }
@@ -959,8 +1280,8 @@ function writeToEnvoyRequestStart(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.method);
   bare.writeString(bc, x.path);
-  write13(bc, x.headers);
-  write8(bc, x.body);
+  write16(bc, x.headers);
+  write10(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToEnvoyRequestChunk(bc) {
@@ -976,15 +1297,15 @@ function writeToEnvoyRequestChunk(bc, x) {
 function readToRivetResponseStart(bc) {
   return {
     status: bare.readU16(bc),
-    headers: read13(bc),
-    body: read8(bc),
+    headers: read16(bc),
+    body: read10(bc),
     stream: bare.readBool(bc)
   };
 }
 function writeToRivetResponseStart(bc, x) {
   bare.writeU16(bc, x.status);
-  write13(bc, x.headers);
-  write8(bc, x.body);
+  write16(bc, x.headers);
+  write10(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToRivetResponseChunk(bc) {
@@ -1001,13 +1322,13 @@ function readToEnvoyWebSocketOpen(bc) {
   return {
     actorId: readId(bc),
     path: bare.readString(bc),
-    headers: read13(bc)
+    headers: read16(bc)
   };
 }
 function writeToEnvoyWebSocketOpen(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.path);
-  write13(bc, x.headers);
+  write16(bc, x.headers);
 }
 function readToEnvoyWebSocketMessage(bc) {
   return {
@@ -1019,10 +1340,10 @@ function writeToEnvoyWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function read14(bc) {
+function read17(bc) {
   return bare.readBool(bc) ? bare.readU16(bc) : null;
 }
-function write14(bc, x) {
+function write17(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeU16(bc, x);
@@ -1030,13 +1351,13 @@ function write14(bc, x) {
 }
 function readToEnvoyWebSocketClose(bc) {
   return {
-    code: read14(bc),
-    reason: read7(bc)
+    code: read17(bc),
+    reason: read9(bc)
   };
 }
 function writeToEnvoyWebSocketClose(bc, x) {
-  write14(bc, x.code);
-  write7(bc, x.reason);
+  write17(bc, x.code);
+  write9(bc, x.reason);
 }
 function readToRivetWebSocketOpen(bc) {
   return {
@@ -1066,14 +1387,14 @@ function writeToRivetWebSocketMessageAck(bc, x) {
 }
 function readToRivetWebSocketClose(bc) {
   return {
-    code: read14(bc),
-    reason: read7(bc),
+    code: read17(bc),
+    reason: read9(bc),
     hibernate: bare.readBool(bc)
   };
 }
 function writeToRivetWebSocketClose(bc, x) {
-  write14(bc, x.code);
-  write7(bc, x.reason);
+  write17(bc, x.code);
+  write9(bc, x.reason);
   bare.writeBool(bc, x.hibernate);
 }
 function readToRivetTunnelMessageKind(bc) {
@@ -1221,7 +1542,7 @@ function readToEnvoyPing(bc) {
 function writeToEnvoyPing(bc, x) {
   bare.writeI64(bc, x.ts);
 }
-function read15(bc) {
+function read18(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1235,26 +1556,26 @@ function read15(bc) {
   }
   return result;
 }
-function write15(bc, x) {
+function write18(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
     writeActorName(bc, kv[1]);
   }
 }
-function read16(bc) {
-  return bare.readBool(bc) ? read15(bc) : null;
+function read19(bc) {
+  return bare.readBool(bc) ? read18(bc) : null;
 }
-function write16(bc, x) {
+function write19(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
-    write15(bc, x);
+    write18(bc, x);
   }
 }
-function read17(bc) {
+function read20(bc) {
   return bare.readBool(bc) ? readJson(bc) : null;
 }
-function write17(bc, x) {
+function write20(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeJson(bc, x);
@@ -1262,13 +1583,13 @@ function write17(bc, x) {
 }
 function readToRivetMetadata(bc) {
   return {
-    prepopulateActorNames: read16(bc),
-    metadata: read17(bc)
+    prepopulateActorNames: read19(bc),
+    metadata: read20(bc)
   };
 }
 function writeToRivetMetadata(bc, x) {
-  write16(bc, x.prepopulateActorNames);
-  write17(bc, x.metadata);
+  write19(bc, x.prepopulateActorNames);
+  write20(bc, x.metadata);
 }
 function readToRivetEvents(bc) {
   const len = bare.readUintSafe(bc);
@@ -1287,7 +1608,7 @@ function writeToRivetEvents(bc, x) {
     writeEventWrapper(bc, x[i]);
   }
 }
-function read18(bc) {
+function read21(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1298,7 +1619,7 @@ function read18(bc) {
   }
   return result;
 }
-function write18(bc, x) {
+function write21(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeActorCheckpoint(bc, x[i]);
@@ -1306,11 +1627,11 @@ function write18(bc, x) {
 }
 function readToRivetAckCommands(bc) {
   return {
-    lastCommandCheckpoints: read18(bc)
+    lastCommandCheckpoints: read21(bc)
   };
 }
 function writeToRivetAckCommands(bc, x) {
-  write18(bc, x.lastCommandCheckpoints);
+  write21(bc, x.lastCommandCheckpoints);
 }
 function readToRivetPong(bc) {
   return {
@@ -1332,6 +1653,46 @@ function writeToRivetKvRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeKvRequestData(bc, x.data);
 }
+function readToRivetSqliteGetPagesRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteGetPagesRequest(bc)
+  };
+}
+function writeToRivetSqliteGetPagesRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteGetPagesRequest(bc, x.data);
+}
+function readToRivetSqliteCommitRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitRequest(bc, x.data);
+}
+function readToRivetSqliteCommitStageRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitStageRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageRequest(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 readToRivet(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -1350,6 +1711,14 @@ function readToRivet(bc) {
       return { tag: "ToRivetKvRequest", val: readToRivetKvRequest(bc) };
     case 6:
       return { tag: "ToRivetTunnelMessage", val: readToRivetTunnelMessage(bc) };
+    case 7:
+      return { tag: "ToRivetSqliteGetPagesRequest", val: readToRivetSqliteGetPagesRequest(bc) };
+    case 8:
+      return { tag: "ToRivetSqliteCommitRequest", val: readToRivetSqliteCommitRequest(bc) };
+    case 9:
+      return { tag: "ToRivetSqliteCommitStageRequest", val: readToRivetSqliteCommitStageRequest(bc) };
+    case 10:
+      return { tag: "ToRivetSqliteCommitFinalizeRequest", val: readToRivetSqliteCommitFinalizeRequest(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -1392,6 +1761,26 @@ function writeToRivet(bc, x) {
       writeToRivetTunnelMessage(bc, x.val);
       break;
     }
+    case "ToRivetSqliteGetPagesRequest": {
+      bare.writeU8(bc, 7);
+      writeToRivetSqliteGetPagesRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitRequest": {
+      bare.writeU8(bc, 8);
+      writeToRivetSqliteCommitRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitStageRequest": {
+      bare.writeU8(bc, 9);
+      writeToRivetSqliteCommitStageRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitFinalizeRequest": {
+      bare.writeU8(bc, 10);
+      writeToRivetSqliteCommitFinalizeRequest(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToRivet(x, config) {
@@ -1411,40 +1800,17 @@ function decodeToRivet(bytes) {
   }
   return result;
 }
-function readSqliteFastPathCapability(bc) {
-  return {
-    protocolVersion: bare.readU16(bc),
-    supportsWriteBatch: bare.readBool(bc),
-    supportsTruncate: bare.readBool(bc)
-  };
-}
-function writeSqliteFastPathCapability(bc, x) {
-  bare.writeU16(bc, x.protocolVersion);
-  bare.writeBool(bc, x.supportsWriteBatch);
-  bare.writeBool(bc, x.supportsTruncate);
-}
-function read19(bc) {
-  return bare.readBool(bc) ? readSqliteFastPathCapability(bc) : null;
-}
-function write19(bc, x) {
-  bare.writeBool(bc, x != null);
-  if (x != null) {
-    writeSqliteFastPathCapability(bc, x);
-  }
-}
 function readProtocolMetadata(bc) {
   return {
     envoyLostThreshold: bare.readI64(bc),
     actorStopThreshold: bare.readI64(bc),
-    maxResponsePayloadSize: bare.readU64(bc),
-    sqliteFastPath: read19(bc)
+    maxResponsePayloadSize: bare.readU64(bc)
   };
 }
 function writeProtocolMetadata(bc, x) {
   bare.writeI64(bc, x.envoyLostThreshold);
   bare.writeI64(bc, x.actorStopThreshold);
   bare.writeU64(bc, x.maxResponsePayloadSize);
-  write19(bc, x.sqliteFastPath);
 }
 function readToEnvoyInit(bc) {
   return {
@@ -1473,11 +1839,11 @@ function writeToEnvoyCommands(bc, x) {
 }
 function readToEnvoyAckEvents(bc) {
   return {
-    lastEventCheckpoints: read18(bc)
+    lastEventCheckpoints: read21(bc)
   };
 }
 function writeToEnvoyAckEvents(bc, x) {
-  write18(bc, x.lastEventCheckpoints);
+  write21(bc, x.lastEventCheckpoints);
 }
 function readToEnvoyKvResponse(bc) {
   return {
@@ -1489,6 +1855,46 @@ function writeToEnvoyKvResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeKvResponseData(bc, x.data);
 }
+function readToEnvoySqliteGetPagesResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteGetPagesResponse(bc)
+  };
+}
+function writeToEnvoySqliteGetPagesResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteGetPagesResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitStageResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitStageResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageResponse(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 readToEnvoy(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -1505,6 +1911,14 @@ function readToEnvoy(bc) {
       return { tag: "ToEnvoyTunnelMessage", val: readToEnvoyTunnelMessage(bc) };
     case 5:
       return { tag: "ToEnvoyPing", val: readToEnvoyPing(bc) };
+    case 6:
+      return { tag: "ToEnvoySqliteGetPagesResponse", val: readToEnvoySqliteGetPagesResponse(bc) };
+    case 7:
+      return { tag: "ToEnvoySqliteCommitResponse", val: readToEnvoySqliteCommitResponse(bc) };
+    case 8:
+      return { tag: "ToEnvoySqliteCommitStageResponse", val: readToEnvoySqliteCommitStageResponse(bc) };
+    case 9:
+      return { tag: "ToEnvoySqliteCommitFinalizeResponse", val: readToEnvoySqliteCommitFinalizeResponse(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -1543,6 +1957,26 @@ function writeToEnvoy(bc, x) {
       writeToEnvoyPing(bc, x.val);
       break;
     }
+    case "ToEnvoySqliteGetPagesResponse": {
+      bare.writeU8(bc, 6);
+      writeToEnvoySqliteGetPagesResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitResponse": {
+      bare.writeU8(bc, 7);
+      writeToEnvoySqliteCommitResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitStageResponse": {
+      bare.writeU8(bc, 8);
+      writeToEnvoySqliteCommitStageResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitFinalizeResponse": {
+      bare.writeU8(bc, 9);
+      writeToEnvoySqliteCommitFinalizeResponse(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToEnvoy(x, config) {
@@ -1801,8 +2235,6 @@ export {
   readKvPutRequest,
   readKvRequestData,
   readKvResponseData,
-  readKvSqliteTruncateRequest,
-  readKvSqliteWriteBatchRequest,
   readKvValue,
   readMessageId,
   readMessageIndex,
@@ -1810,9 +2242,30 @@ export {
   readPreloadedKvEntry,
   readProtocolMetadata,
   readRequestId,
-  readSqliteFastPathCapability,
-  readSqliteFastPathFence,
-  readSqlitePageUpdate,
+  readSqliteCommitFinalizeOk,
+  readSqliteCommitFinalizeRequest,
+  readSqliteCommitFinalizeResponse,
+  readSqliteCommitOk,
+  readSqliteCommitRequest,
+  readSqliteCommitResponse,
+  readSqliteCommitStageOk,
+  readSqliteCommitStageRequest,
+  readSqliteCommitStageResponse,
+  readSqliteCommitTooLarge,
+  readSqliteDirtyPage,
+  readSqliteFenceMismatch,
+  readSqliteFetchedPage,
+  readSqliteGeneration,
+  readSqliteGetPagesOk,
+  readSqliteGetPagesRequest,
+  readSqliteGetPagesResponse,
+  readSqliteMeta,
+  readSqlitePageBytes,
+  readSqlitePgno,
+  readSqliteStageId,
+  readSqliteStageNotFound,
+  readSqliteStartupData,
+  readSqliteTxid,
   readStopActorReason,
   readStopCode,
   readToEnvoy,
@@ -1825,6 +2278,10 @@ export {
   readToEnvoyPing,
   readToEnvoyRequestChunk,
   readToEnvoyRequestStart,
+  readToEnvoySqliteCommitFinalizeResponse,
+  readToEnvoySqliteCommitResponse,
+  readToEnvoySqliteCommitStageResponse,
+  readToEnvoySqliteGetPagesResponse,
   readToEnvoyTunnelMessage,
   readToEnvoyTunnelMessageKind,
   readToEnvoyWebSocketClose,
@@ -1842,6 +2299,10 @@ export {
   readToRivetPong,
   readToRivetResponseChunk,
   readToRivetResponseStart,
+  readToRivetSqliteCommitFinalizeRequest,
+  readToRivetSqliteCommitRequest,
+  readToRivetSqliteCommitStageRequest,
+  readToRivetSqliteGetPagesRequest,
   readToRivetTunnelMessage,
   readToRivetTunnelMessageKind,
   readToRivetWebSocketClose,
@@ -1883,8 +2344,6 @@ export {
   writeKvPutRequest,
   writeKvRequestData,
   writeKvResponseData,
-  writeKvSqliteTruncateRequest,
-  writeKvSqliteWriteBatchRequest,
   writeKvValue,
   writeMessageId,
   writeMessageIndex,
@@ -1892,9 +2351,30 @@ export {
   writePreloadedKvEntry,
   writeProtocolMetadata,
   writeRequestId,
-  writeSqliteFastPathCapability,
-  writeSqliteFastPathFence,
-  writeSqlitePageUpdate,
+  writeSqliteCommitFinalizeOk,
+  writeSqliteCommitFinalizeRequest,
+  writeSqliteCommitFinalizeResponse,
+  writeSqliteCommitOk,
+  writeSqliteCommitRequest,
+  writeSqliteCommitResponse,
+  writeSqliteCommitStageOk,
+  writeSqliteCommitStageRequest,
+  writeSqliteCommitStageResponse,
+  writeSqliteCommitTooLarge,
+  writeSqliteDirtyPage,
+  writeSqliteFenceMismatch,
+  writeSqliteFetchedPage,
+  writeSqliteGeneration,
+  writeSqliteGetPagesOk,
+  writeSqliteGetPagesRequest,
+  writeSqliteGetPagesResponse,
+  writeSqliteMeta,
+  writeSqlitePageBytes,
+  writeSqlitePgno,
+  writeSqliteStageId,
+  writeSqliteStageNotFound,
+  writeSqliteStartupData,
+  writeSqliteTxid,
   writeStopActorReason,
   writeStopCode,
   writeToEnvoy,
@@ -1907,6 +2387,10 @@ export {
   writeToEnvoyPing,
   writeToEnvoyRequestChunk,
   writeToEnvoyRequestStart,
+  writeToEnvoySqliteCommitFinalizeResponse,
+  writeToEnvoySqliteCommitResponse,
+  writeToEnvoySqliteCommitStageResponse,
+  writeToEnvoySqliteGetPagesResponse,
   writeToEnvoyTunnelMessage,
   writeToEnvoyTunnelMessageKind,
   writeToEnvoyWebSocketClose,
@@ -1924,6 +2408,10 @@ export {
   writeToRivetPong,
   writeToRivetResponseChunk,
   writeToRivetResponseStart,
+  writeToRivetSqliteCommitFinalizeRequest,
+  writeToRivetSqliteCommitRequest,
+  writeToRivetSqliteCommitStageRequest,
+  writeToRivetSqliteGetPagesRequest,
   writeToRivetTunnelMessage,
   writeToRivetTunnelMessageKind,
   writeToRivetWebSocketClose,