@rivetkit/engine-runner-protocol 25.7.1-rc.1

package/dist/index.d.ts

@@ -0,0 +1,345 @@
+import * as bare from '@bare-ts/lib';
+
+type i64 = bigint;
+type u32 = number;
+type u64 = bigint;
+type Id = string;
+declare function readId(bc: bare.ByteCursor): Id;
+declare function writeId(bc: bare.ByteCursor, x: Id): void;
+type Json = string;
+declare function readJson(bc: bare.ByteCursor): Json;
+declare function writeJson(bc: bare.ByteCursor, x: Json): void;
+type KvKey = ArrayBuffer;
+declare function readKvKey(bc: bare.ByteCursor): KvKey;
+declare function writeKvKey(bc: bare.ByteCursor, x: KvKey): void;
+type KvValue = ArrayBuffer;
+declare function readKvValue(bc: bare.ByteCursor): KvValue;
+declare function writeKvValue(bc: bare.ByteCursor, x: KvValue): void;
+type KvMetadata = {
+    readonly version: ArrayBuffer;
+    readonly createTs: i64;
+};
+declare function readKvMetadata(bc: bare.ByteCursor): KvMetadata;
+declare function writeKvMetadata(bc: bare.ByteCursor, x: KvMetadata): void;
+type KvListAllQuery = null;
+type KvListRangeQuery = {
+    readonly start: KvKey;
+    readonly end: KvKey;
+    readonly exclusive: boolean;
+};
+declare function readKvListRangeQuery(bc: bare.ByteCursor): KvListRangeQuery;
+declare function writeKvListRangeQuery(bc: bare.ByteCursor, x: KvListRangeQuery): void;
+type KvListPrefixQuery = {
+    readonly key: KvKey;
+};
+declare function readKvListPrefixQuery(bc: bare.ByteCursor): KvListPrefixQuery;
+declare function writeKvListPrefixQuery(bc: bare.ByteCursor, x: KvListPrefixQuery): void;
+type KvListQuery = {
+    readonly tag: "KvListAllQuery";
+    readonly val: KvListAllQuery;
+} | {
+    readonly tag: "KvListRangeQuery";
+    readonly val: KvListRangeQuery;
+} | {
+    readonly tag: "KvListPrefixQuery";
+    readonly val: KvListPrefixQuery;
+};
+declare function readKvListQuery(bc: bare.ByteCursor): KvListQuery;
+declare function writeKvListQuery(bc: bare.ByteCursor, x: KvListQuery): void;
+type ActorName = {
+    readonly metadata: Json;
+};
+declare function readActorName(bc: bare.ByteCursor): ActorName;
+declare function writeActorName(bc: bare.ByteCursor, x: ActorName): void;
+declare enum StopCode {
+    Ok = "Ok",
+    Error = "Error"
+}
+declare function readStopCode(bc: bare.ByteCursor): StopCode;
+declare function writeStopCode(bc: bare.ByteCursor, x: StopCode): void;
+type ActorIntentSleep = null;
+type ActorIntentStop = null;
+type ActorIntent = {
+    readonly tag: "ActorIntentSleep";
+    readonly val: ActorIntentSleep;
+} | {
+    readonly tag: "ActorIntentStop";
+    readonly val: ActorIntentStop;
+};
+declare function readActorIntent(bc: bare.ByteCursor): ActorIntent;
+declare function writeActorIntent(bc: bare.ByteCursor, x: ActorIntent): void;
+type ActorStateRunning = null;
+type ActorStateStopped = {
+    readonly code: StopCode;
+    readonly message: string | null;
+};
+declare function readActorStateStopped(bc: bare.ByteCursor): ActorStateStopped;
+declare function writeActorStateStopped(bc: bare.ByteCursor, x: ActorStateStopped): void;
+type ActorState = {
+    readonly tag: "ActorStateRunning";
+    readonly val: ActorStateRunning;
+} | {
+    readonly tag: "ActorStateStopped";
+    readonly val: ActorStateStopped;
+};
+declare function readActorState(bc: bare.ByteCursor): ActorState;
+declare function writeActorState(bc: bare.ByteCursor, x: ActorState): void;
+type EventActorIntent = {
+    readonly actorId: Id;
+    readonly generation: u32;
+    readonly intent: ActorIntent;
+};
+declare function readEventActorIntent(bc: bare.ByteCursor): EventActorIntent;
+declare function writeEventActorIntent(bc: bare.ByteCursor, x: EventActorIntent): void;
+type EventActorStateUpdate = {
+    readonly actorId: Id;
+    readonly generation: u32;
+    readonly state: ActorState;
+};
+declare function readEventActorStateUpdate(bc: bare.ByteCursor): EventActorStateUpdate;
+declare function writeEventActorStateUpdate(bc: bare.ByteCursor, x: EventActorStateUpdate): void;
+type EventActorSetAlarm = {
+    readonly actorId: Id;
+    readonly generation: u32;
+    readonly alarmTs: i64 | null;
+};
+declare function readEventActorSetAlarm(bc: bare.ByteCursor): EventActorSetAlarm;
+declare function writeEventActorSetAlarm(bc: bare.ByteCursor, x: EventActorSetAlarm): void;
+type Event = {
+    readonly tag: "EventActorIntent";
+    readonly val: EventActorIntent;
+} | {
+    readonly tag: "EventActorStateUpdate";
+    readonly val: EventActorStateUpdate;
+} | {
+    readonly tag: "EventActorSetAlarm";
+    readonly val: EventActorSetAlarm;
+};
+declare function readEvent(bc: bare.ByteCursor): Event;
+declare function writeEvent(bc: bare.ByteCursor, x: Event): void;
+type EventWrapper = {
+    readonly index: i64;
+    readonly inner: Event;
+};
+declare function readEventWrapper(bc: bare.ByteCursor): EventWrapper;
+declare function writeEventWrapper(bc: bare.ByteCursor, x: EventWrapper): void;
+type ActorConfig = {
+    readonly name: string;
+    readonly key: string | null;
+    readonly createTs: i64;
+    readonly input: ArrayBuffer | null;
+};
+declare function readActorConfig(bc: bare.ByteCursor): ActorConfig;
+declare function writeActorConfig(bc: bare.ByteCursor, x: ActorConfig): void;
+type CommandStartActor = {
+    readonly actorId: Id;
+    readonly generation: u32;
+    readonly config: ActorConfig;
+};
+declare function readCommandStartActor(bc: bare.ByteCursor): CommandStartActor;
+declare function writeCommandStartActor(bc: bare.ByteCursor, x: CommandStartActor): void;
+type CommandStopActor = {
+    readonly actorId: Id;
+    readonly generation: u32;
+};
+declare function readCommandStopActor(bc: bare.ByteCursor): CommandStopActor;
+declare function writeCommandStopActor(bc: bare.ByteCursor, x: CommandStopActor): void;
+type Command = {
+    readonly tag: "CommandStartActor";
+    readonly val: CommandStartActor;
+} | {
+    readonly tag: "CommandStopActor";
+    readonly val: CommandStopActor;
+};
+declare function readCommand(bc: bare.ByteCursor): Command;
+declare function writeCommand(bc: bare.ByteCursor, x: Command): void;
+type CommandWrapper = {
+    readonly index: i64;
+    readonly inner: Command;
+};
+declare function readCommandWrapper(bc: bare.ByteCursor): CommandWrapper;
+declare function writeCommandWrapper(bc: bare.ByteCursor, x: CommandWrapper): void;
+type ToServerInit = {
+    readonly name: string;
+    readonly version: u32;
+    readonly totalSlots: u32;
+    readonly lastCommandIdx: i64 | null;
+    readonly prepopulateActorNames: ReadonlyMap<string, ActorName> | null;
+    readonly metadata: Json | null;
+};
+declare function readToServerInit(bc: bare.ByteCursor): ToServerInit;
+declare function writeToServerInit(bc: bare.ByteCursor, x: ToServerInit): void;
+type ToServerEvents = readonly EventWrapper[];
+declare function readToServerEvents(bc: bare.ByteCursor): ToServerEvents;
+declare function writeToServerEvents(bc: bare.ByteCursor, x: ToServerEvents): void;
+type ToServerAckCommands = {
+    readonly lastCommandIdx: i64;
+};
+declare function readToServerAckCommands(bc: bare.ByteCursor): ToServerAckCommands;
+declare function writeToServerAckCommands(bc: bare.ByteCursor, x: ToServerAckCommands): void;
+type ToServerStopping = null;
+type ToServerPing = {
+    readonly ts: i64;
+};
+declare function readToServerPing(bc: bare.ByteCursor): ToServerPing;
+declare function writeToServerPing(bc: bare.ByteCursor, x: ToServerPing): void;
+type KvGetRequest = {
+    readonly keys: readonly KvKey[];
+};
+declare function readKvGetRequest(bc: bare.ByteCursor): KvGetRequest;
+declare function writeKvGetRequest(bc: bare.ByteCursor, x: KvGetRequest): void;
+type KvListRequest = {
+    readonly query: KvListQuery;
+    readonly reverse: boolean | null;
+    readonly limit: u64 | null;
+};
+declare function readKvListRequest(bc: bare.ByteCursor): KvListRequest;
+declare function writeKvListRequest(bc: bare.ByteCursor, x: KvListRequest): void;
+type KvPutRequest = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+};
+declare function readKvPutRequest(bc: bare.ByteCursor): KvPutRequest;
+declare function writeKvPutRequest(bc: bare.ByteCursor, x: KvPutRequest): void;
+type KvDeleteRequest = {
+    readonly keys: readonly KvKey[];
+};
+declare function readKvDeleteRequest(bc: bare.ByteCursor): KvDeleteRequest;
+declare function writeKvDeleteRequest(bc: bare.ByteCursor, x: KvDeleteRequest): void;
+type KvDropRequest = null;
+type KvRequestData = {
+    readonly tag: "KvGetRequest";
+    readonly val: KvGetRequest;
+} | {
+    readonly tag: "KvListRequest";
+    readonly val: KvListRequest;
+} | {
+    readonly tag: "KvPutRequest";
+    readonly val: KvPutRequest;
+} | {
+    readonly tag: "KvDeleteRequest";
+    readonly val: KvDeleteRequest;
+} | {
+    readonly tag: "KvDropRequest";
+    readonly val: KvDropRequest;
+};
+declare function readKvRequestData(bc: bare.ByteCursor): KvRequestData;
+declare function writeKvRequestData(bc: bare.ByteCursor, x: KvRequestData): void;
+type ToServerKvRequest = {
+    readonly actorId: Id;
+    readonly requestId: u32;
+    readonly data: KvRequestData;
+};
+declare function readToServerKvRequest(bc: bare.ByteCursor): ToServerKvRequest;
+declare function writeToServerKvRequest(bc: bare.ByteCursor, x: ToServerKvRequest): void;
+type ToServer = {
+    readonly tag: "ToServerInit";
+    readonly val: ToServerInit;
+} | {
+    readonly tag: "ToServerEvents";
+    readonly val: ToServerEvents;
+} | {
+    readonly tag: "ToServerAckCommands";
+    readonly val: ToServerAckCommands;
+} | {
+    readonly tag: "ToServerStopping";
+    readonly val: ToServerStopping;
+} | {
+    readonly tag: "ToServerPing";
+    readonly val: ToServerPing;
+} | {
+    readonly tag: "ToServerKvRequest";
+    readonly val: ToServerKvRequest;
+};
+declare function readToServer(bc: bare.ByteCursor): ToServer;
+declare function writeToServer(bc: bare.ByteCursor, x: ToServer): void;
+declare function encodeToServer(x: ToServer, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToServer(bytes: Uint8Array): ToServer;
+type ProtocolMetadata = {
+    readonly runnerLostThreshold: i64;
+};
+declare function readProtocolMetadata(bc: bare.ByteCursor): ProtocolMetadata;
+declare function writeProtocolMetadata(bc: bare.ByteCursor, x: ProtocolMetadata): void;
+type ToClientInit = {
+    readonly runnerId: Id;
+    readonly lastEventIdx: i64;
+    readonly metadata: ProtocolMetadata;
+};
+declare function readToClientInit(bc: bare.ByteCursor): ToClientInit;
+declare function writeToClientInit(bc: bare.ByteCursor, x: ToClientInit): void;
+type ToClientCommands = readonly CommandWrapper[];
+declare function readToClientCommands(bc: bare.ByteCursor): ToClientCommands;
+declare function writeToClientCommands(bc: bare.ByteCursor, x: ToClientCommands): void;
+type ToClientAckEvents = {
+    readonly lastEventIdx: i64;
+};
+declare function readToClientAckEvents(bc: bare.ByteCursor): ToClientAckEvents;
+declare function writeToClientAckEvents(bc: bare.ByteCursor, x: ToClientAckEvents): void;
+type KvErrorResponse = {
+    readonly message: string;
+};
+declare function readKvErrorResponse(bc: bare.ByteCursor): KvErrorResponse;
+declare function writeKvErrorResponse(bc: bare.ByteCursor, x: KvErrorResponse): void;
+type KvGetResponse = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+    readonly metadata: readonly KvMetadata[];
+};
+declare function readKvGetResponse(bc: bare.ByteCursor): KvGetResponse;
+declare function writeKvGetResponse(bc: bare.ByteCursor, x: KvGetResponse): void;
+type KvListResponse = {
+    readonly keys: readonly KvKey[];
+    readonly values: readonly KvValue[];
+    readonly metadata: readonly KvMetadata[];
+};
+declare function readKvListResponse(bc: bare.ByteCursor): KvListResponse;
+declare function writeKvListResponse(bc: bare.ByteCursor, x: KvListResponse): void;
+type KvPutResponse = null;
+type KvDeleteResponse = null;
+type KvDropResponse = null;
+type KvResponseData = {
+    readonly tag: "KvErrorResponse";
+    readonly val: KvErrorResponse;
+} | {
+    readonly tag: "KvGetResponse";
+    readonly val: KvGetResponse;
+} | {
+    readonly tag: "KvListResponse";
+    readonly val: KvListResponse;
+} | {
+    readonly tag: "KvPutResponse";
+    readonly val: KvPutResponse;
+} | {
+    readonly tag: "KvDeleteResponse";
+    readonly val: KvDeleteResponse;
+} | {
+    readonly tag: "KvDropResponse";
+    readonly val: KvDropResponse;
+};
+declare function readKvResponseData(bc: bare.ByteCursor): KvResponseData;
+declare function writeKvResponseData(bc: bare.ByteCursor, x: KvResponseData): void;
+type ToClientKvResponse = {
+    readonly requestId: u32;
+    readonly data: KvResponseData;
+};
+declare function readToClientKvResponse(bc: bare.ByteCursor): ToClientKvResponse;
+declare function writeToClientKvResponse(bc: bare.ByteCursor, x: ToClientKvResponse): void;
+type ToClient = {
+    readonly tag: "ToClientInit";
+    readonly val: ToClientInit;
+} | {
+    readonly tag: "ToClientCommands";
+    readonly val: ToClientCommands;
+} | {
+    readonly tag: "ToClientAckEvents";
+    readonly val: ToClientAckEvents;
+} | {
+    readonly tag: "ToClientKvResponse";
+    readonly val: ToClientKvResponse;
+};
+declare function readToClient(bc: bare.ByteCursor): ToClient;
+declare function writeToClient(bc: bare.ByteCursor, x: ToClient): void;
+declare function encodeToClient(x: ToClient, config?: Partial<bare.Config>): Uint8Array;
+declare function decodeToClient(bytes: Uint8Array): ToClient;
+
+export { type ActorConfig, type ActorIntent, type ActorIntentSleep, type ActorIntentStop, type ActorName, type ActorState, type ActorStateRunning, type ActorStateStopped, type Command, type CommandStartActor, type CommandStopActor, type CommandWrapper, type Event, type EventActorIntent, type EventActorSetAlarm, type EventActorStateUpdate, type EventWrapper, type Id, type Json, type KvDeleteRequest, type KvDeleteResponse, type KvDropRequest, type KvDropResponse, type KvErrorResponse, type KvGetRequest, type KvGetResponse, type KvKey, type KvListAllQuery, type KvListPrefixQuery, type KvListQuery, type KvListRangeQuery, type KvListRequest, type KvListResponse, type KvMetadata, type KvPutRequest, type KvPutResponse, type KvRequestData, type KvResponseData, type KvValue, type ProtocolMetadata, StopCode, type ToClient, type ToClientAckEvents, type ToClientCommands, type ToClientInit, type ToClientKvResponse, type ToServer, type ToServerAckCommands, type ToServerEvents, type ToServerInit, type ToServerKvRequest, type ToServerPing, type ToServerStopping, decodeToClient, decodeToServer, encodeToClient, encodeToServer, type i64, readActorConfig, readActorIntent, readActorName, readActorState, readActorStateStopped, readCommand, readCommandStartActor, readCommandStopActor, readCommandWrapper, readEvent, readEventActorIntent, readEventActorSetAlarm, readEventActorStateUpdate, readEventWrapper, readId, readJson, readKvDeleteRequest, readKvErrorResponse, readKvGetRequest, readKvGetResponse, readKvKey, readKvListPrefixQuery, readKvListQuery, readKvListRangeQuery, readKvListRequest, readKvListResponse, readKvMetadata, readKvPutRequest, readKvRequestData, readKvResponseData, readKvValue, readProtocolMetadata, readStopCode, readToClient, readToClientAckEvents, readToClientCommands, readToClientInit, readToClientKvResponse, readToServer, readToServerAckCommands, readToServerEvents, readToServerInit, readToServerKvRequest, readToServerPing, type u32, type u64, writeActorConfig, writeActorIntent, writeActorName, writeActorState, writeActorStateStopped, writeCommand, writeCommandStartActor, writeCommandStopActor, writeCommandWrapper, writeEvent, writeEventActorIntent, writeEventActorSetAlarm, writeEventActorStateUpdate, writeEventWrapper, writeId, writeJson, writeKvDeleteRequest, writeKvErrorResponse, writeKvGetRequest, writeKvGetResponse, writeKvKey, writeKvListPrefixQuery, writeKvListQuery, writeKvListRangeQuery, writeKvListRequest, writeKvListResponse, writeKvMetadata, writeKvPutRequest, writeKvRequestData, writeKvResponseData, writeKvValue, writeProtocolMetadata, writeStopCode, writeToClient, writeToClientAckEvents, writeToClientCommands, writeToClientInit, writeToClientKvResponse, writeToServer, writeToServerAckCommands, writeToServerEvents, writeToServerInit, writeToServerKvRequest, writeToServerPing };

package/dist/index.js

@@ -0,0 +1,999 @@
+// src/index.ts
+import * as bare from "@bare-ts/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 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 readActorName(bc) {
+  return {
+    metadata: readJson(bc)
+  };
+}
+function writeActorName(bc, x) {
+  writeJson(bc, x.metadata);
+}
+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 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 read0(bc) {
+  return bare.readBool(bc) ? bare.readString(bc) : null;
+}
+function write0(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeString(bc, x);
+  }
+}
+function readActorStateStopped(bc) {
+  return {
+    code: readStopCode(bc),
+    message: read0(bc)
+  };
+}
+function writeActorStateStopped(bc, x) {
+  writeStopCode(bc, x.code);
+  write0(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 read1(bc) {
+  return bare.readBool(bc) ? bare.readI64(bc) : null;
+}
+function write1(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: read1(bc)
+  };
+}
+function writeEventActorSetAlarm(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  write1(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 read2(bc) {
+  return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write2(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeData(bc, x);
+  }
+}
+function readActorConfig(bc) {
+  return {
+    name: bare.readString(bc),
+    key: read0(bc),
+    createTs: bare.readI64(bc),
+    input: read2(bc)
+  };
+}
+function writeActorConfig(bc, x) {
+  bare.writeString(bc, x.name);
+  write0(bc, x.key);
+  bare.writeI64(bc, x.createTs);
+  write2(bc, x.input);
+}
+function readCommandStartActor(bc) {
+  return {
+    actorId: readId(bc),
+    generation: bare.readU32(bc),
+    config: readActorConfig(bc)
+  };
+}
+function writeCommandStartActor(bc, x) {
+  writeId(bc, x.actorId);
+  bare.writeU32(bc, x.generation);
+  writeActorConfig(bc, x.config);
+}
+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 read3(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 write3(bc, x) {
+  bare.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare.writeString(bc, kv[0]);
+    writeActorName(bc, kv[1]);
+  }
+}
+function read4(bc) {
+  return bare.readBool(bc) ? read3(bc) : null;
+}
+function write4(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    write3(bc, x);
+  }
+}
+function read5(bc) {
+  return bare.readBool(bc) ? readJson(bc) : null;
+}
+function write5(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: read1(bc),
+    prepopulateActorNames: read4(bc),
+    metadata: read5(bc)
+  };
+}
+function writeToServerInit(bc, x) {
+  bare.writeString(bc, x.name);
+  bare.writeU32(bc, x.version);
+  bare.writeU32(bc, x.totalSlots);
+  write1(bc, x.lastCommandIdx);
+  write4(bc, x.prepopulateActorNames);
+  write5(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 read6(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 write6(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvKey(bc, x[i]);
+  }
+}
+function readKvGetRequest(bc) {
+  return {
+    keys: read6(bc)
+  };
+}
+function writeKvGetRequest(bc, x) {
+  write6(bc, x.keys);
+}
+function read7(bc) {
+  return bare.readBool(bc) ? bare.readBool(bc) : null;
+}
+function write7(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeBool(bc, x);
+  }
+}
+function read8(bc) {
+  return bare.readBool(bc) ? bare.readU64(bc) : null;
+}
+function write8(bc, x) {
+  bare.writeBool(bc, x != null);
+  if (x != null) {
+    bare.writeU64(bc, x);
+  }
+}
+function readKvListRequest(bc) {
+  return {
+    query: readKvListQuery(bc),
+    reverse: read7(bc),
+    limit: read8(bc)
+  };
+}
+function writeKvListRequest(bc, x) {
+  writeKvListQuery(bc, x.query);
+  write7(bc, x.reverse);
+  write8(bc, x.limit);
+}
+function read9(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 write9(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvValue(bc, x[i]);
+  }
+}
+function readKvPutRequest(bc) {
+  return {
+    keys: read6(bc),
+    values: read9(bc)
+  };
+}
+function writeKvPutRequest(bc, x) {
+  write6(bc, x.keys);
+  write9(bc, x.values);
+}
+function readKvDeleteRequest(bc) {
+  return {
+    keys: read6(bc)
+  };
+}
+function writeKvDeleteRequest(bc, x) {
+  write6(bc, x.keys);
+}
+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 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) };
+    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;
+    }
+  }
+}
+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 readKvErrorResponse(bc) {
+  return {
+    message: bare.readString(bc)
+  };
+}
+function writeKvErrorResponse(bc, x) {
+  bare.writeString(bc, x.message);
+}
+function read10(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 write10(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeKvMetadata(bc, x[i]);
+  }
+}
+function readKvGetResponse(bc) {
+  return {
+    keys: read6(bc),
+    values: read9(bc),
+    metadata: read10(bc)
+  };
+}
+function writeKvGetResponse(bc, x) {
+  write6(bc, x.keys);
+  write9(bc, x.values);
+  write10(bc, x.metadata);
+}
+function readKvListResponse(bc) {
+  return {
+    keys: read6(bc),
+    values: read9(bc),
+    metadata: read10(bc)
+  };
+}
+function writeKvListResponse(bc, x) {
+  write6(bc, x.keys);
+  write9(bc, x.values);
+  write10(bc, x.metadata);
+}
+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 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: "ToClientCommands", val: readToClientCommands(bc) };
+    case 2:
+      return { tag: "ToClientAckEvents", val: readToClientAckEvents(bc) };
+    case 3:
+      return { tag: "ToClientKvResponse", val: readToClientKvResponse(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 "ToClientCommands": {
+      bare.writeU8(bc, 1);
+      writeToClientCommands(bc, x.val);
+      break;
+    }
+    case "ToClientAckEvents": {
+      bare.writeU8(bc, 2);
+      writeToClientAckEvents(bc, x.val);
+      break;
+    }
+    case "ToClientKvResponse": {
+      bare.writeU8(bc, 3);
+      writeToClientKvResponse(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;
+}
+export {
+  StopCode,
+  decodeToClient,
+  decodeToServer,
+  encodeToClient,
+  encodeToServer,
+  readActorConfig,
+  readActorIntent,
+  readActorName,
+  readActorState,
+  readActorStateStopped,
+  readCommand,
+  readCommandStartActor,
+  readCommandStopActor,
+  readCommandWrapper,
+  readEvent,
+  readEventActorIntent,
+  readEventActorSetAlarm,
+  readEventActorStateUpdate,
+  readEventWrapper,
+  readId,
+  readJson,
+  readKvDeleteRequest,
+  readKvErrorResponse,
+  readKvGetRequest,
+  readKvGetResponse,
+  readKvKey,
+  readKvListPrefixQuery,
+  readKvListQuery,
+  readKvListRangeQuery,
+  readKvListRequest,
+  readKvListResponse,
+  readKvMetadata,
+  readKvPutRequest,
+  readKvRequestData,
+  readKvResponseData,
+  readKvValue,
+  readProtocolMetadata,
+  readStopCode,
+  readToClient,
+  readToClientAckEvents,
+  readToClientCommands,
+  readToClientInit,
+  readToClientKvResponse,
+  readToServer,
+  readToServerAckCommands,
+  readToServerEvents,
+  readToServerInit,
+  readToServerKvRequest,
+  readToServerPing,
+  writeActorConfig,
+  writeActorIntent,
+  writeActorName,
+  writeActorState,
+  writeActorStateStopped,
+  writeCommand,
+  writeCommandStartActor,
+  writeCommandStopActor,
+  writeCommandWrapper,
+  writeEvent,
+  writeEventActorIntent,
+  writeEventActorSetAlarm,
+  writeEventActorStateUpdate,
+  writeEventWrapper,
+  writeId,
+  writeJson,
+  writeKvDeleteRequest,
+  writeKvErrorResponse,
+  writeKvGetRequest,
+  writeKvGetResponse,
+  writeKvKey,
+  writeKvListPrefixQuery,
+  writeKvListQuery,
+  writeKvListRangeQuery,
+  writeKvListRequest,
+  writeKvListResponse,
+  writeKvMetadata,
+  writeKvPutRequest,
+  writeKvRequestData,
+  writeKvResponseData,
+  writeKvValue,
+  writeProtocolMetadata,
+  writeStopCode,
+  writeToClient,
+  writeToClientAckEvents,
+  writeToClientCommands,
+  writeToClientInit,
+  writeToClientKvResponse,
+  writeToServer,
+  writeToServerAckCommands,
+  writeToServerEvents,
+  writeToServerInit,
+  writeToServerKvRequest,
+  writeToServerPing
+};
+//# sourceMappingURL=index.js.map

package/package.json

@@ -0,0 +1,34 @@
+{
+	"name": "@rivetkit/engine-runner-protocol",
+	"version": "25.7.1-rc.1",
+	"license": "Apache-2.0",
+	"type": "module",
+	"exports": {
+		"import": {
+			"types": "./dist/index.d.ts",
+			"default": "./dist/index.js"
+		},
+		"require": {
+			"types": "./dist/index.d.cts",
+			"default": "./dist/index.cjs"
+		}
+	},
+	"files": [
+		"dist/**/*.js",
+		"dist/**/*.d.ts"
+	],
+	"scripts": {
+		"build": "tsup src/index.ts",
+		"clean": "rm -rf dist",
+		"check-types": "tsc --noEmit"
+	},
+	"types": "dist/index.d.ts",
+	"dependencies": {
+		"@bare-ts/lib": "^0.4.0"
+	},
+	"devDependencies": {
+		"@types/node": "^20.0.0",
+		"typescript": "^5.0.0",
+		"tsup": "^8.4.0"
+	}
+}