@rivetkit/engine-envoy-protocol 0.0.0-0-0-0-preview-guard-stops.9d82529

package/dist/index.js

@@ -0,0 +1,3147 @@
+// src/index.ts
+import * as bare from "@rivetkit/bare-ts";
+var DEFAULT_CONFIG = /* @__PURE__ */ bare.Config({});
+function readId(bc) {
+  return bare.readString(bc);
+}
+function writeId(bc, x) {
+  bare.writeString(bc, x);
+}
+function readJson(bc) {
+  return bare.readString(bc);
+}
+function writeJson(bc, x) {
+  bare.writeString(bc, x);
+}
+function readGatewayId(bc) {
+  return bare.readFixedData(bc, 4);
+}
+function writeGatewayId(bc, x) {
+  assert(x.byteLength === 4);
+  bare.writeFixedData(bc, x);
+}
+function readRequestId(bc) {
+  return bare.readFixedData(bc, 4);
+}
+function writeRequestId(bc, x) {
+  assert(x.byteLength === 4);
+  bare.writeFixedData(bc, x);
+}
+function readMessageIndex(bc) {
+  return bare.readU16(bc);
+}
+function writeMessageIndex(bc, x) {
+  bare.writeU16(bc, x);
+}
+function readKvKey(bc) {
+  return bare.readData(bc);
+}
+function writeKvKey(bc, x) {
+  bare.writeData(bc, x);
+}
+function readKvValue(bc) {
+  return bare.readData(bc);
+}
+function writeKvValue(bc, x) {
+  bare.writeData(bc, x);
+}
+function readKvMetadata(bc) {
+  return {
+    version: bare.readData(bc),
+    updateTs: bare.readI64(bc)
+  };
+}
+function writeKvMetadata(bc, x) {
+  bare.writeData(bc, x.version);
+  bare.writeI64(bc, x.updateTs);
+}
+function readKvListRangeQuery(bc) {
+  return {
+    start: readKvKey(bc),
+    end: readKvKey(bc),
+    exclusive: bare.readBool(bc)
+  };
+}
+function writeKvListRangeQuery(bc, x) {
+  writeKvKey(bc, x.start);
+  writeKvKey(bc, x.end);
+  bare.writeBool(bc, x.exclusive);
+}
+function readKvListPrefixQuery(bc) {
+  return {
+    key: readKvKey(bc)
+  };
+}
+function writeKvListPrefixQuery(bc, x) {
+  writeKvKey(bc, x.key);
+}
+function readKvListQuery(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "KvListAllQuery", val: null };
+    case 1:
+      return { tag: "KvListRangeQuery", val: readKvListRangeQuery(bc) };
+    case 2:
+      return { tag: "KvListPrefixQuery", val: readKvListPrefixQuery(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeKvListQuery(bc, x) {
+  switch (x.tag) {
+    case "KvListAllQuery": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "KvListRangeQuery": {
+      bare.writeU8(bc, 1);
+      writeKvListRangeQuery(bc, x.val);
+      break;
+    }
+    case "KvListPrefixQuery": {
+      bare.writeU8(bc, 2);
+      writeKvListPrefixQuery(bc, x.val);
+      break;
+    }
+  }
+}
+function read0(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readKvKey(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readKvKey(bc);
+  }
+  return result;
+}
+function write0(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvKey(bc, x[i]);
+  }
+}
+function readKvGetRequest(bc) {
+  return {
+    keys: read0(bc)
+  };
+}
+function writeKvGetRequest(bc, x) {
+  write0(bc, x.keys);
+}
+function read1(bc) {
+  return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write1(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeBool(bc, x);
+  }
+}
+function read2(bc) {
+  return bare.readBool(bc) ? bare.readU64(bc) : null;
+}
+function write2(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU64(bc, x);
+  }
+}
+function readKvListRequest(bc) {
+  return {
+    query: readKvListQuery(bc),
+    reverse: read1(bc),
+    limit: read2(bc)
+  };
+}
+function writeKvListRequest(bc, x) {
+  writeKvListQuery(bc, x.query);
+  write1(bc, x.reverse);
+  write2(bc, x.limit);
+}
+function read3(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readKvValue(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readKvValue(bc);
+  }
+  return result;
+}
+function write3(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvValue(bc, x[i]);
+  }
+}
+function readKvPutRequest(bc) {
+  return {
+    keys: read0(bc),
+    values: read3(bc)
+  };
+}
+function writeKvPutRequest(bc, x) {
+  write0(bc, x.keys);
+  write3(bc, x.values);
+}
+function readKvDeleteRequest(bc) {
+  return {
+    keys: read0(bc)
+  };
+}
+function writeKvDeleteRequest(bc, x) {
+  write0(bc, x.keys);
+}
+function readKvDeleteRangeRequest(bc) {
+  return {
+    start: readKvKey(bc),
+    end: readKvKey(bc)
+  };
+}
+function writeKvDeleteRangeRequest(bc, x) {
+  writeKvKey(bc, x.start);
+  writeKvKey(bc, x.end);
+}
+function readKvErrorResponse(bc) {
+  return {
+    message: bare.readString(bc)
+  };
+}
+function writeKvErrorResponse(bc, x) {
+  bare.writeString(bc, x.message);
+}
+function read4(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readKvMetadata(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readKvMetadata(bc);
+  }
+  return result;
+}
+function write4(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvMetadata(bc, x[i]);
+  }
+}
+function readKvGetResponse(bc) {
+  return {
+    keys: read0(bc),
+    values: read3(bc),
+    metadata: read4(bc)
+  };
+}
+function writeKvGetResponse(bc, x) {
+  write0(bc, x.keys);
+  write3(bc, x.values);
+  write4(bc, x.metadata);
+}
+function readKvListResponse(bc) {
+  return {
+    keys: read0(bc),
+    values: read3(bc),
+    metadata: read4(bc)
+  };
+}
+function writeKvListResponse(bc, x) {
+  write0(bc, x.keys);
+  write3(bc, x.values);
+  write4(bc, x.metadata);
+}
+function readKvRequestData(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "KvGetRequest", val: readKvGetRequest(bc) };
+    case 1:
+      return { tag: "KvListRequest", val: readKvListRequest(bc) };
+    case 2:
+      return { tag: "KvPutRequest", val: readKvPutRequest(bc) };
+    case 3:
+      return { tag: "KvDeleteRequest", val: readKvDeleteRequest(bc) };
+    case 4:
+      return { tag: "KvDeleteRangeRequest", val: readKvDeleteRangeRequest(bc) };
+    case 5:
+      return { tag: "KvDropRequest", val: null };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeKvRequestData(bc, x) {
+  switch (x.tag) {
+    case "KvGetRequest": {
+      bare.writeU8(bc, 0);
+      writeKvGetRequest(bc, x.val);
+      break;
+    }
+    case "KvListRequest": {
+      bare.writeU8(bc, 1);
+      writeKvListRequest(bc, x.val);
+      break;
+    }
+    case "KvPutRequest": {
+      bare.writeU8(bc, 2);
+      writeKvPutRequest(bc, x.val);
+      break;
+    }
+    case "KvDeleteRequest": {
+      bare.writeU8(bc, 3);
+      writeKvDeleteRequest(bc, x.val);
+      break;
+    }
+    case "KvDeleteRangeRequest": {
+      bare.writeU8(bc, 4);
+      writeKvDeleteRangeRequest(bc, x.val);
+      break;
+    }
+    case "KvDropRequest": {
+      bare.writeU8(bc, 5);
+      break;
+    }
+  }
+}
+function readKvResponseData(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "KvErrorResponse", val: readKvErrorResponse(bc) };
+    case 1:
+      return { tag: "KvGetResponse", val: readKvGetResponse(bc) };
+    case 2:
+      return { tag: "KvListResponse", val: readKvListResponse(bc) };
+    case 3:
+      return { tag: "KvPutResponse", val: null };
+    case 4:
+      return { tag: "KvDeleteResponse", val: null };
+    case 5:
+      return { tag: "KvDropResponse", val: null };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeKvResponseData(bc, x) {
+  switch (x.tag) {
+    case "KvErrorResponse": {
+      bare.writeU8(bc, 0);
+      writeKvErrorResponse(bc, x.val);
+      break;
+    }
+    case "KvGetResponse": {
+      bare.writeU8(bc, 1);
+      writeKvGetResponse(bc, x.val);
+      break;
+    }
+    case "KvListResponse": {
+      bare.writeU8(bc, 2);
+      writeKvListResponse(bc, x.val);
+      break;
+    }
+    case "KvPutResponse": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "KvDeleteResponse": {
+      bare.writeU8(bc, 4);
+      break;
+    }
+    case "KvDropResponse": {
+      bare.writeU8(bc, 5);
+      break;
+    }
+  }
+}
+function readSqlitePgno(bc) {
+  return bare.readU32(bc);
+}
+function writeSqlitePgno(bc, x) {
+  bare.writeU32(bc, x);
+}
+function readSqliteGeneration(bc) {
+  return bare.readU64(bc);
+}
+function writeSqliteGeneration(bc, x) {
+  bare.writeU64(bc, x);
+}
+function readSqlitePageBytes(bc) {
+  return bare.readData(bc);
+}
+function writeSqlitePageBytes(bc, x) {
+  bare.writeData(bc, x);
+}
+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),
+    pgnos: read6(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
+  };
+}
+function writeSqliteGetPagesRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write6(bc, x.pgnos);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
+}
+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),
+    headTxid: read2(bc)
+  };
+}
+function writeSqliteGetPagesOk(bc, x) {
+  write7(bc, x.pages);
+  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) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteGetPagesOk", val: readSqliteGetPagesOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(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 "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(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),
+    dirtyPages: read8(bc),
+    dbSizePages: bare.readU32(bc),
+    nowMs: bare.readI64(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
+  };
+}
+function writeSqliteCommitRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write8(bc, x.dirtyPages);
+  bare.writeU32(bc, x.dbSizePages);
+  bare.writeI64(bc, x.nowMs);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
+}
+function readSqliteCommitOk(bc) {
+  return {
+    headTxid: read2(bc)
+  };
+}
+function writeSqliteCommitOk(bc, x) {
+  write2(bc, x.headTxid);
+}
+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: "SqliteErrorResponse", val: readSqliteErrorResponse(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 "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitStageBeginRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    expectedHeadTxid: read2(bc)
+  };
+}
+function writeSqliteCommitStageBeginRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  write2(bc, x.expectedHeadTxid);
+}
+function readSqliteCommitStageBeginOk(bc) {
+  return {
+    txid: bare.readU64(bc)
+  };
+}
+function writeSqliteCommitStageBeginOk(bc, x) {
+  bare.writeU64(bc, x.txid);
+}
+function readSqliteCommitStageBeginResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitStageBeginOk", val: readSqliteCommitStageBeginOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitStageBeginResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitStageBeginOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitStageBeginOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitStageSegmentRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    txid: bare.readU64(bc),
+    firstPgno: bare.readU32(bc),
+    dirtyPages: read8(bc)
+  };
+}
+function writeSqliteCommitStageSegmentRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  bare.writeU64(bc, x.txid);
+  bare.writeU32(bc, x.firstPgno);
+  write8(bc, x.dirtyPages);
+}
+function readSqliteCommitStageSegmentOk(bc) {
+  return {
+    stagedBytes: bare.readU64(bc)
+  };
+}
+function writeSqliteCommitStageSegmentOk(bc, x) {
+  bare.writeU64(bc, x.stagedBytes);
+}
+function readSqliteCommitStageSegmentResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitStageSegmentOk", val: readSqliteCommitStageSegmentOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitStageSegmentResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitStageSegmentOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitStageSegmentOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteCommitFinalizeRequest(bc) {
+  return {
+    actorId: readId(bc),
+    expectedGeneration: read2(bc),
+    txid: bare.readU64(bc),
+    newDbSizePages: bare.readU32(bc),
+    nowMs: bare.readI64(bc),
+    segmentFirstPgnos: bare.readU32Array(bc)
+  };
+}
+function writeSqliteCommitFinalizeRequest(bc, x) {
+  writeId(bc, x.actorId);
+  write2(bc, x.expectedGeneration);
+  bare.writeU64(bc, x.txid);
+  bare.writeU32(bc, x.newDbSizePages);
+  bare.writeI64(bc, x.nowMs);
+  bare.writeU32Array(bc, x.segmentFirstPgnos);
+}
+function readSqliteCommitFinalizeOk(bc) {
+  return {
+    headTxid: read2(bc)
+  };
+}
+function writeSqliteCommitFinalizeOk(bc, x) {
+  write2(bc, x.headTxid);
+}
+function readSqliteCommitFinalizeResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteCommitFinalizeOk", val: readSqliteCommitFinalizeOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteCommitFinalizeResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteCommitFinalizeOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteCommitFinalizeOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteValueInteger(bc) {
+  return {
+    value: bare.readI64(bc)
+  };
+}
+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 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),
+    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 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 {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    sql: bare.readString(bc),
+    params: read14(bc)
+  };
+}
+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 readSqliteBatchStatement(bc) {
+  return {
+    sql: bare.readString(bc),
+    params: read14(bc)
+  };
+}
+function writeSqliteBatchStatement(bc, x) {
+  bare.writeString(bc, x.sql);
+  write14(bc, x.params);
+}
+function read15(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSqliteBatchStatement(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSqliteBatchStatement(bc);
+  }
+  return result;
+}
+function write15(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSqliteBatchStatement(bc, x[i]);
+  }
+}
+function readSqliteExecuteBatchRequest(bc) {
+  return {
+    namespaceId: readId(bc),
+    actorId: readId(bc),
+    generation: readSqliteGeneration(bc),
+    statements: read15(bc)
+  };
+}
+function writeSqliteExecuteBatchRequest(bc, x) {
+  writeId(bc, x.namespaceId);
+  writeId(bc, x.actorId);
+  writeSqliteGeneration(bc, x.generation);
+  write15(bc, x.statements);
+}
+function readSqliteExecOk(bc) {
+  return {
+    result: readSqliteQueryResult(bc)
+  };
+}
+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: "SqliteExecOk", val: readSqliteExecOk(bc) };
+    case 1:
+      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 "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      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: "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, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function readSqliteExecuteBatchResponse(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "SqliteExecuteBatchOk", val: readSqliteExecuteBatchOk(bc) };
+    case 1:
+      return { tag: "SqliteErrorResponse", val: readSqliteErrorResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeSqliteExecuteBatchResponse(bc, x) {
+  switch (x.tag) {
+    case "SqliteExecuteBatchOk": {
+      bare.writeU8(bc, 0);
+      writeSqliteExecuteBatchOk(bc, x.val);
+      break;
+    }
+    case "SqliteErrorResponse": {
+      bare.writeU8(bc, 1);
+      writeSqliteErrorResponse(bc, x.val);
+      break;
+    }
+  }
+}
+var StopCode = /* @__PURE__ */ ((StopCode2) => {
+  StopCode2["Ok"] = "Ok";
+  StopCode2["Error"] = "Error";
+  return StopCode2;
+})(StopCode || {});
+function readStopCode(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "Ok" /* Ok */;
+    case 1:
+      return "Error" /* Error */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeStopCode(bc, x) {
+  switch (x) {
+    case "Ok" /* Ok */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "Error" /* Error */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+  }
+}
+function readActorName(bc) {
+  return {
+    metadata: readJson(bc)
+  };
+}
+function writeActorName(bc, x) {
+  writeJson(bc, x.metadata);
+}
+function read17(bc) {
+  return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write17(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeString(bc, x);
+  }
+}
+function read18(bc) {
+  return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write18(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeData(bc, x);
+  }
+}
+function readActorConfig(bc) {
+  return {
+    name: bare.readString(bc),
+    key: read17(bc),
+    createTs: bare.readI64(bc),
+    input: read18(bc)
+  };
+}
+function writeActorConfig(bc, x) {
+  bare.writeString(bc, x.name);
+  write17(bc, x.key);
+  bare.writeI64(bc, x.createTs);
+  write18(bc, x.input);
+}
+function readActorCheckpoint(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    index: bare.readI64(bc)
+  };
+}
+function writeActorCheckpoint(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  bare.writeI64(bc, x.index);
+}
+function readActorIntent(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActorIntentSleep", val: null };
+    case 1:
+      return { tag: "ActorIntentStop", val: null };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeActorIntent(bc, x) {
+  switch (x.tag) {
+    case "ActorIntentSleep": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "ActorIntentStop": {
+      bare.writeU8(bc, 1);
+      break;
+    }
+  }
+}
+function readActorStateStopped(bc) {
+  return {
+    code: readStopCode(bc),
+    message: read17(bc)
+  };
+}
+function writeActorStateStopped(bc, x) {
+  writeStopCode(bc, x.code);
+  write17(bc, x.message);
+}
+function readActorState(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActorStateRunning", val: null };
+    case 1:
+      return { tag: "ActorStateStopped", val: readActorStateStopped(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeActorState(bc, x) {
+  switch (x.tag) {
+    case "ActorStateRunning": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "ActorStateStopped": {
+      bare.writeU8(bc, 1);
+      writeActorStateStopped(bc, x.val);
+      break;
+    }
+  }
+}
+function readEventActorIntent(bc) {
+  return {
+    intent: readActorIntent(bc)
+  };
+}
+function writeEventActorIntent(bc, x) {
+  writeActorIntent(bc, x.intent);
+}
+function readEventActorStateUpdate(bc) {
+  return {
+    state: readActorState(bc)
+  };
+}
+function writeEventActorStateUpdate(bc, x) {
+  writeActorState(bc, x.state);
+}
+function readEventActorSetAlarm(bc) {
+  return {
+    alarmTs: read12(bc)
+  };
+}
+function writeEventActorSetAlarm(bc, x) {
+  write12(bc, x.alarmTs);
+}
+function readEvent(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "EventActorIntent", val: readEventActorIntent(bc) };
+    case 1:
+      return { tag: "EventActorStateUpdate", val: readEventActorStateUpdate(bc) };
+    case 2:
+      return { tag: "EventActorSetAlarm", val: readEventActorSetAlarm(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeEvent(bc, x) {
+  switch (x.tag) {
+    case "EventActorIntent": {
+      bare.writeU8(bc, 0);
+      writeEventActorIntent(bc, x.val);
+      break;
+    }
+    case "EventActorStateUpdate": {
+      bare.writeU8(bc, 1);
+      writeEventActorStateUpdate(bc, x.val);
+      break;
+    }
+    case "EventActorSetAlarm": {
+      bare.writeU8(bc, 2);
+      writeEventActorSetAlarm(bc, x.val);
+      break;
+    }
+  }
+}
+function readEventWrapper(bc) {
+  return {
+    checkpoint: readActorCheckpoint(bc),
+    inner: readEvent(bc)
+  };
+}
+function writeEventWrapper(bc, x) {
+  writeActorCheckpoint(bc, x.checkpoint);
+  writeEvent(bc, x.inner);
+}
+function readPreloadedKvEntry(bc) {
+  return {
+    key: readKvKey(bc),
+    value: readKvValue(bc),
+    metadata: readKvMetadata(bc)
+  };
+}
+function writePreloadedKvEntry(bc, x) {
+  writeKvKey(bc, x.key);
+  writeKvValue(bc, x.value);
+  writeKvMetadata(bc, x.metadata);
+}
+function read19(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPreloadedKvEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPreloadedKvEntry(bc);
+  }
+  return result;
+}
+function write19(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePreloadedKvEntry(bc, x[i]);
+  }
+}
+function readPreloadedKv(bc) {
+  return {
+    entries: read19(bc),
+    requestedGetKeys: read0(bc),
+    requestedPrefixes: read0(bc)
+  };
+}
+function writePreloadedKv(bc, x) {
+  write19(bc, x.entries);
+  write0(bc, x.requestedGetKeys);
+  write0(bc, x.requestedPrefixes);
+}
+function readHibernatingRequest(bc) {
+  return {
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc)
+  };
+}
+function writeHibernatingRequest(bc, x) {
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+}
+function read20(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readHibernatingRequest(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readHibernatingRequest(bc);
+  }
+  return result;
+}
+function write20(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeHibernatingRequest(bc, x[i]);
+  }
+}
+function read21(bc) {
+  return bare.readBool(bc) ? readPreloadedKv(bc) : null;
+}
+function write21(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writePreloadedKv(bc, x);
+  }
+}
+function readCommandStartActor(bc) {
+  return {
+    config: readActorConfig(bc),
+    hibernatingRequests: read20(bc),
+    preloadedKv: read21(bc)
+  };
+}
+function writeCommandStartActor(bc, x) {
+  writeActorConfig(bc, x.config);
+  write20(bc, x.hibernatingRequests);
+  write21(bc, x.preloadedKv);
+}
+var StopActorReason = /* @__PURE__ */ ((StopActorReason2) => {
+  StopActorReason2["SleepIntent"] = "SleepIntent";
+  StopActorReason2["StopIntent"] = "StopIntent";
+  StopActorReason2["Destroy"] = "Destroy";
+  StopActorReason2["GoingAway"] = "GoingAway";
+  StopActorReason2["Lost"] = "Lost";
+  return StopActorReason2;
+})(StopActorReason || {});
+function readStopActorReason(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "SleepIntent" /* SleepIntent */;
+    case 1:
+      return "StopIntent" /* StopIntent */;
+    case 2:
+      return "Destroy" /* Destroy */;
+    case 3:
+      return "GoingAway" /* GoingAway */;
+    case 4:
+      return "Lost" /* Lost */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeStopActorReason(bc, x) {
+  switch (x) {
+    case "SleepIntent" /* SleepIntent */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "StopIntent" /* StopIntent */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "Destroy" /* Destroy */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "GoingAway" /* GoingAway */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "Lost" /* Lost */: {
+      bare.writeU8(bc, 4);
+      break;
+    }
+  }
+}
+function readCommandStopActor(bc) {
+  return {
+    reason: readStopActorReason(bc)
+  };
+}
+function writeCommandStopActor(bc, x) {
+  writeStopActorReason(bc, x.reason);
+}
+function readCommand(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "CommandStartActor", val: readCommandStartActor(bc) };
+    case 1:
+      return { tag: "CommandStopActor", val: readCommandStopActor(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeCommand(bc, x) {
+  switch (x.tag) {
+    case "CommandStartActor": {
+      bare.writeU8(bc, 0);
+      writeCommandStartActor(bc, x.val);
+      break;
+    }
+    case "CommandStopActor": {
+      bare.writeU8(bc, 1);
+      writeCommandStopActor(bc, x.val);
+      break;
+    }
+  }
+}
+function readCommandWrapper(bc) {
+  return {
+    checkpoint: readActorCheckpoint(bc),
+    inner: readCommand(bc)
+  };
+}
+function writeCommandWrapper(bc, x) {
+  writeActorCheckpoint(bc, x.checkpoint);
+  writeCommand(bc, x.inner);
+}
+function readActorCommandKeyData(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "CommandStartActor", val: readCommandStartActor(bc) };
+    case 1:
+      return { tag: "CommandStopActor", val: readCommandStopActor(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeActorCommandKeyData(bc, x) {
+  switch (x.tag) {
+    case "CommandStartActor": {
+      bare.writeU8(bc, 0);
+      writeCommandStartActor(bc, x.val);
+      break;
+    }
+    case "CommandStopActor": {
+      bare.writeU8(bc, 1);
+      writeCommandStopActor(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeActorCommandKeyData(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeActorCommandKeyData(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorCommandKeyData(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readActorCommandKeyData(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readMessageId(bc) {
+  return {
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc),
+    messageIndex: readMessageIndex(bc)
+  };
+}
+function writeMessageId(bc, x) {
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+  writeMessageIndex(bc, x.messageIndex);
+}
+function read22(bc) {
+  return bare.readBool(bc) ? bare.readU32(bc) : null;
+}
+function write22(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU32(bc, x);
+  }
+}
+function read23(bc) {
+  const len = bare.readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = bare.readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "duplicated key");
+    }
+    result.set(key, bare.readString(bc));
+  }
+  return result;
+}
+function write23(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    bare.writeString(bc, kv[1]);
+  }
+}
+function readToEnvoyRequestStart(bc) {
+  return {
+    actorId: readId(bc),
+    actorGeneration: read22(bc),
+    method: bare.readString(bc),
+    path: bare.readString(bc),
+    headers: read23(bc),
+    body: read18(bc),
+    stream: bare.readBool(bc),
+    responseStream: bare.readBool(bc)
+  };
+}
+function writeToEnvoyRequestStart(bc, x) {
+  writeId(bc, x.actorId);
+  write22(bc, x.actorGeneration);
+  bare.writeString(bc, x.method);
+  bare.writeString(bc, x.path);
+  write23(bc, x.headers);
+  write18(bc, x.body);
+  bare.writeBool(bc, x.stream);
+  bare.writeBool(bc, x.responseStream);
+}
+function readToEnvoyRequestChunk(bc) {
+  return {
+    body: bare.readData(bc),
+    finish: bare.readBool(bc)
+  };
+}
+function writeToEnvoyRequestChunk(bc, x) {
+  bare.writeData(bc, x.body);
+  bare.writeBool(bc, x.finish);
+}
+function readToRivetRequestBodyWindowUpdate(bc) {
+  return {
+    consumedBytes: bare.readU64(bc)
+  };
+}
+function writeToRivetRequestBodyWindowUpdate(bc, x) {
+  bare.writeU64(bc, x.consumedBytes);
+}
+var HttpStreamAbortReasonKind = /* @__PURE__ */ ((HttpStreamAbortReasonKind2) => {
+  HttpStreamAbortReasonKind2["Unknown"] = "Unknown";
+  HttpStreamAbortReasonKind2["Cancelled"] = "Cancelled";
+  HttpStreamAbortReasonKind2["HandlerError"] = "HandlerError";
+  HttpStreamAbortReasonKind2["InternalError"] = "InternalError";
+  return HttpStreamAbortReasonKind2;
+})(HttpStreamAbortReasonKind || {});
+function readHttpStreamAbortReasonKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return "Unknown" /* Unknown */;
+    case 1:
+      return "Cancelled" /* Cancelled */;
+    case 2:
+      return "HandlerError" /* HandlerError */;
+    case 3:
+      return "InternalError" /* InternalError */;
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeHttpStreamAbortReasonKind(bc, x) {
+  switch (x) {
+    case "Unknown" /* Unknown */: {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "Cancelled" /* Cancelled */: {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "HandlerError" /* HandlerError */: {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "InternalError" /* InternalError */: {
+      bare.writeU8(bc, 3);
+      break;
+    }
+  }
+}
+function readHttpStreamAbortReason(bc) {
+  return {
+    kind: readHttpStreamAbortReasonKind(bc),
+    detail: read17(bc)
+  };
+}
+function writeHttpStreamAbortReason(bc, x) {
+  writeHttpStreamAbortReasonKind(bc, x.kind);
+  write17(bc, x.detail);
+}
+function read24(bc) {
+  return bare.readBool(bc) ? readId(bc) : null;
+}
+function write24(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeId(bc, x);
+  }
+}
+function readToEnvoyRequestAbort(bc) {
+  return {
+    actorId: read24(bc),
+    actorGeneration: read22(bc),
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToEnvoyRequestAbort(bc, x) {
+  write24(bc, x.actorId);
+  write22(bc, x.actorGeneration);
+  writeHttpStreamAbortReason(bc, x.reason);
+}
+function readToRivetResponseStart(bc) {
+  return {
+    status: bare.readU16(bc),
+    headers: read23(bc),
+    body: read18(bc),
+    stream: bare.readBool(bc)
+  };
+}
+function writeToRivetResponseStart(bc, x) {
+  bare.writeU16(bc, x.status);
+  write23(bc, x.headers);
+  write18(bc, x.body);
+  bare.writeBool(bc, x.stream);
+}
+function readToRivetResponseChunk(bc) {
+  return {
+    body: bare.readData(bc),
+    finish: bare.readBool(bc)
+  };
+}
+function writeToRivetResponseChunk(bc, x) {
+  bare.writeData(bc, x.body);
+  bare.writeBool(bc, x.finish);
+}
+function readToEnvoyResponseBodyWindowUpdate(bc) {
+  return {
+    consumedBytes: bare.readU64(bc)
+  };
+}
+function writeToEnvoyResponseBodyWindowUpdate(bc, x) {
+  bare.writeU64(bc, x.consumedBytes);
+}
+function readToRivetResponseAbort(bc) {
+  return {
+    reason: readHttpStreamAbortReason(bc)
+  };
+}
+function writeToRivetResponseAbort(bc, x) {
+  writeHttpStreamAbortReason(bc, x.reason);
+}
+function readToEnvoyWebSocketOpen(bc) {
+  return {
+    actorId: readId(bc),
+    actorGeneration: read22(bc),
+    path: bare.readString(bc),
+    headers: read23(bc)
+  };
+}
+function writeToEnvoyWebSocketOpen(bc, x) {
+  writeId(bc, x.actorId);
+  write22(bc, x.actorGeneration);
+  bare.writeString(bc, x.path);
+  write23(bc, x.headers);
+}
+function readToEnvoyWebSocketMessage(bc) {
+  return {
+    data: bare.readData(bc),
+    binary: bare.readBool(bc)
+  };
+}
+function writeToEnvoyWebSocketMessage(bc, x) {
+  bare.writeData(bc, x.data);
+  bare.writeBool(bc, x.binary);
+}
+function read25(bc) {
+  return bare.readBool(bc) ? bare.readU16(bc) : null;
+}
+function write25(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU16(bc, x);
+  }
+}
+function readToEnvoyWebSocketClose(bc) {
+  return {
+    code: read25(bc),
+    reason: read17(bc)
+  };
+}
+function writeToEnvoyWebSocketClose(bc, x) {
+  write25(bc, x.code);
+  write17(bc, x.reason);
+}
+function readToRivetWebSocketOpen(bc) {
+  return {
+    canHibernate: bare.readBool(bc)
+  };
+}
+function writeToRivetWebSocketOpen(bc, x) {
+  bare.writeBool(bc, x.canHibernate);
+}
+function readToRivetWebSocketMessage(bc) {
+  return {
+    data: bare.readData(bc),
+    binary: bare.readBool(bc)
+  };
+}
+function writeToRivetWebSocketMessage(bc, x) {
+  bare.writeData(bc, x.data);
+  bare.writeBool(bc, x.binary);
+}
+function readToRivetWebSocketMessageAck(bc) {
+  return {
+    index: readMessageIndex(bc)
+  };
+}
+function writeToRivetWebSocketMessageAck(bc, x) {
+  writeMessageIndex(bc, x.index);
+}
+function readToRivetWebSocketClose(bc) {
+  return {
+    code: read25(bc),
+    reason: read17(bc),
+    hibernate: bare.readBool(bc)
+  };
+}
+function writeToRivetWebSocketClose(bc, x) {
+  write25(bc, x.code);
+  write17(bc, x.reason);
+  bare.writeBool(bc, x.hibernate);
+}
+function readToRivetTunnelMessageKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToRivetResponseStart", val: readToRivetResponseStart(bc) };
+    case 1:
+      return { tag: "ToRivetResponseChunk", val: readToRivetResponseChunk(bc) };
+    case 2:
+      return { tag: "ToRivetResponseAbort", val: readToRivetResponseAbort(bc) };
+    case 3:
+      return { tag: "ToRivetRequestBodyWindowUpdate", val: readToRivetRequestBodyWindowUpdate(bc) };
+    case 4:
+      return { tag: "ToRivetRequestBodyCancel", val: null };
+    case 5:
+      return { tag: "ToRivetWebSocketOpen", val: readToRivetWebSocketOpen(bc) };
+    case 6:
+      return { tag: "ToRivetWebSocketMessage", val: readToRivetWebSocketMessage(bc) };
+    case 7:
+      return { tag: "ToRivetWebSocketMessageAck", val: readToRivetWebSocketMessageAck(bc) };
+    case 8:
+      return { tag: "ToRivetWebSocketClose", val: readToRivetWebSocketClose(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToRivetTunnelMessageKind(bc, x) {
+  switch (x.tag) {
+    case "ToRivetResponseStart": {
+      bare.writeU8(bc, 0);
+      writeToRivetResponseStart(bc, x.val);
+      break;
+    }
+    case "ToRivetResponseChunk": {
+      bare.writeU8(bc, 1);
+      writeToRivetResponseChunk(bc, x.val);
+      break;
+    }
+    case "ToRivetResponseAbort": {
+      bare.writeU8(bc, 2);
+      writeToRivetResponseAbort(bc, x.val);
+      break;
+    }
+    case "ToRivetRequestBodyWindowUpdate": {
+      bare.writeU8(bc, 3);
+      writeToRivetRequestBodyWindowUpdate(bc, x.val);
+      break;
+    }
+    case "ToRivetRequestBodyCancel": {
+      bare.writeU8(bc, 4);
+      break;
+    }
+    case "ToRivetWebSocketOpen": {
+      bare.writeU8(bc, 5);
+      writeToRivetWebSocketOpen(bc, x.val);
+      break;
+    }
+    case "ToRivetWebSocketMessage": {
+      bare.writeU8(bc, 6);
+      writeToRivetWebSocketMessage(bc, x.val);
+      break;
+    }
+    case "ToRivetWebSocketMessageAck": {
+      bare.writeU8(bc, 7);
+      writeToRivetWebSocketMessageAck(bc, x.val);
+      break;
+    }
+    case "ToRivetWebSocketClose": {
+      bare.writeU8(bc, 8);
+      writeToRivetWebSocketClose(bc, x.val);
+      break;
+    }
+  }
+}
+function readToRivetTunnelMessage(bc) {
+  return {
+    messageId: readMessageId(bc),
+    messageKind: readToRivetTunnelMessageKind(bc)
+  };
+}
+function writeToRivetTunnelMessage(bc, x) {
+  writeMessageId(bc, x.messageId);
+  writeToRivetTunnelMessageKind(bc, x.messageKind);
+}
+function readToEnvoyTunnelMessageKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToEnvoyRequestStart", val: readToEnvoyRequestStart(bc) };
+    case 1:
+      return { tag: "ToEnvoyRequestChunk", val: readToEnvoyRequestChunk(bc) };
+    case 2:
+      return { tag: "ToEnvoyRequestAbort", val: readToEnvoyRequestAbort(bc) };
+    case 3:
+      return { tag: "ToEnvoyRequestBodyCancel", val: null };
+    case 4:
+      return { tag: "ToEnvoyResponseBodyWindowUpdate", val: readToEnvoyResponseBodyWindowUpdate(bc) };
+    case 5:
+      return { tag: "ToEnvoyWebSocketOpen", val: readToEnvoyWebSocketOpen(bc) };
+    case 6:
+      return { tag: "ToEnvoyWebSocketMessage", val: readToEnvoyWebSocketMessage(bc) };
+    case 7:
+      return { tag: "ToEnvoyWebSocketClose", val: readToEnvoyWebSocketClose(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToEnvoyTunnelMessageKind(bc, x) {
+  switch (x.tag) {
+    case "ToEnvoyRequestStart": {
+      bare.writeU8(bc, 0);
+      writeToEnvoyRequestStart(bc, x.val);
+      break;
+    }
+    case "ToEnvoyRequestChunk": {
+      bare.writeU8(bc, 1);
+      writeToEnvoyRequestChunk(bc, x.val);
+      break;
+    }
+    case "ToEnvoyRequestAbort": {
+      bare.writeU8(bc, 2);
+      writeToEnvoyRequestAbort(bc, x.val);
+      break;
+    }
+    case "ToEnvoyRequestBodyCancel": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToEnvoyResponseBodyWindowUpdate": {
+      bare.writeU8(bc, 4);
+      writeToEnvoyResponseBodyWindowUpdate(bc, x.val);
+      break;
+    }
+    case "ToEnvoyWebSocketOpen": {
+      bare.writeU8(bc, 5);
+      writeToEnvoyWebSocketOpen(bc, x.val);
+      break;
+    }
+    case "ToEnvoyWebSocketMessage": {
+      bare.writeU8(bc, 6);
+      writeToEnvoyWebSocketMessage(bc, x.val);
+      break;
+    }
+    case "ToEnvoyWebSocketClose": {
+      bare.writeU8(bc, 7);
+      writeToEnvoyWebSocketClose(bc, x.val);
+      break;
+    }
+  }
+}
+function readToEnvoyTunnelMessage(bc) {
+  return {
+    messageId: readMessageId(bc),
+    messageKind: readToEnvoyTunnelMessageKind(bc)
+  };
+}
+function writeToEnvoyTunnelMessage(bc, x) {
+  writeMessageId(bc, x.messageId);
+  writeToEnvoyTunnelMessageKind(bc, x.messageKind);
+}
+function readToEnvoyPing(bc) {
+  return {
+    ts: bare.readI64(bc)
+  };
+}
+function writeToEnvoyPing(bc, x) {
+  bare.writeI64(bc, x.ts);
+}
+function read26(bc) {
+  const len = bare.readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = bare.readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "duplicated key");
+    }
+    result.set(key, readActorName(bc));
+  }
+  return result;
+}
+function write26(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    writeActorName(bc, kv[1]);
+  }
+}
+function read27(bc) {
+  return bare.readBool(bc) ? read26(bc) : null;
+}
+function write27(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    write26(bc, x);
+  }
+}
+function read28(bc) {
+  return bare.readBool(bc) ? readJson(bc) : null;
+}
+function write28(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeJson(bc, x);
+  }
+}
+function readToRivetMetadata(bc) {
+  return {
+    prepopulateActorNames: read27(bc),
+    metadata: read28(bc)
+  };
+}
+function writeToRivetMetadata(bc, x) {
+  write27(bc, x.prepopulateActorNames);
+  write28(bc, x.metadata);
+}
+function readToRivetEvents(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readEventWrapper(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readEventWrapper(bc);
+  }
+  return result;
+}
+function writeToRivetEvents(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeEventWrapper(bc, x[i]);
+  }
+}
+function read29(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readActorCheckpoint(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readActorCheckpoint(bc);
+  }
+  return result;
+}
+function write29(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeActorCheckpoint(bc, x[i]);
+  }
+}
+function readToRivetAckCommands(bc) {
+  return {
+    lastCommandCheckpoints: read29(bc)
+  };
+}
+function writeToRivetAckCommands(bc, x) {
+  write29(bc, x.lastCommandCheckpoints);
+}
+function readToRivetPong(bc) {
+  return {
+    ts: bare.readI64(bc)
+  };
+}
+function writeToRivetPong(bc, x) {
+  bare.writeI64(bc, x.ts);
+}
+function readToRivetKvRequest(bc) {
+  return {
+    actorId: readId(bc),
+    requestId: bare.readU32(bc),
+    data: readKvRequestData(bc)
+  };
+}
+function writeToRivetKvRequest(bc, x) {
+  writeId(bc, x.actorId);
+  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 readToRivetSqliteCommitStageBeginRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageBeginRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitStageBeginRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageBeginRequest(bc, x.data);
+}
+function readToRivetSqliteCommitStageSegmentRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageSegmentRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitStageSegmentRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageSegmentRequest(bc, x.data);
+}
+function readToRivetSqliteCommitFinalizeRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitFinalizeRequest(bc)
+  };
+}
+function writeToRivetSqliteCommitFinalizeRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitFinalizeRequest(bc, x.data);
+}
+function readToRivetSqliteExecRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    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 readToRivetSqliteExecuteBatchRequest(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteBatchRequest(bc)
+  };
+}
+function writeToRivetSqliteExecuteBatchRequest(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteBatchRequest(bc, x.data);
+}
+function readToRivet(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToRivetMetadata", val: readToRivetMetadata(bc) };
+    case 1:
+      return { tag: "ToRivetEvents", val: readToRivetEvents(bc) };
+    case 2:
+      return { tag: "ToRivetAckCommands", val: readToRivetAckCommands(bc) };
+    case 3:
+      return { tag: "ToRivetStopping", val: null };
+    case 4:
+      return { tag: "ToRivetPong", val: readToRivetPong(bc) };
+    case 5:
+      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: "ToRivetSqliteCommitStageBeginRequest", val: readToRivetSqliteCommitStageBeginRequest(bc) };
+    case 10:
+      return { tag: "ToRivetSqliteCommitStageSegmentRequest", val: readToRivetSqliteCommitStageSegmentRequest(bc) };
+    case 11:
+      return { tag: "ToRivetSqliteCommitFinalizeRequest", val: readToRivetSqliteCommitFinalizeRequest(bc) };
+    case 12:
+      return { tag: "ToRivetSqliteExecRequest", val: readToRivetSqliteExecRequest(bc) };
+    case 13:
+      return { tag: "ToRivetSqliteExecuteRequest", val: readToRivetSqliteExecuteRequest(bc) };
+    case 14:
+      return { tag: "ToRivetSqliteExecuteBatchRequest", val: readToRivetSqliteExecuteBatchRequest(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToRivet(bc, x) {
+  switch (x.tag) {
+    case "ToRivetMetadata": {
+      bare.writeU8(bc, 0);
+      writeToRivetMetadata(bc, x.val);
+      break;
+    }
+    case "ToRivetEvents": {
+      bare.writeU8(bc, 1);
+      writeToRivetEvents(bc, x.val);
+      break;
+    }
+    case "ToRivetAckCommands": {
+      bare.writeU8(bc, 2);
+      writeToRivetAckCommands(bc, x.val);
+      break;
+    }
+    case "ToRivetStopping": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToRivetPong": {
+      bare.writeU8(bc, 4);
+      writeToRivetPong(bc, x.val);
+      break;
+    }
+    case "ToRivetKvRequest": {
+      bare.writeU8(bc, 5);
+      writeToRivetKvRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetTunnelMessage": {
+      bare.writeU8(bc, 6);
+      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 "ToRivetSqliteCommitStageBeginRequest": {
+      bare.writeU8(bc, 9);
+      writeToRivetSqliteCommitStageBeginRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitStageSegmentRequest": {
+      bare.writeU8(bc, 10);
+      writeToRivetSqliteCommitStageSegmentRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteCommitFinalizeRequest": {
+      bare.writeU8(bc, 11);
+      writeToRivetSqliteCommitFinalizeRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecRequest": {
+      bare.writeU8(bc, 12);
+      writeToRivetSqliteExecRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecuteRequest": {
+      bare.writeU8(bc, 13);
+      writeToRivetSqliteExecuteRequest(bc, x.val);
+      break;
+    }
+    case "ToRivetSqliteExecuteBatchRequest": {
+      bare.writeU8(bc, 14);
+      writeToRivetSqliteExecuteBatchRequest(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToRivet(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToRivet(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToRivet(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToRivet(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readProtocolMetadata(bc) {
+  return {
+    envoyLostThreshold: bare.readI64(bc),
+    actorStopThreshold: bare.readI64(bc),
+    maxResponsePayloadSize: bare.readU64(bc)
+  };
+}
+function writeProtocolMetadata(bc, x) {
+  bare.writeI64(bc, x.envoyLostThreshold);
+  bare.writeI64(bc, x.actorStopThreshold);
+  bare.writeU64(bc, x.maxResponsePayloadSize);
+}
+function readToEnvoyInit(bc) {
+  return {
+    metadata: readProtocolMetadata(bc)
+  };
+}
+function writeToEnvoyInit(bc, x) {
+  writeProtocolMetadata(bc, x.metadata);
+}
+function readToEnvoyCommands(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readCommandWrapper(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readCommandWrapper(bc);
+  }
+  return result;
+}
+function writeToEnvoyCommands(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeCommandWrapper(bc, x[i]);
+  }
+}
+function readToEnvoyAckEvents(bc) {
+  return {
+    lastEventCheckpoints: read29(bc)
+  };
+}
+function writeToEnvoyAckEvents(bc, x) {
+  write29(bc, x.lastEventCheckpoints);
+}
+function readToEnvoyKvResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readKvResponseData(bc)
+  };
+}
+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 readToEnvoySqliteCommitStageBeginResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageBeginResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitStageBeginResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageBeginResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitStageSegmentResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitStageSegmentResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitStageSegmentResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitStageSegmentResponse(bc, x.data);
+}
+function readToEnvoySqliteCommitFinalizeResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteCommitFinalizeResponse(bc)
+  };
+}
+function writeToEnvoySqliteCommitFinalizeResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteCommitFinalizeResponse(bc, x.data);
+}
+function readToEnvoySqliteExecResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    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 readToEnvoySqliteExecuteBatchResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readSqliteExecuteBatchResponse(bc)
+  };
+}
+function writeToEnvoySqliteExecuteBatchResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeSqliteExecuteBatchResponse(bc, x.data);
+}
+function readToEnvoy(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToEnvoyInit", val: readToEnvoyInit(bc) };
+    case 1:
+      return { tag: "ToEnvoyCommands", val: readToEnvoyCommands(bc) };
+    case 2:
+      return { tag: "ToEnvoyAckEvents", val: readToEnvoyAckEvents(bc) };
+    case 3:
+      return { tag: "ToEnvoyKvResponse", val: readToEnvoyKvResponse(bc) };
+    case 4:
+      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: "ToEnvoySqliteCommitStageBeginResponse", val: readToEnvoySqliteCommitStageBeginResponse(bc) };
+    case 9:
+      return { tag: "ToEnvoySqliteCommitStageSegmentResponse", val: readToEnvoySqliteCommitStageSegmentResponse(bc) };
+    case 10:
+      return { tag: "ToEnvoySqliteCommitFinalizeResponse", val: readToEnvoySqliteCommitFinalizeResponse(bc) };
+    case 11:
+      return { tag: "ToEnvoySqliteExecResponse", val: readToEnvoySqliteExecResponse(bc) };
+    case 12:
+      return { tag: "ToEnvoySqliteExecuteResponse", val: readToEnvoySqliteExecuteResponse(bc) };
+    case 13:
+      return { tag: "ToEnvoySqliteExecuteBatchResponse", val: readToEnvoySqliteExecuteBatchResponse(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToEnvoy(bc, x) {
+  switch (x.tag) {
+    case "ToEnvoyInit": {
+      bare.writeU8(bc, 0);
+      writeToEnvoyInit(bc, x.val);
+      break;
+    }
+    case "ToEnvoyCommands": {
+      bare.writeU8(bc, 1);
+      writeToEnvoyCommands(bc, x.val);
+      break;
+    }
+    case "ToEnvoyAckEvents": {
+      bare.writeU8(bc, 2);
+      writeToEnvoyAckEvents(bc, x.val);
+      break;
+    }
+    case "ToEnvoyKvResponse": {
+      bare.writeU8(bc, 3);
+      writeToEnvoyKvResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoyTunnelMessage": {
+      bare.writeU8(bc, 4);
+      writeToEnvoyTunnelMessage(bc, x.val);
+      break;
+    }
+    case "ToEnvoyPing": {
+      bare.writeU8(bc, 5);
+      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 "ToEnvoySqliteCommitStageBeginResponse": {
+      bare.writeU8(bc, 8);
+      writeToEnvoySqliteCommitStageBeginResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitStageSegmentResponse": {
+      bare.writeU8(bc, 9);
+      writeToEnvoySqliteCommitStageSegmentResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteCommitFinalizeResponse": {
+      bare.writeU8(bc, 10);
+      writeToEnvoySqliteCommitFinalizeResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecResponse": {
+      bare.writeU8(bc, 11);
+      writeToEnvoySqliteExecResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecuteResponse": {
+      bare.writeU8(bc, 12);
+      writeToEnvoySqliteExecuteResponse(bc, x.val);
+      break;
+    }
+    case "ToEnvoySqliteExecuteBatchResponse": {
+      bare.writeU8(bc, 13);
+      writeToEnvoySqliteExecuteBatchResponse(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToEnvoy(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToEnvoy(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToEnvoy(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToEnvoy(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readToEnvoyConnPing(bc) {
+  return {
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc),
+    ts: bare.readI64(bc)
+  };
+}
+function writeToEnvoyConnPing(bc, x) {
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+  bare.writeI64(bc, x.ts);
+}
+function readToEnvoyConn(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToEnvoyConnPing", val: readToEnvoyConnPing(bc) };
+    case 1:
+      return { tag: "ToEnvoyConnClose", val: null };
+    case 2:
+      return { tag: "ToEnvoyCommands", val: readToEnvoyCommands(bc) };
+    case 3:
+      return { tag: "ToEnvoyAckEvents", val: readToEnvoyAckEvents(bc) };
+    case 4:
+      return { tag: "ToEnvoyTunnelMessage", val: readToEnvoyTunnelMessage(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToEnvoyConn(bc, x) {
+  switch (x.tag) {
+    case "ToEnvoyConnPing": {
+      bare.writeU8(bc, 0);
+      writeToEnvoyConnPing(bc, x.val);
+      break;
+    }
+    case "ToEnvoyConnClose": {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "ToEnvoyCommands": {
+      bare.writeU8(bc, 2);
+      writeToEnvoyCommands(bc, x.val);
+      break;
+    }
+    case "ToEnvoyAckEvents": {
+      bare.writeU8(bc, 3);
+      writeToEnvoyAckEvents(bc, x.val);
+      break;
+    }
+    case "ToEnvoyTunnelMessage": {
+      bare.writeU8(bc, 4);
+      writeToEnvoyTunnelMessage(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToEnvoyConn(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToEnvoyConn(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToEnvoyConn(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToEnvoyConn(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readToGatewayPong(bc) {
+  return {
+    requestId: readRequestId(bc),
+    ts: bare.readI64(bc)
+  };
+}
+function writeToGatewayPong(bc, x) {
+  writeRequestId(bc, x.requestId);
+  bare.writeI64(bc, x.ts);
+}
+function readToGateway(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToGatewayPong", val: readToGatewayPong(bc) };
+    case 1:
+      return { tag: "ToRivetTunnelMessage", val: readToRivetTunnelMessage(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToGateway(bc, x) {
+  switch (x.tag) {
+    case "ToGatewayPong": {
+      bare.writeU8(bc, 0);
+      writeToGatewayPong(bc, x.val);
+      break;
+    }
+    case "ToRivetTunnelMessage": {
+      bare.writeU8(bc, 1);
+      writeToRivetTunnelMessage(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToGateway(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToGateway(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToGateway(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToGateway(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readToOutboundActorStart(bc) {
+  return {
+    namespaceId: readId(bc),
+    poolName: bare.readString(bc),
+    checkpoint: readActorCheckpoint(bc),
+    actorConfig: readActorConfig(bc)
+  };
+}
+function writeToOutboundActorStart(bc, x) {
+  writeId(bc, x.namespaceId);
+  bare.writeString(bc, x.poolName);
+  writeActorCheckpoint(bc, x.checkpoint);
+  writeActorConfig(bc, x.actorConfig);
+}
+function readToOutbound(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToOutboundActorStart", val: readToOutboundActorStart(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToOutbound(bc, x) {
+  switch (x.tag) {
+    case "ToOutboundActorStart": {
+      bare.writeU8(bc, 0);
+      writeToOutboundActorStart(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToOutbound(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToOutbound(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToOutbound(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToOutbound(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function assert(condition, message) {
+  if (!condition) throw new Error(message ?? "Assertion failed");
+}
+var VERSION = 8;
+export {
+  HttpStreamAbortReasonKind,
+  StopActorReason,
+  StopCode,
+  VERSION,
+  decodeActorCommandKeyData,
+  decodeToEnvoy,
+  decodeToEnvoyConn,
+  decodeToGateway,
+  decodeToOutbound,
+  decodeToRivet,
+  encodeActorCommandKeyData,
+  encodeToEnvoy,
+  encodeToEnvoyConn,
+  encodeToGateway,
+  encodeToOutbound,
+  encodeToRivet,
+  readActorCheckpoint,
+  readActorCommandKeyData,
+  readActorConfig,
+  readActorIntent,
+  readActorName,
+  readActorState,
+  readActorStateStopped,
+  readCommand,
+  readCommandStartActor,
+  readCommandStopActor,
+  readCommandWrapper,
+  readEvent,
+  readEventActorIntent,
+  readEventActorSetAlarm,
+  readEventActorStateUpdate,
+  readEventWrapper,
+  readGatewayId,
+  readHibernatingRequest,
+  readHttpStreamAbortReason,
+  readHttpStreamAbortReasonKind,
+  readId,
+  readJson,
+  readKvDeleteRangeRequest,
+  readKvDeleteRequest,
+  readKvErrorResponse,
+  readKvGetRequest,
+  readKvGetResponse,
+  readKvKey,
+  readKvListPrefixQuery,
+  readKvListQuery,
+  readKvListRangeQuery,
+  readKvListRequest,
+  readKvListResponse,
+  readKvMetadata,
+  readKvPutRequest,
+  readKvRequestData,
+  readKvResponseData,
+  readKvValue,
+  readMessageId,
+  readMessageIndex,
+  readPreloadedKv,
+  readPreloadedKvEntry,
+  readProtocolMetadata,
+  readRequestId,
+  readSqliteBatchStatement,
+  readSqliteBindParam,
+  readSqliteColumnValue,
+  readSqliteCommitFinalizeOk,
+  readSqliteCommitFinalizeRequest,
+  readSqliteCommitFinalizeResponse,
+  readSqliteCommitOk,
+  readSqliteCommitRequest,
+  readSqliteCommitResponse,
+  readSqliteCommitStageBeginOk,
+  readSqliteCommitStageBeginRequest,
+  readSqliteCommitStageBeginResponse,
+  readSqliteCommitStageSegmentOk,
+  readSqliteCommitStageSegmentRequest,
+  readSqliteCommitStageSegmentResponse,
+  readSqliteDirtyPage,
+  readSqliteErrorResponse,
+  readSqliteExecOk,
+  readSqliteExecRequest,
+  readSqliteExecResponse,
+  readSqliteExecuteBatchOk,
+  readSqliteExecuteBatchRequest,
+  readSqliteExecuteBatchResponse,
+  readSqliteExecuteOk,
+  readSqliteExecuteRequest,
+  readSqliteExecuteResponse,
+  readSqliteExecuteResult,
+  readSqliteFetchedPage,
+  readSqliteGeneration,
+  readSqliteGetPagesOk,
+  readSqliteGetPagesRequest,
+  readSqliteGetPagesResponse,
+  readSqlitePageBytes,
+  readSqlitePgno,
+  readSqliteQueryResult,
+  readSqliteValueBlob,
+  readSqliteValueFloat,
+  readSqliteValueInteger,
+  readSqliteValueText,
+  readStopActorReason,
+  readStopCode,
+  readToEnvoy,
+  readToEnvoyAckEvents,
+  readToEnvoyCommands,
+  readToEnvoyConn,
+  readToEnvoyConnPing,
+  readToEnvoyInit,
+  readToEnvoyKvResponse,
+  readToEnvoyPing,
+  readToEnvoyRequestAbort,
+  readToEnvoyRequestChunk,
+  readToEnvoyRequestStart,
+  readToEnvoyResponseBodyWindowUpdate,
+  readToEnvoySqliteCommitFinalizeResponse,
+  readToEnvoySqliteCommitResponse,
+  readToEnvoySqliteCommitStageBeginResponse,
+  readToEnvoySqliteCommitStageSegmentResponse,
+  readToEnvoySqliteExecResponse,
+  readToEnvoySqliteExecuteBatchResponse,
+  readToEnvoySqliteExecuteResponse,
+  readToEnvoySqliteGetPagesResponse,
+  readToEnvoyTunnelMessage,
+  readToEnvoyTunnelMessageKind,
+  readToEnvoyWebSocketClose,
+  readToEnvoyWebSocketMessage,
+  readToEnvoyWebSocketOpen,
+  readToGateway,
+  readToGatewayPong,
+  readToOutbound,
+  readToOutboundActorStart,
+  readToRivet,
+  readToRivetAckCommands,
+  readToRivetEvents,
+  readToRivetKvRequest,
+  readToRivetMetadata,
+  readToRivetPong,
+  readToRivetRequestBodyWindowUpdate,
+  readToRivetResponseAbort,
+  readToRivetResponseChunk,
+  readToRivetResponseStart,
+  readToRivetSqliteCommitFinalizeRequest,
+  readToRivetSqliteCommitRequest,
+  readToRivetSqliteCommitStageBeginRequest,
+  readToRivetSqliteCommitStageSegmentRequest,
+  readToRivetSqliteExecRequest,
+  readToRivetSqliteExecuteBatchRequest,
+  readToRivetSqliteExecuteRequest,
+  readToRivetSqliteGetPagesRequest,
+  readToRivetTunnelMessage,
+  readToRivetTunnelMessageKind,
+  readToRivetWebSocketClose,
+  readToRivetWebSocketMessage,
+  readToRivetWebSocketMessageAck,
+  readToRivetWebSocketOpen,
+  writeActorCheckpoint,
+  writeActorCommandKeyData,
+  writeActorConfig,
+  writeActorIntent,
+  writeActorName,
+  writeActorState,
+  writeActorStateStopped,
+  writeCommand,
+  writeCommandStartActor,
+  writeCommandStopActor,
+  writeCommandWrapper,
+  writeEvent,
+  writeEventActorIntent,
+  writeEventActorSetAlarm,
+  writeEventActorStateUpdate,
+  writeEventWrapper,
+  writeGatewayId,
+  writeHibernatingRequest,
+  writeHttpStreamAbortReason,
+  writeHttpStreamAbortReasonKind,
+  writeId,
+  writeJson,
+  writeKvDeleteRangeRequest,
+  writeKvDeleteRequest,
+  writeKvErrorResponse,
+  writeKvGetRequest,
+  writeKvGetResponse,
+  writeKvKey,
+  writeKvListPrefixQuery,
+  writeKvListQuery,
+  writeKvListRangeQuery,
+  writeKvListRequest,
+  writeKvListResponse,
+  writeKvMetadata,
+  writeKvPutRequest,
+  writeKvRequestData,
+  writeKvResponseData,
+  writeKvValue,
+  writeMessageId,
+  writeMessageIndex,
+  writePreloadedKv,
+  writePreloadedKvEntry,
+  writeProtocolMetadata,
+  writeRequestId,
+  writeSqliteBatchStatement,
+  writeSqliteBindParam,
+  writeSqliteColumnValue,
+  writeSqliteCommitFinalizeOk,
+  writeSqliteCommitFinalizeRequest,
+  writeSqliteCommitFinalizeResponse,
+  writeSqliteCommitOk,
+  writeSqliteCommitRequest,
+  writeSqliteCommitResponse,
+  writeSqliteCommitStageBeginOk,
+  writeSqliteCommitStageBeginRequest,
+  writeSqliteCommitStageBeginResponse,
+  writeSqliteCommitStageSegmentOk,
+  writeSqliteCommitStageSegmentRequest,
+  writeSqliteCommitStageSegmentResponse,
+  writeSqliteDirtyPage,
+  writeSqliteErrorResponse,
+  writeSqliteExecOk,
+  writeSqliteExecRequest,
+  writeSqliteExecResponse,
+  writeSqliteExecuteBatchOk,
+  writeSqliteExecuteBatchRequest,
+  writeSqliteExecuteBatchResponse,
+  writeSqliteExecuteOk,
+  writeSqliteExecuteRequest,
+  writeSqliteExecuteResponse,
+  writeSqliteExecuteResult,
+  writeSqliteFetchedPage,
+  writeSqliteGeneration,
+  writeSqliteGetPagesOk,
+  writeSqliteGetPagesRequest,
+  writeSqliteGetPagesResponse,
+  writeSqlitePageBytes,
+  writeSqlitePgno,
+  writeSqliteQueryResult,
+  writeSqliteValueBlob,
+  writeSqliteValueFloat,
+  writeSqliteValueInteger,
+  writeSqliteValueText,
+  writeStopActorReason,
+  writeStopCode,
+  writeToEnvoy,
+  writeToEnvoyAckEvents,
+  writeToEnvoyCommands,
+  writeToEnvoyConn,
+  writeToEnvoyConnPing,
+  writeToEnvoyInit,
+  writeToEnvoyKvResponse,
+  writeToEnvoyPing,
+  writeToEnvoyRequestAbort,
+  writeToEnvoyRequestChunk,
+  writeToEnvoyRequestStart,
+  writeToEnvoyResponseBodyWindowUpdate,
+  writeToEnvoySqliteCommitFinalizeResponse,
+  writeToEnvoySqliteCommitResponse,
+  writeToEnvoySqliteCommitStageBeginResponse,
+  writeToEnvoySqliteCommitStageSegmentResponse,
+  writeToEnvoySqliteExecResponse,
+  writeToEnvoySqliteExecuteBatchResponse,
+  writeToEnvoySqliteExecuteResponse,
+  writeToEnvoySqliteGetPagesResponse,
+  writeToEnvoyTunnelMessage,
+  writeToEnvoyTunnelMessageKind,
+  writeToEnvoyWebSocketClose,
+  writeToEnvoyWebSocketMessage,
+  writeToEnvoyWebSocketOpen,
+  writeToGateway,
+  writeToGatewayPong,
+  writeToOutbound,
+  writeToOutboundActorStart,
+  writeToRivet,
+  writeToRivetAckCommands,
+  writeToRivetEvents,
+  writeToRivetKvRequest,
+  writeToRivetMetadata,
+  writeToRivetPong,
+  writeToRivetRequestBodyWindowUpdate,
+  writeToRivetResponseAbort,
+  writeToRivetResponseChunk,
+  writeToRivetResponseStart,
+  writeToRivetSqliteCommitFinalizeRequest,
+  writeToRivetSqliteCommitRequest,
+  writeToRivetSqliteCommitStageBeginRequest,
+  writeToRivetSqliteCommitStageSegmentRequest,
+  writeToRivetSqliteExecRequest,
+  writeToRivetSqliteExecuteBatchRequest,
+  writeToRivetSqliteExecuteRequest,
+  writeToRivetSqliteGetPagesRequest,
+  writeToRivetTunnelMessage,
+  writeToRivetTunnelMessageKind,
+  writeToRivetWebSocketClose,
+  writeToRivetWebSocketMessage,
+  writeToRivetWebSocketMessageAck,
+  writeToRivetWebSocketOpen
+};
+//# sourceMappingURL=index.js.map