@rivetkit/engine 1.0.0

package/sdks/typescript/runner-protocol/dist/index.cjs

@@ -0,0 +1,1632 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }// src/index.ts
+var _assert = require('assert'); var _assert2 = _interopRequireDefault(_assert);
+var _lib = require('@bare-ts/lib'); var bare = _interopRequireWildcard(_lib);
+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) {
+  _assert2.default.call(void 0, x.byteLength === 4);
+  bare.writeFixedData(bc, x);
+}
+function readRequestId(bc) {
+  return bare.readFixedData(bc, 4);
+}
+function writeRequestId(bc, x) {
+  _assert2.default.call(void 0, 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),
+    createTs: bare.readI64(bc)
+  };
+}
+function writeKvMetadata(bc, x) {
+  bare.writeData(bc, x.version);
+  bare.writeI64(bc, x.createTs);
+}
+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 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: "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 "KvDropRequest": {
+      bare.writeU8(bc, 4);
+      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;
+    }
+  }
+}
+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 read5(bc) {
+  return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write5(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeString(bc, x);
+  }
+}
+function read6(bc) {
+  return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write6(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeData(bc, x);
+  }
+}
+function readActorConfig(bc) {
+  return {
+    name: bare.readString(bc),
+    key: read5(bc),
+    createTs: bare.readI64(bc),
+    input: read6(bc)
+  };
+}
+function writeActorConfig(bc, x) {
+  bare.writeString(bc, x.name);
+  write5(bc, x.key);
+  bare.writeI64(bc, x.createTs);
+  write6(bc, x.input);
+}
+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: read5(bc)
+  };
+}
+function writeActorStateStopped(bc, x) {
+  writeStopCode(bc, x.code);
+  write5(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 {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    intent: readActorIntent(bc)
+  };
+}
+function writeEventActorIntent(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  writeActorIntent(bc, x.intent);
+}
+function readEventActorStateUpdate(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    state: readActorState(bc)
+  };
+}
+function writeEventActorStateUpdate(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  writeActorState(bc, x.state);
+}
+function read7(bc) {
+  return bare.readBool(bc) ? bare.readI64(bc) : null;
+}
+function write7(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeI64(bc, x);
+  }
+}
+function readEventActorSetAlarm(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    alarmTs: read7(bc)
+  };
+}
+function writeEventActorSetAlarm(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  write7(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 {
+    index: bare.readI64(bc),
+    inner: readEvent(bc)
+  };
+}
+function writeEventWrapper(bc, x) {
+  bare.writeI64(bc, x.index);
+  writeEvent(bc, x.inner);
+}
+function readHibernatingRequest(bc) {
+  return {
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc)
+  };
+}
+function writeHibernatingRequest(bc, x) {
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+}
+function read8(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 write8(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeHibernatingRequest(bc, x[i]);
+  }
+}
+function readCommandStartActor(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    config: readActorConfig(bc),
+    hibernatingRequests: read8(bc)
+  };
+}
+function writeCommandStartActor(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  writeActorConfig(bc, x.config);
+  write8(bc, x.hibernatingRequests);
+}
+function readCommandStopActor(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc)
+  };
+}
+function writeCommandStopActor(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+}
+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 {
+    index: bare.readI64(bc),
+    inner: readCommand(bc)
+  };
+}
+function writeCommandWrapper(bc, x) {
+  bare.writeI64(bc, x.index);
+  writeCommand(bc, x.inner);
+}
+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 read9(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 write9(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    bare.writeString(bc, kv[1]);
+  }
+}
+function readToClientRequestStart(bc) {
+  return {
+    actorId: readId(bc),
+    method: bare.readString(bc),
+    path: bare.readString(bc),
+    headers: read9(bc),
+    body: read6(bc),
+    stream: bare.readBool(bc)
+  };
+}
+function writeToClientRequestStart(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeString(bc, x.method);
+  bare.writeString(bc, x.path);
+  write9(bc, x.headers);
+  write6(bc, x.body);
+  bare.writeBool(bc, x.stream);
+}
+function readToClientRequestChunk(bc) {
+  return {
+    body: bare.readData(bc),
+    finish: bare.readBool(bc)
+  };
+}
+function writeToClientRequestChunk(bc, x) {
+  bare.writeData(bc, x.body);
+  bare.writeBool(bc, x.finish);
+}
+function readToServerResponseStart(bc) {
+  return {
+    status: bare.readU16(bc),
+    headers: read9(bc),
+    body: read6(bc),
+    stream: bare.readBool(bc)
+  };
+}
+function writeToServerResponseStart(bc, x) {
+  bare.writeU16(bc, x.status);
+  write9(bc, x.headers);
+  write6(bc, x.body);
+  bare.writeBool(bc, x.stream);
+}
+function readToServerResponseChunk(bc) {
+  return {
+    body: bare.readData(bc),
+    finish: bare.readBool(bc)
+  };
+}
+function writeToServerResponseChunk(bc, x) {
+  bare.writeData(bc, x.body);
+  bare.writeBool(bc, x.finish);
+}
+function readToClientWebSocketOpen(bc) {
+  return {
+    actorId: readId(bc),
+    path: bare.readString(bc),
+    headers: read9(bc)
+  };
+}
+function writeToClientWebSocketOpen(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeString(bc, x.path);
+  write9(bc, x.headers);
+}
+function readToClientWebSocketMessage(bc) {
+  return {
+    data: bare.readData(bc),
+    binary: bare.readBool(bc)
+  };
+}
+function writeToClientWebSocketMessage(bc, x) {
+  bare.writeData(bc, x.data);
+  bare.writeBool(bc, x.binary);
+}
+function read10(bc) {
+  return bare.readBool(bc) ? bare.readU16(bc) : null;
+}
+function write10(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU16(bc, x);
+  }
+}
+function readToClientWebSocketClose(bc) {
+  return {
+    code: read10(bc),
+    reason: read5(bc)
+  };
+}
+function writeToClientWebSocketClose(bc, x) {
+  write10(bc, x.code);
+  write5(bc, x.reason);
+}
+function readToServerWebSocketOpen(bc) {
+  return {
+    canHibernate: bare.readBool(bc)
+  };
+}
+function writeToServerWebSocketOpen(bc, x) {
+  bare.writeBool(bc, x.canHibernate);
+}
+function readToServerWebSocketMessage(bc) {
+  return {
+    data: bare.readData(bc),
+    binary: bare.readBool(bc)
+  };
+}
+function writeToServerWebSocketMessage(bc, x) {
+  bare.writeData(bc, x.data);
+  bare.writeBool(bc, x.binary);
+}
+function readToServerWebSocketMessageAck(bc) {
+  return {
+    index: readMessageIndex(bc)
+  };
+}
+function writeToServerWebSocketMessageAck(bc, x) {
+  writeMessageIndex(bc, x.index);
+}
+function readToServerWebSocketClose(bc) {
+  return {
+    code: read10(bc),
+    reason: read5(bc),
+    hibernate: bare.readBool(bc)
+  };
+}
+function writeToServerWebSocketClose(bc, x) {
+  write10(bc, x.code);
+  write5(bc, x.reason);
+  bare.writeBool(bc, x.hibernate);
+}
+function readToServerTunnelMessageKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "DeprecatedTunnelAck", val: null };
+    case 1:
+      return { tag: "ToServerResponseStart", val: readToServerResponseStart(bc) };
+    case 2:
+      return { tag: "ToServerResponseChunk", val: readToServerResponseChunk(bc) };
+    case 3:
+      return { tag: "ToServerResponseAbort", val: null };
+    case 4:
+      return { tag: "ToServerWebSocketOpen", val: readToServerWebSocketOpen(bc) };
+    case 5:
+      return { tag: "ToServerWebSocketMessage", val: readToServerWebSocketMessage(bc) };
+    case 6:
+      return { tag: "ToServerWebSocketMessageAck", val: readToServerWebSocketMessageAck(bc) };
+    case 7:
+      return { tag: "ToServerWebSocketClose", val: readToServerWebSocketClose(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerTunnelMessageKind(bc, x) {
+  switch (x.tag) {
+    case "DeprecatedTunnelAck": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "ToServerResponseStart": {
+      bare.writeU8(bc, 1);
+      writeToServerResponseStart(bc, x.val);
+      break;
+    }
+    case "ToServerResponseChunk": {
+      bare.writeU8(bc, 2);
+      writeToServerResponseChunk(bc, x.val);
+      break;
+    }
+    case "ToServerResponseAbort": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToServerWebSocketOpen": {
+      bare.writeU8(bc, 4);
+      writeToServerWebSocketOpen(bc, x.val);
+      break;
+    }
+    case "ToServerWebSocketMessage": {
+      bare.writeU8(bc, 5);
+      writeToServerWebSocketMessage(bc, x.val);
+      break;
+    }
+    case "ToServerWebSocketMessageAck": {
+      bare.writeU8(bc, 6);
+      writeToServerWebSocketMessageAck(bc, x.val);
+      break;
+    }
+    case "ToServerWebSocketClose": {
+      bare.writeU8(bc, 7);
+      writeToServerWebSocketClose(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServerTunnelMessage(bc) {
+  return {
+    messageId: readMessageId(bc),
+    messageKind: readToServerTunnelMessageKind(bc)
+  };
+}
+function writeToServerTunnelMessage(bc, x) {
+  writeMessageId(bc, x.messageId);
+  writeToServerTunnelMessageKind(bc, x.messageKind);
+}
+function readToClientTunnelMessageKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "DeprecatedTunnelAck", val: null };
+    case 1:
+      return { tag: "ToClientRequestStart", val: readToClientRequestStart(bc) };
+    case 2:
+      return { tag: "ToClientRequestChunk", val: readToClientRequestChunk(bc) };
+    case 3:
+      return { tag: "ToClientRequestAbort", val: null };
+    case 4:
+      return { tag: "ToClientWebSocketOpen", val: readToClientWebSocketOpen(bc) };
+    case 5:
+      return { tag: "ToClientWebSocketMessage", val: readToClientWebSocketMessage(bc) };
+    case 6:
+      return { tag: "ToClientWebSocketClose", val: readToClientWebSocketClose(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientTunnelMessageKind(bc, x) {
+  switch (x.tag) {
+    case "DeprecatedTunnelAck": {
+      bare.writeU8(bc, 0);
+      break;
+    }
+    case "ToClientRequestStart": {
+      bare.writeU8(bc, 1);
+      writeToClientRequestStart(bc, x.val);
+      break;
+    }
+    case "ToClientRequestChunk": {
+      bare.writeU8(bc, 2);
+      writeToClientRequestChunk(bc, x.val);
+      break;
+    }
+    case "ToClientRequestAbort": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToClientWebSocketOpen": {
+      bare.writeU8(bc, 4);
+      writeToClientWebSocketOpen(bc, x.val);
+      break;
+    }
+    case "ToClientWebSocketMessage": {
+      bare.writeU8(bc, 5);
+      writeToClientWebSocketMessage(bc, x.val);
+      break;
+    }
+    case "ToClientWebSocketClose": {
+      bare.writeU8(bc, 6);
+      writeToClientWebSocketClose(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClientTunnelMessage(bc) {
+  return {
+    messageId: readMessageId(bc),
+    messageKind: readToClientTunnelMessageKind(bc)
+  };
+}
+function writeToClientTunnelMessage(bc, x) {
+  writeMessageId(bc, x.messageId);
+  writeToClientTunnelMessageKind(bc, x.messageKind);
+}
+function read11(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 write11(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    writeActorName(bc, kv[1]);
+  }
+}
+function read12(bc) {
+  return bare.readBool(bc) ? read11(bc) : null;
+}
+function write12(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    write11(bc, x);
+  }
+}
+function read13(bc) {
+  return bare.readBool(bc) ? readJson(bc) : null;
+}
+function write13(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    writeJson(bc, x);
+  }
+}
+function readToServerInit(bc) {
+  return {
+    name: bare.readString(bc),
+    version: bare.readU32(bc),
+    totalSlots: bare.readU32(bc),
+    lastCommandIdx: read7(bc),
+    prepopulateActorNames: read12(bc),
+    metadata: read13(bc)
+  };
+}
+function writeToServerInit(bc, x) {
+  bare.writeString(bc, x.name);
+  bare.writeU32(bc, x.version);
+  bare.writeU32(bc, x.totalSlots);
+  write7(bc, x.lastCommandIdx);
+  write12(bc, x.prepopulateActorNames);
+  write13(bc, x.metadata);
+}
+function readToServerEvents(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 writeToServerEvents(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeEventWrapper(bc, x[i]);
+  }
+}
+function readToServerAckCommands(bc) {
+  return {
+    lastCommandIdx: bare.readI64(bc)
+  };
+}
+function writeToServerAckCommands(bc, x) {
+  bare.writeI64(bc, x.lastCommandIdx);
+}
+function readToServerPing(bc) {
+  return {
+    ts: bare.readI64(bc)
+  };
+}
+function writeToServerPing(bc, x) {
+  bare.writeI64(bc, x.ts);
+}
+function readToServerKvRequest(bc) {
+  return {
+    actorId: readId(bc),
+    requestId: bare.readU32(bc),
+    data: readKvRequestData(bc)
+  };
+}
+function writeToServerKvRequest(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.requestId);
+  writeKvRequestData(bc, x.data);
+}
+function readToServer(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToServerInit", val: readToServerInit(bc) };
+    case 1:
+      return { tag: "ToServerEvents", val: readToServerEvents(bc) };
+    case 2:
+      return { tag: "ToServerAckCommands", val: readToServerAckCommands(bc) };
+    case 3:
+      return { tag: "ToServerStopping", val: null };
+    case 4:
+      return { tag: "ToServerPing", val: readToServerPing(bc) };
+    case 5:
+      return { tag: "ToServerKvRequest", val: readToServerKvRequest(bc) };
+    case 6:
+      return { tag: "ToServerTunnelMessage", val: readToServerTunnelMessage(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServer(bc, x) {
+  switch (x.tag) {
+    case "ToServerInit": {
+      bare.writeU8(bc, 0);
+      writeToServerInit(bc, x.val);
+      break;
+    }
+    case "ToServerEvents": {
+      bare.writeU8(bc, 1);
+      writeToServerEvents(bc, x.val);
+      break;
+    }
+    case "ToServerAckCommands": {
+      bare.writeU8(bc, 2);
+      writeToServerAckCommands(bc, x.val);
+      break;
+    }
+    case "ToServerStopping": {
+      bare.writeU8(bc, 3);
+      break;
+    }
+    case "ToServerPing": {
+      bare.writeU8(bc, 4);
+      writeToServerPing(bc, x.val);
+      break;
+    }
+    case "ToServerKvRequest": {
+      bare.writeU8(bc, 5);
+      writeToServerKvRequest(bc, x.val);
+      break;
+    }
+    case "ToServerTunnelMessage": {
+      bare.writeU8(bc, 6);
+      writeToServerTunnelMessage(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToServer(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServer(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToServer(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readProtocolMetadata(bc) {
+  return {
+    runnerLostThreshold: bare.readI64(bc)
+  };
+}
+function writeProtocolMetadata(bc, x) {
+  bare.writeI64(bc, x.runnerLostThreshold);
+}
+function readToClientInit(bc) {
+  return {
+    runnerId: readId(bc),
+    lastEventIdx: bare.readI64(bc),
+    metadata: readProtocolMetadata(bc)
+  };
+}
+function writeToClientInit(bc, x) {
+  writeId(bc, x.runnerId);
+  bare.writeI64(bc, x.lastEventIdx);
+  writeProtocolMetadata(bc, x.metadata);
+}
+function readToClientCommands(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 writeToClientCommands(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeCommandWrapper(bc, x[i]);
+  }
+}
+function readToClientAckEvents(bc) {
+  return {
+    lastEventIdx: bare.readI64(bc)
+  };
+}
+function writeToClientAckEvents(bc, x) {
+  bare.writeI64(bc, x.lastEventIdx);
+}
+function readToClientKvResponse(bc) {
+  return {
+    requestId: bare.readU32(bc),
+    data: readKvResponseData(bc)
+  };
+}
+function writeToClientKvResponse(bc, x) {
+  bare.writeU32(bc, x.requestId);
+  writeKvResponseData(bc, x.data);
+}
+function readToClient(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToClientInit", val: readToClientInit(bc) };
+    case 1:
+      return { tag: "ToClientClose", val: null };
+    case 2:
+      return { tag: "ToClientCommands", val: readToClientCommands(bc) };
+    case 3:
+      return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) };
+    case 4:
+      return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) };
+    case 5:
+      return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClient(bc, x) {
+  switch (x.tag) {
+    case "ToClientInit": {
+      bare.writeU8(bc, 0);
+      writeToClientInit(bc, x.val);
+      break;
+    }
+    case "ToClientClose": {
+      bare.writeU8(bc, 1);
+      break;
+    }
+    case "ToClientCommands": {
+      bare.writeU8(bc, 2);
+      writeToClientCommands(bc, x.val);
+      break;
+    }
+    case "ToClientAckEvents": {
+      bare.writeU8(bc, 3);
+      writeToClientAckEvents(bc, x.val);
+      break;
+    }
+    case "ToClientKvResponse": {
+      bare.writeU8(bc, 4);
+      writeToClientKvResponse(bc, x.val);
+      break;
+    }
+    case "ToClientTunnelMessage": {
+      bare.writeU8(bc, 5);
+      writeToClientTunnelMessage(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToClient(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToClient(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToClient(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readToRunnerPing(bc) {
+  return {
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc),
+    ts: bare.readI64(bc)
+  };
+}
+function writeToRunnerPing(bc, x) {
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+  bare.writeI64(bc, x.ts);
+}
+function readToRunner(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToRunnerPing", val: readToRunnerPing(bc) };
+    case 1:
+      return { tag: "ToClientInit", val: readToClientInit(bc) };
+    case 2:
+      return { tag: "ToClientClose", val: null };
+    case 3:
+      return { tag: "ToClientCommands", val: readToClientCommands(bc) };
+    case 4:
+      return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) };
+    case 5:
+      return { tag: "ToClientKvResponse", val: readToClientKvResponse(bc) };
+    case 6:
+      return { tag: "ToClientTunnelMessage", val: readToClientTunnelMessage(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToRunner(bc, x) {
+  switch (x.tag) {
+    case "ToRunnerPing": {
+      bare.writeU8(bc, 0);
+      writeToRunnerPing(bc, x.val);
+      break;
+    }
+    case "ToClientInit": {
+      bare.writeU8(bc, 1);
+      writeToClientInit(bc, x.val);
+      break;
+    }
+    case "ToClientClose": {
+      bare.writeU8(bc, 2);
+      break;
+    }
+    case "ToClientCommands": {
+      bare.writeU8(bc, 3);
+      writeToClientCommands(bc, x.val);
+      break;
+    }
+    case "ToClientAckEvents": {
+      bare.writeU8(bc, 4);
+      writeToClientAckEvents(bc, x.val);
+      break;
+    }
+    case "ToClientKvResponse": {
+      bare.writeU8(bc, 5);
+      writeToClientKvResponse(bc, x.val);
+      break;
+    }
+    case "ToClientTunnelMessage": {
+      bare.writeU8(bc, 6);
+      writeToClientTunnelMessage(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToRunner(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToRunner(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToRunner(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToRunner(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: "ToServerTunnelMessage", val: readToServerTunnelMessage(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 "ToServerTunnelMessage": {
+      bare.writeU8(bc, 1);
+      writeToServerTunnelMessage(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 readToServerlessServerInit(bc) {
+  return {
+    runnerId: readId(bc)
+  };
+}
+function writeToServerlessServerInit(bc, x) {
+  writeId(bc, x.runnerId);
+}
+function readToServerlessServer(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ToServerlessServerInit", val: readToServerlessServerInit(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerlessServer(bc, x) {
+  switch (x.tag) {
+    case "ToServerlessServerInit": {
+      bare.writeU8(bc, 0);
+      writeToServerlessServerInit(bc, x.val);
+      break;
+    }
+  }
+}
+function encodeToServerlessServer(x, config) {
+  const fullConfig = config != null ? bare.Config(config) : DEFAULT_CONFIG;
+  const bc = new bare.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServerlessServer(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServerlessServer(bytes) {
+  const bc = new bare.ByteCursor(bytes, DEFAULT_CONFIG);
+  const result = readToServerlessServer(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.StopCode = StopCode; exports.decodeToClient = decodeToClient; exports.decodeToGateway = decodeToGateway; exports.decodeToRunner = decodeToRunner; exports.decodeToServer = decodeToServer; exports.decodeToServerlessServer = decodeToServerlessServer; exports.encodeToClient = encodeToClient; exports.encodeToGateway = encodeToGateway; exports.encodeToRunner = encodeToRunner; exports.encodeToServer = encodeToServer; exports.encodeToServerlessServer = encodeToServerlessServer; exports.readActorConfig = readActorConfig; exports.readActorIntent = readActorIntent; exports.readActorName = readActorName; exports.readActorState = readActorState; exports.readActorStateStopped = readActorStateStopped; exports.readCommand = readCommand; exports.readCommandStartActor = readCommandStartActor; exports.readCommandStopActor = readCommandStopActor; exports.readCommandWrapper = readCommandWrapper; exports.readEvent = readEvent; exports.readEventActorIntent = readEventActorIntent; exports.readEventActorSetAlarm = readEventActorSetAlarm; exports.readEventActorStateUpdate = readEventActorStateUpdate; exports.readEventWrapper = readEventWrapper; exports.readGatewayId = readGatewayId; exports.readHibernatingRequest = readHibernatingRequest; exports.readId = readId; exports.readJson = readJson; exports.readKvDeleteRequest = readKvDeleteRequest; exports.readKvErrorResponse = readKvErrorResponse; exports.readKvGetRequest = readKvGetRequest; exports.readKvGetResponse = readKvGetResponse; exports.readKvKey = readKvKey; exports.readKvListPrefixQuery = readKvListPrefixQuery; exports.readKvListQuery = readKvListQuery; exports.readKvListRangeQuery = readKvListRangeQuery; exports.readKvListRequest = readKvListRequest; exports.readKvListResponse = readKvListResponse; exports.readKvMetadata = readKvMetadata; exports.readKvPutRequest = readKvPutRequest; exports.readKvRequestData = readKvRequestData; exports.readKvResponseData = readKvResponseData; exports.readKvValue = readKvValue; exports.readMessageId = readMessageId; exports.readMessageIndex = readMessageIndex; exports.readProtocolMetadata = readProtocolMetadata; exports.readRequestId = readRequestId; exports.readStopCode = readStopCode; exports.readToClient = readToClient; exports.readToClientAckEvents = readToClientAckEvents; exports.readToClientCommands = readToClientCommands; exports.readToClientInit = readToClientInit; exports.readToClientKvResponse = readToClientKvResponse; exports.readToClientRequestChunk = readToClientRequestChunk; exports.readToClientRequestStart = readToClientRequestStart; exports.readToClientTunnelMessage = readToClientTunnelMessage; exports.readToClientTunnelMessageKind = readToClientTunnelMessageKind; exports.readToClientWebSocketClose = readToClientWebSocketClose; exports.readToClientWebSocketMessage = readToClientWebSocketMessage; exports.readToClientWebSocketOpen = readToClientWebSocketOpen; exports.readToGateway = readToGateway; exports.readToGatewayPong = readToGatewayPong; exports.readToRunner = readToRunner; exports.readToRunnerPing = readToRunnerPing; exports.readToServer = readToServer; exports.readToServerAckCommands = readToServerAckCommands; exports.readToServerEvents = readToServerEvents; exports.readToServerInit = readToServerInit; exports.readToServerKvRequest = readToServerKvRequest; exports.readToServerPing = readToServerPing; exports.readToServerResponseChunk = readToServerResponseChunk; exports.readToServerResponseStart = readToServerResponseStart; exports.readToServerTunnelMessage = readToServerTunnelMessage; exports.readToServerTunnelMessageKind = readToServerTunnelMessageKind; exports.readToServerWebSocketClose = readToServerWebSocketClose; exports.readToServerWebSocketMessage = readToServerWebSocketMessage; exports.readToServerWebSocketMessageAck = readToServerWebSocketMessageAck; exports.readToServerWebSocketOpen = readToServerWebSocketOpen; exports.readToServerlessServer = readToServerlessServer; exports.readToServerlessServerInit = readToServerlessServerInit; exports.writeActorConfig = writeActorConfig; exports.writeActorIntent = writeActorIntent; exports.writeActorName = writeActorName; exports.writeActorState = writeActorState; exports.writeActorStateStopped = writeActorStateStopped; exports.writeCommand = writeCommand; exports.writeCommandStartActor = writeCommandStartActor; exports.writeCommandStopActor = writeCommandStopActor; exports.writeCommandWrapper = writeCommandWrapper; exports.writeEvent = writeEvent; exports.writeEventActorIntent = writeEventActorIntent; exports.writeEventActorSetAlarm = writeEventActorSetAlarm; exports.writeEventActorStateUpdate = writeEventActorStateUpdate; exports.writeEventWrapper = writeEventWrapper; exports.writeGatewayId = writeGatewayId; exports.writeHibernatingRequest = writeHibernatingRequest; exports.writeId = writeId; exports.writeJson = writeJson; exports.writeKvDeleteRequest = writeKvDeleteRequest; exports.writeKvErrorResponse = writeKvErrorResponse; exports.writeKvGetRequest = writeKvGetRequest; exports.writeKvGetResponse = writeKvGetResponse; exports.writeKvKey = writeKvKey; exports.writeKvListPrefixQuery = writeKvListPrefixQuery; exports.writeKvListQuery = writeKvListQuery; exports.writeKvListRangeQuery = writeKvListRangeQuery; exports.writeKvListRequest = writeKvListRequest; exports.writeKvListResponse = writeKvListResponse; exports.writeKvMetadata = writeKvMetadata; exports.writeKvPutRequest = writeKvPutRequest; exports.writeKvRequestData = writeKvRequestData; exports.writeKvResponseData = writeKvResponseData; exports.writeKvValue = writeKvValue; exports.writeMessageId = writeMessageId; exports.writeMessageIndex = writeMessageIndex; exports.writeProtocolMetadata = writeProtocolMetadata; exports.writeRequestId = writeRequestId; exports.writeStopCode = writeStopCode; exports.writeToClient = writeToClient; exports.writeToClientAckEvents = writeToClientAckEvents; exports.writeToClientCommands = writeToClientCommands; exports.writeToClientInit = writeToClientInit; exports.writeToClientKvResponse = writeToClientKvResponse; exports.writeToClientRequestChunk = writeToClientRequestChunk; exports.writeToClientRequestStart = writeToClientRequestStart; exports.writeToClientTunnelMessage = writeToClientTunnelMessage; exports.writeToClientTunnelMessageKind = writeToClientTunnelMessageKind; exports.writeToClientWebSocketClose = writeToClientWebSocketClose; exports.writeToClientWebSocketMessage = writeToClientWebSocketMessage; exports.writeToClientWebSocketOpen = writeToClientWebSocketOpen; exports.writeToGateway = writeToGateway; exports.writeToGatewayPong = writeToGatewayPong; exports.writeToRunner = writeToRunner; exports.writeToRunnerPing = writeToRunnerPing; exports.writeToServer = writeToServer; exports.writeToServerAckCommands = writeToServerAckCommands; exports.writeToServerEvents = writeToServerEvents; exports.writeToServerInit = writeToServerInit; exports.writeToServerKvRequest = writeToServerKvRequest; exports.writeToServerPing = writeToServerPing; exports.writeToServerResponseChunk = writeToServerResponseChunk; exports.writeToServerResponseStart = writeToServerResponseStart; exports.writeToServerTunnelMessage = writeToServerTunnelMessage; exports.writeToServerTunnelMessageKind = writeToServerTunnelMessageKind; exports.writeToServerWebSocketClose = writeToServerWebSocketClose; exports.writeToServerWebSocketMessage = writeToServerWebSocketMessage; exports.writeToServerWebSocketMessageAck = writeToServerWebSocketMessageAck; exports.writeToServerWebSocketOpen = writeToServerWebSocketOpen; exports.writeToServerlessServer = writeToServerlessServer; exports.writeToServerlessServerInit = writeToServerlessServerInit;
+//# sourceMappingURL=index.cjs.map