@rivetkit/engine-envoy-protocol 0.0.0-pr.4857.3a10f72 → 0.0.0-pr.4860.b5fe23b

package/dist/index.js

@@ -997,6 +997,462 @@ function writeSqliteStartupData(bc, x) {
   writeSqliteMeta(bc, x.meta);
   write7(bc, x.preloadedPages);
 }
+function readSqliteValueInteger(bc) {
+  return {
+    value: bare.readI64(bc)
+  };
+}
+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 readSqliteValueBlob(bc) {
+  return {
+    value: bare.readData(bc)
+  };
+}
+function writeSqliteValueBlob(bc, x) {
+  bare.writeData(bc, x.value);
+}
+function readSqliteBindParam(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteValueNull", val: null };
+    case 1:
+      return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) };
+    case 2:
+      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 writeSqliteBindParam(bc, x) {
+  switch (x.tag) {
+    case "SqliteValueNull": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "SqliteValueInteger": {
+      bare.writeU8(bc, 1);
+      writeSqliteValueInteger(bc, x.val);
+      break;
+    }
+    case "SqliteValueFloat": {
+      bare.writeU8(bc, 2);
+      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 readSqliteColumnValue(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteValueNull", val: null };
+    case 1:
+      return { tag: "SqliteValueInteger", val: readSqliteValueInteger(bc) };
+    case 2:
+      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 writeSqliteColumnValue(bc, x) {
+  switch (x.tag) {
+    case "SqliteValueNull": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "SqliteValueInteger": {
+      bare.writeU8(bc, 1);
+      writeSqliteValueInteger(bc, x.val);
+      break;
+    }
+    case "SqliteValueFloat": {
+      bare.writeU8(bc, 2);
+      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 read10(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 write10(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare.writeString(bc, x[i]);
+  }
+}
+function read11(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 write11(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteColumnValue(bc, x[i]);
+  }
+}
+function read12(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [read11(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = read11(bc);
+  }
+  return result;
+}
+function write12(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    write11(bc, x[i]);
+  }
+}
+function readSqliteQueryResult(bc) {
+  return {
+    columns: read10(bc),
+    rows: read12(bc)
+  };
+}
+function writeSqliteQueryResult(bc, x) {
+  write10(bc, x.columns);
+  write12(bc, x.rows);
+}
+var SqliteExecuteRoute = /* @__PURE__ */ ((SqliteExecuteRoute2) => {
+  SqliteExecuteRoute2["Read"] = "Read";
+  SqliteExecuteRoute2["Write"] = "Write";
+  SqliteExecuteRoute2["WriteFallback"] = "WriteFallback";
+  return SqliteExecuteRoute2;
+})(SqliteExecuteRoute || {});
+function readSqliteExecuteRoute(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "Read" /* Read */;
+    case 1:
+      return "Write" /* Write */;
+    case 2:
+      return "WriteFallback" /* WriteFallback */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecuteRoute(bc, x) {
+  switch (x) {
+    case "Read" /* Read */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "Write" /* Write */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "WriteFallback" /* WriteFallback */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+  }
+}
+function read13(bc) {
+  return bare.readBool(bc) ? bare.readI64(bc) : null;
+}
+function write13(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeI64(bc, x);
+  }
+}
+function readSqliteExecuteResult(bc) {
+  return {
+    columns: read10(bc),
+    rows: read12(bc),
+    changes: bare.readI64(bc),
+    lastInsertRowId: read13(bc),
+    route: readSqliteExecuteRoute(bc)
+  };
+}
+function writeSqliteExecuteResult(bc, x) {
+  write10(bc, x.columns);
+  write12(bc, x.rows);
+  bare.writeI64(bc, x.changes);
+  write13(bc, x.lastInsertRowId);
+  writeSqliteExecuteRoute(bc, x.route);
+}
+function readSqliteExecRequest(bc) {
+  return {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    sql: bare.readString(bc)
+  };
+}
+function writeSqliteExecRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  bare.writeString(bc, x.sql);
+}
+function read14(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 write14(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteBindParam(bc, x[i]);
+  }
+}
+function read15(bc) {
+  return bare.readBool(bc) ? read14(bc) : null;
+}
+function write15(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    write14(bc, x);
+  }
+}
+function readSqliteExecuteRequest(bc) {
+  return {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    sql: bare.readString(bc),
+    params: read15(bc)
+  };
+}
+function writeSqliteExecuteRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  bare.writeString(bc, x.sql);
+  write15(bc, x.params);
+}
+function readSqliteExecuteWriteRequest(bc) {
+  return {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    sql: bare.readString(bc),
+    params: read15(bc)
+  };
+}
+function writeSqliteExecuteWriteRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  bare.writeString(bc, x.sql);
+  write15(bc, x.params);
+}
+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 readSqliteExecuteWriteOk(bc) {
+  return {
+    result: readSqliteExecuteResult(bc)
+  };
+}
+function writeSqliteExecuteWriteOk(bc, x) {
+  writeSqliteExecuteResult(bc, x.result);
+}
+function readSqliteExecResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteExecOk", val: readSqliteExecOk(bc) };
+    case 1:
+      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    case 2:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteExecOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteExecOk(bc, x.val);
+      break;
+    }
+    case "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 2);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+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: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    case 2:
+      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 "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 2);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteExecuteWriteResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteExecuteWriteOk", val: readSqliteExecuteWriteOk(bc) };
+    case 1:
+      return { tag: "SqliteFenceMismatch", val: readSqliteFenceMismatch(bc) };
+    case 2:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecuteWriteResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteExecuteWriteOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteExecuteWriteOk(bc, x.val);
+      break;
+    }
+    case "SqliteFenceMismatch": {
+      bare.writeU8(bc, 1);
+      writeSqliteFenceMismatch(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 2);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
 var StopCode = /* @__PURE__ */ ((StopCode2) => {
   StopCode2["Ok"] = "Ok";
   StopCode2["Error"] = "Error";
@@ -1036,19 +1492,19 @@ function readActorName(bc) {
 function writeActorName(bc, x) {
   writeJson(bc, x.metadata);
 }
-function read10(bc) {
+function read16(bc) {
   return bare.readBool(bc) ? bare.readString(bc) : null;
 }
-function write10(bc, x) {
+function write16(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeString(bc, x);
   }
 }
-function read11(bc) {
+function read17(bc) {
   return bare.readBool(bc) ? bare.readData(bc) : null;
 }
-function write11(bc, x) {
+function write17(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeData(bc, x);
@@ -1057,16 +1513,16 @@ function write11(bc, x) {
 function readActorConfig(bc) {
   return {
     name: bare.readString(bc),
-    key: read10(bc),
+    key: read16(bc),
     createTs: bare.readI64(bc),
-    input: read11(bc)
+    input: read17(bc)
   };
 }
 function writeActorConfig(bc, x) {
   bare.writeString(bc, x.name);
-  write10(bc, x.key);
+  write16(bc, x.key);
   bare.writeI64(bc, x.createTs);
-  write11(bc, x.input);
+  write17(bc, x.input);
 }
 function readActorCheckpoint(bc) {
   return {
@@ -1109,12 +1565,12 @@ function writeActorIntent(bc, x) {
 function readActorStateStopped(bc) {
   return {
     code: readStopCode(bc),
-    message: read10(bc)
+    message: read16(bc)
   };
 }
 function writeActorStateStopped(bc, x) {
   writeStopCode(bc, x.code);
-  write10(bc, x.message);
+  write16(bc, x.message);
 }
 function readActorState(bc) {
   const offset = bc.offset;
@@ -1159,22 +1615,13 @@ function readEventActorStateUpdate(bc) {
 function writeEventActorStateUpdate(bc, x) {
   writeActorState(bc, x.state);
 }
-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 readEventActorSetAlarm(bc) {
   return {
-    alarmTs: read12(bc)
+    alarmTs: read13(bc)
   };
 }
 function writeEventActorSetAlarm(bc, x) {
-  write12(bc, x.alarmTs);
+  write13(bc, x.alarmTs);
 }
 function readEvent(bc) {
   const offset = bc.offset;
@@ -1233,7 +1680,7 @@ function writePreloadedKvEntry(bc, x) {
   writeKvValue(bc, x.value);
   writeKvMetadata(bc, x.metadata);
 }
-function read13(bc) {
+function read18(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1244,7 +1691,7 @@ function read13(bc) {
   }
   return result;
 }
-function write13(bc, x) {
+function write18(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePreloadedKvEntry(bc, x[i]);
@@ -1252,13 +1699,13 @@ function write13(bc, x) {
 }
 function readPreloadedKv(bc) {
   return {
-    entries: read13(bc),
+    entries: read18(bc),
     requestedGetKeys: read0(bc),
     requestedPrefixes: read0(bc)
   };
 }
 function writePreloadedKv(bc, x) {
-  write13(bc, x.entries);
+  write18(bc, x.entries);
   write0(bc, x.requestedGetKeys);
   write0(bc, x.requestedPrefixes);
 }
@@ -1272,7 +1719,7 @@ function writeHibernatingRequest(bc, x) {
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
 }
-function read14(bc) {
+function read19(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1283,25 +1730,25 @@ function read14(bc) {
   }
   return result;
 }
-function write14(bc, x) {
+function write19(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeHibernatingRequest(bc, x[i]);
   }
 }
-function read15(bc) {
+function read20(bc) {
   return bare.readBool(bc) ? readPreloadedKv(bc) : null;
 }
-function write15(bc, x) {
+function write20(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writePreloadedKv(bc, x);
   }
 }
-function read16(bc) {
+function read21(bc) {
   return bare.readBool(bc) ? readSqliteStartupData(bc) : null;
 }
-function write16(bc, x) {
+function write21(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeSqliteStartupData(bc, x);
@@ -1310,16 +1757,16 @@ function write16(bc, x) {
 function readCommandStartActor(bc) {
   return {
     config: readActorConfig(bc),
-    hibernatingRequests: read14(bc),
-    preloadedKv: read15(bc),
-    sqliteStartupData: read16(bc)
+    hibernatingRequests: read19(bc),
+    preloadedKv: read20(bc),
+    sqliteStartupData: read21(bc)
   };
 }
 function writeCommandStartActor(bc, x) {
   writeActorConfig(bc, x.config);
-  write14(bc, x.hibernatingRequests);
-  write15(bc, x.preloadedKv);
-  write16(bc, x.sqliteStartupData);
+  write19(bc, x.hibernatingRequests);
+  write20(bc, x.preloadedKv);
+  write21(bc, x.sqliteStartupData);
 }
 var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
   StopActorReason2["SleepIntent"] = "SleepIntent";
@@ -1476,7 +1923,7 @@ function writeMessageId(bc, x) {
   writeRequestId(bc, x.requestId);
   writeMessageIndex(bc, x.messageIndex);
 }
-function read17(bc) {
+function read22(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1490,7 +1937,7 @@ function read17(bc) {
   }
   return result;
 }
-function write17(bc, x) {
+function write22(bc, x) {
   bare.writeUintSafe(bc, x.size);
   for (const kv of x) {
     bare.writeString(bc, kv[0]);
@@ -1502,8 +1949,8 @@ function readToEnvoyRequestStart(bc) {
     actorId: readId(bc),
     method: bare.readString(bc),
     path: bare.readString(bc),
-    headers: read17(bc),
-    body: read11(bc),
+    headers: read22(bc),
+    body: read17(bc),
     stream: bare.readBool(bc)
   };
 }
@@ -1511,8 +1958,8 @@ function writeToEnvoyRequestStart(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.method);
   bare.writeString(bc, x.path);
-  write17(bc, x.headers);
-  write11(bc, x.body);
+  write22(bc, x.headers);
+  write17(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToEnvoyRequestChunk(bc) {
@@ -1528,15 +1975,15 @@ function writeToEnvoyRequestChunk(bc, x) {
 function readToRivetResponseStart(bc) {
   return {
     status: bare.readU16(bc),
-    headers: read17(bc),
-    body: read11(bc),
+    headers: read22(bc),
+    body: read17(bc),
     stream: bare.readBool(bc)
   };
 }
 function writeToRivetResponseStart(bc, x) {
   bare.writeU16(bc, x.status);
-  write17(bc, x.headers);
-  write11(bc, x.body);
+  write22(bc, x.headers);
+  write17(bc, x.body);
   bare.writeBool(bc, x.stream);
 }
 function readToRivetResponseChunk(bc) {
@@ -1553,13 +2000,13 @@ function readToEnvoyWebSocketOpen(bc) {
   return {
     actorId: readId(bc),
     path: bare.readString(bc),
-    headers: read17(bc)
+    headers: read22(bc)
   };
 }
 function writeToEnvoyWebSocketOpen(bc, x) {
   writeId(bc, x.actorId);
   bare.writeString(bc, x.path);
-  write17(bc, x.headers);
+  write22(bc, x.headers);
 }
 function readToEnvoyWebSocketMessage(bc) {
   return {
@@ -1571,10 +2018,10 @@ function writeToEnvoyWebSocketMessage(bc, x) {
   bare.writeData(bc, x.data);
   bare.writeBool(bc, x.binary);
 }
-function read18(bc) {
+function read23(bc) {
   return bare.readBool(bc) ? bare.readU16(bc) : null;
 }
-function write18(bc, x) {
+function write23(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     bare.writeU16(bc, x);
@@ -1582,13 +2029,13 @@ function write18(bc, x) {
 }
 function readToEnvoyWebSocketClose(bc) {
   return {
-    code: read18(bc),
-    reason: read10(bc)
+    code: read23(bc),
+    reason: read16(bc)
   };
 }
 function writeToEnvoyWebSocketClose(bc, x) {
-  write18(bc, x.code);
-  write10(bc, x.reason);
+  write23(bc, x.code);
+  write16(bc, x.reason);
 }
 function readToRivetWebSocketOpen(bc) {
   return {
@@ -1618,14 +2065,14 @@ function writeToRivetWebSocketMessageAck(bc, x) {
 }
 function readToRivetWebSocketClose(bc) {
   return {
-    code: read18(bc),
-    reason: read10(bc),
+    code: read23(bc),
+    reason: read16(bc),
     hibernate: bare.readBool(bc)
   };
 }
 function writeToRivetWebSocketClose(bc, x) {
-  write18(bc, x.code);
-  write10(bc, x.reason);
+  write23(bc, x.code);
+  write16(bc, x.reason);
   bare.writeBool(bc, x.hibernate);
 }
 function readToRivetTunnelMessageKind(bc) {
@@ -1773,7 +2220,7 @@ function readToEnvoyPing(bc) {
 function writeToEnvoyPing(bc, x) {
   bare.writeI64(bc, x.ts);
 }
-function read19(bc) {
+function read24(bc) {
   const len = bare.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
@@ -1787,26 +2234,26 @@ function read19(bc) {
   }
   return result;
 }
-function write19(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 read20(bc) {
-  return bare.readBool(bc) ? read19(bc) : null;
+function read25(bc) {
+  return bare.readBool(bc) ? read24(bc) : null;
 }
-function write20(bc, x) {
+function write25(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
-    write19(bc, x);
+    write24(bc, x);
   }
 }
-function read21(bc) {
+function read26(bc) {
   return bare.readBool(bc) ? readJson(bc) : null;
 }
-function write21(bc, x) {
+function write26(bc, x) {
   bare.writeBool(bc, x != null);
   if (x != null) {
     writeJson(bc, x);
@@ -1814,13 +2261,13 @@ function write21(bc, x) {
 }
 function readToRivetMetadata(bc) {
   return {
-    prepopulateActorNames: read20(bc),
-    metadata: read21(bc)
+    prepopulateActorNames: read25(bc),
+    metadata: read26(bc)
   };
 }
 function writeToRivetMetadata(bc, x) {
-  write20(bc, x.prepopulateActorNames);
-  write21(bc, x.metadata);
+  write25(bc, x.prepopulateActorNames);
+  write26(bc, x.metadata);
 }
 function readToRivetEvents(bc) {
   const len = bare.readUintSafe(bc);
@@ -1839,7 +2286,7 @@ function writeToRivetEvents(bc, x) {
     writeEventWrapper(bc, x[i]);
   }
 }
-function read22(bc) {
+function read27(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
     return [];
@@ -1850,7 +2297,7 @@ function read22(bc) {
   }
   return result;
 }
-function write22(bc, x) {
+function write27(bc, x) {
   bare.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeActorCheckpoint(bc, x[i]);
@@ -1858,11 +2305,11 @@ function write22(bc, x) {
 }
 function readToRivetAckCommands(bc) {
   return {
-    lastCommandCheckpoints: read22(bc)
+    lastCommandCheckpoints: read27(bc)
   };
 }
 function writeToRivetAckCommands(bc, x) {
-  write22(bc, x.lastCommandCheckpoints);
+  write27(bc, x.lastCommandCheckpoints);
 }
 function readToRivetPong(bc) {
   return {
@@ -1954,6 +2401,36 @@ function writeToRivetSqlitePersistPreloadHintsRequest(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqlitePersistPreloadHintsRequest(bc, x.data);
 }
+function readToRivetSqliteExecRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecRequest(bc)
+  };
+}
+function writeToRivetSqliteExecRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecRequest(bc, x.data);
+}
+function readToRivetSqliteExecuteRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteRequest(bc)
+  };
+}
+function writeToRivetSqliteExecuteRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteRequest(bc, x.data);
+}
+function readToRivetSqliteExecuteWriteRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteWriteRequest(bc)
+  };
+}
+function writeToRivetSqliteExecuteWriteRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteWriteRequest(bc, x.data);
+}
 function readToRivet(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -1986,6 +2463,12 @@ function readToRivet(bc) {
       return { tag: "ToRivetSqliteCommitFinalizeRequest", val: readToRivetSqliteCommitFinalizeRequest(bc) };
     case 13:
       return { tag: "ToRivetSqlitePersistPreloadHintsRequest", val: readToRivetSqlitePersistPreloadHintsRequest(bc) };
+    case 14:
+      return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) };
+    case 15:
+      return { tag: "ToRivetSqliteExecuteRequest", val: readToRivetSqliteExecuteRequest(bc) };
+    case 16:
+      return { tag: "ToRivetSqliteExecuteWriteRequest", val: readToRivetSqliteExecuteWriteRequest(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -2063,6 +2546,21 @@ function writeToRivet(bc, x) {
       writeToRivetSqlitePersistPreloadHintsRequest(bc, x.val);
       break;
     }
+    case "ToRivetSqliteExecRequest": {
+      bare.writeU8(bc, 14);
+      writeToRivetSqliteExecRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecuteRequest": {
+      bare.writeU8(bc, 15);
+      writeToRivetSqliteExecuteRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecuteWriteRequest": {
+      bare.writeU8(bc, 16);
+      writeToRivetSqliteExecuteWriteRequest(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToRivet(x, config) {
@@ -2121,11 +2619,11 @@ function writeToEnvoyCommands(bc, x) {
 }
 function readToEnvoyAckEvents(bc) {
   return {
-    lastEventCheckpoints: read22(bc)
+    lastEventCheckpoints: read27(bc)
   };
 }
 function writeToEnvoyAckEvents(bc, x) {
-  write22(bc, x.lastEventCheckpoints);
+  write27(bc, x.lastEventCheckpoints);
 }
 function readToEnvoyKvResponse(bc) {
   return {
@@ -2207,6 +2705,36 @@ function writeToEnvoySqlitePersistPreloadHintsResponse(bc, x) {
   bare.writeU32(bc, x.requestId);
   writeSqlitePersistPreloadHintsResponse(bc, x.data);
 }
+function readToEnvoySqliteExecResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecResponse(bc)
+  };
+}
+function writeToEnvoySqliteExecResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecResponse(bc, x.data);
+}
+function readToEnvoySqliteExecuteResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteResponse(bc)
+  };
+}
+function writeToEnvoySqliteExecuteResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteResponse(bc, x.data);
+}
+function readToEnvoySqliteExecuteWriteResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteWriteResponse(bc)
+  };
+}
+function writeToEnvoySqliteExecuteWriteResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteWriteResponse(bc, x.data);
+}
 function readToEnvoy(bc) {
   const offset = bc.offset;
   const tag = bare.readU8(bc);
@@ -2237,6 +2765,12 @@ function readToEnvoy(bc) {
       return { tag: "ToEnvoySqliteCommitFinalizeResponse", val: readToEnvoySqliteCommitFinalizeResponse(bc) };
     case 12:
       return { tag: "ToEnvoySqlitePersistPreloadHintsResponse", val: readToEnvoySqlitePersistPreloadHintsResponse(bc) };
+    case 13:
+      return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) };
+    case 14:
+      return { tag: "ToEnvoySqliteExecuteResponse", val: readToEnvoySqliteExecuteResponse(bc) };
+    case 15:
+      return { tag: "ToEnvoySqliteExecuteWriteResponse", val: readToEnvoySqliteExecuteWriteResponse(bc) };
     default: {
       bc.offset = offset;
       throw new bare.BareError(offset, "invalid tag");
@@ -2310,6 +2844,21 @@ function writeToEnvoy(bc, x) {
       writeToEnvoySqlitePersistPreloadHintsResponse(bc, x.val);
       break;
     }
+    case "ToEnvoySqliteExecResponse": {
+      bare.writeU8(bc, 13);
+      writeToEnvoySqliteExecResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecuteResponse": {
+      bare.writeU8(bc, 14);
+      writeToEnvoySqliteExecuteResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecuteWriteResponse": {
+      bare.writeU8(bc, 15);
+      writeToEnvoySqliteExecuteWriteResponse(bc, x.val);
+      break;
+    }
   }
 }
 function encodeToEnvoy(x, config) {
@@ -2516,8 +3065,9 @@ function decodeToOutbound(bytes) {
 function assert(condition, message) {
   if (!condition) throw new Error(message ?? "Assertion failed");
 }
-var VERSION = 3;
+var VERSION = 4;
 export {
+  SqliteExecuteRoute,
   StopActorReason,
   StopCode,
   VERSION,
@@ -2575,6 +3125,8 @@ export {
   readPreloadedKvEntry,
   readProtocolMetadata,
   readRequestId,
+  readSqliteBindParam,
+  readSqliteColumnValue,
   readSqliteCommitFinalizeOk,
   readSqliteCommitFinalizeRequest,
   readSqliteCommitFinalizeResponse,
@@ -2590,6 +3142,17 @@ export {
   readSqliteCommitTooLarge,
   readSqliteDirtyPage,
   readSqliteErrorResponse,
+  readSqliteExecOk,
+  readSqliteExecRequest,
+  readSqliteExecResponse,
+  readSqliteExecuteOk,
+  readSqliteExecuteRequest,
+  readSqliteExecuteResponse,
+  readSqliteExecuteResult,
+  readSqliteExecuteRoute,
+  readSqliteExecuteWriteOk,
+  readSqliteExecuteWriteRequest,
+  readSqliteExecuteWriteResponse,
   readSqliteFenceMismatch,
   readSqliteFetchedPage,
   readSqliteGeneration,
@@ -2606,10 +3169,15 @@ export {
   readSqlitePgno,
   readSqlitePreloadHintRange,
   readSqlitePreloadHints,
+  readSqliteQueryResult,
   readSqliteStageId,
   readSqliteStageNotFound,
   readSqliteStartupData,
   readSqliteTxid,
+  readSqliteValueBlob,
+  readSqliteValueFloat,
+  readSqliteValueInteger,
+  readSqliteValueText,
   readStopActorReason,
   readStopCode,
   readToEnvoy,
@@ -2626,6 +3194,9 @@ export {
   readToEnvoySqliteCommitResponse,
   readToEnvoySqliteCommitStageBeginResponse,
   readToEnvoySqliteCommitStageResponse,
+  readToEnvoySqliteExecResponse,
+  readToEnvoySqliteExecuteResponse,
+  readToEnvoySqliteExecuteWriteResponse,
   readToEnvoySqliteGetPageRangeResponse,
   readToEnvoySqliteGetPagesResponse,
   readToEnvoySqlitePersistPreloadHintsResponse,
@@ -2650,6 +3221,9 @@ export {
   readToRivetSqliteCommitRequest,
   readToRivetSqliteCommitStageBeginRequest,
   readToRivetSqliteCommitStageRequest,
+  readToRivetSqliteExecRequest,
+  readToRivetSqliteExecuteRequest,
+  readToRivetSqliteExecuteWriteRequest,
   readToRivetSqliteGetPageRangeRequest,
   readToRivetSqliteGetPagesRequest,
   readToRivetSqlitePersistPreloadHintsRequest,
@@ -2701,6 +3275,8 @@ export {
   writePreloadedKvEntry,
   writeProtocolMetadata,
   writeRequestId,
+  writeSqliteBindParam,
+  writeSqliteColumnValue,
   writeSqliteCommitFinalizeOk,
   writeSqliteCommitFinalizeRequest,
   writeSqliteCommitFinalizeResponse,
@@ -2716,6 +3292,17 @@ export {
   writeSqliteCommitTooLarge,
   writeSqliteDirtyPage,
   writeSqliteErrorResponse,
+  writeSqliteExecOk,
+  writeSqliteExecRequest,
+  writeSqliteExecResponse,
+  writeSqliteExecuteOk,
+  writeSqliteExecuteRequest,
+  writeSqliteExecuteResponse,
+  writeSqliteExecuteResult,
+  writeSqliteExecuteRoute,
+  writeSqliteExecuteWriteOk,
+  writeSqliteExecuteWriteRequest,
+  writeSqliteExecuteWriteResponse,
   writeSqliteFenceMismatch,
   writeSqliteFetchedPage,
   writeSqliteGeneration,
@@ -2732,10 +3319,15 @@ export {
   writeSqlitePgno,
   writeSqlitePreloadHintRange,
   writeSqlitePreloadHints,
+  writeSqliteQueryResult,
   writeSqliteStageId,
   writeSqliteStageNotFound,
   writeSqliteStartupData,
   writeSqliteTxid,
+  writeSqliteValueBlob,
+  writeSqliteValueFloat,
+  writeSqliteValueInteger,
+  writeSqliteValueText,
   writeStopActorReason,
   writeStopCode,
   writeToEnvoy,
@@ -2752,6 +3344,9 @@ export {
   writeToEnvoySqliteCommitResponse,
   writeToEnvoySqliteCommitStageBeginResponse,
   writeToEnvoySqliteCommitStageResponse,
+  writeToEnvoySqliteExecResponse,
+  writeToEnvoySqliteExecuteResponse,
+  writeToEnvoySqliteExecuteWriteResponse,
   writeToEnvoySqliteGetPageRangeResponse,
   writeToEnvoySqliteGetPagesResponse,
   writeToEnvoySqlitePersistPreloadHintsResponse,
@@ -2776,6 +3371,9 @@ export {
   writeToRivetSqliteCommitRequest,
   writeToRivetSqliteCommitStageBeginRequest,
   writeToRivetSqliteCommitStageRequest,
+  writeToRivetSqliteExecRequest,
+  writeToRivetSqliteExecuteRequest,
+  writeToRivetSqliteExecuteWriteRequest,
   writeToRivetSqliteGetPageRangeRequest,
   writeToRivetSqliteGetPagesRequest,
   writeToRivetSqlitePersistPreloadHintsRequest,