rivetkit 2.3.2 → 2.3.3-rc.2

package/dist/browser/inspector/client.js

@@ -2410,34 +2410,740 @@ function decodeToClient4(bytes) {
   return result;
 }
 
-// src/common/bare/transport/v1.ts
+// src/common/bare/generated/inspector/v5.ts
 import * as bare5 from "@rivetkit/bare-ts";
-var config = /* @__PURE__ */ bare5.Config({});
-function readWorkflowCbor(bc) {
+var DEFAULT_CONFIG5 = /* @__PURE__ */ bare5.Config({});
+function readState5(bc) {
   return bare5.readData(bc);
 }
-function writeWorkflowCbor(bc, x) {
+function writeState5(bc, x) {
+  bare5.writeData(bc, x);
+}
+function readWorkflowHistory4(bc) {
+  return bare5.readData(bc);
+}
+function writeWorkflowHistory4(bc, x) {
   bare5.writeData(bc, x);
 }
+function readPatchStateRequest5(bc) {
+  return {
+    state: bare5.readData(bc)
+  };
+}
+function writePatchStateRequest5(bc, x) {
+  bare5.writeData(bc, x.state);
+}
+function readActionRequest5(bc) {
+  return {
+    id: bare5.readUint(bc),
+    name: bare5.readString(bc),
+    args: bare5.readData(bc)
+  };
+}
+function writeActionRequest5(bc, x) {
+  bare5.writeUint(bc, x.id);
+  bare5.writeString(bc, x.name);
+  bare5.writeData(bc, x.args);
+}
+function readStateRequest5(bc) {
+  return {
+    id: bare5.readUint(bc)
+  };
+}
+function writeStateRequest5(bc, x) {
+  bare5.writeUint(bc, x.id);
+}
+function readConnectionsRequest5(bc) {
+  return {
+    id: bare5.readUint(bc)
+  };
+}
+function writeConnectionsRequest5(bc, x) {
+  bare5.writeUint(bc, x.id);
+}
+function readRpcsListRequest5(bc) {
+  return {
+    id: bare5.readUint(bc)
+  };
+}
+function writeRpcsListRequest5(bc, x) {
+  bare5.writeUint(bc, x.id);
+}
+function readTraceQueryRequest4(bc) {
+  return {
+    id: bare5.readUint(bc),
+    startMs: bare5.readUint(bc),
+    endMs: bare5.readUint(bc),
+    limit: bare5.readUint(bc)
+  };
+}
+function writeTraceQueryRequest4(bc, x) {
+  bare5.writeUint(bc, x.id);
+  bare5.writeUint(bc, x.startMs);
+  bare5.writeUint(bc, x.endMs);
+  bare5.writeUint(bc, x.limit);
+}
+function readQueueRequest4(bc) {
+  return {
+    id: bare5.readUint(bc),
+    limit: bare5.readUint(bc)
+  };
+}
+function writeQueueRequest4(bc, x) {
+  bare5.writeUint(bc, x.id);
+  bare5.writeUint(bc, x.limit);
+}
+function readWorkflowHistoryRequest4(bc) {
+  return {
+    id: bare5.readUint(bc)
+  };
+}
+function writeWorkflowHistoryRequest4(bc, x) {
+  bare5.writeUint(bc, x.id);
+}
+function read05(bc) {
+  return bare5.readBool(bc) ? bare5.readString(bc) : null;
+}
+function write05(bc, x) {
+  bare5.writeBool(bc, x != null);
+  if (x != null) {
+    bare5.writeString(bc, x);
+  }
+}
+function readWorkflowReplayRequest2(bc) {
+  return {
+    id: bare5.readUint(bc),
+    entryId: read05(bc)
+  };
+}
+function writeWorkflowReplayRequest2(bc, x) {
+  bare5.writeUint(bc, x.id);
+  write05(bc, x.entryId);
+}
+function readDatabaseSchemaRequest3(bc) {
+  return {
+    id: bare5.readUint(bc)
+  };
+}
+function writeDatabaseSchemaRequest3(bc, x) {
+  bare5.writeUint(bc, x.id);
+}
+function readDatabaseTableRowsRequest3(bc) {
+  return {
+    id: bare5.readUint(bc),
+    table: bare5.readString(bc),
+    limit: bare5.readUint(bc),
+    offset: bare5.readUint(bc)
+  };
+}
+function writeDatabaseTableRowsRequest3(bc, x) {
+  bare5.writeUint(bc, x.id);
+  bare5.writeString(bc, x.table);
+  bare5.writeUint(bc, x.limit);
+  bare5.writeUint(bc, x.offset);
+}
+function readToServerBody5(bc) {
+  const offset = bc.offset;
+  const tag = bare5.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "PatchStateRequest", val: readPatchStateRequest5(bc) };
+    case 1:
+      return { tag: "StateRequest", val: readStateRequest5(bc) };
+    case 2:
+      return { tag: "ConnectionsRequest", val: readConnectionsRequest5(bc) };
+    case 3:
+      return { tag: "ActionRequest", val: readActionRequest5(bc) };
+    case 4:
+      return { tag: "RpcsListRequest", val: readRpcsListRequest5(bc) };
+    case 5:
+      return { tag: "TraceQueryRequest", val: readTraceQueryRequest4(bc) };
+    case 6:
+      return { tag: "QueueRequest", val: readQueueRequest4(bc) };
+    case 7:
+      return { tag: "WorkflowHistoryRequest", val: readWorkflowHistoryRequest4(bc) };
+    case 8:
+      return { tag: "WorkflowReplayRequest", val: readWorkflowReplayRequest2(bc) };
+    case 9:
+      return { tag: "DatabaseSchemaRequest", val: readDatabaseSchemaRequest3(bc) };
+    case 10:
+      return { tag: "DatabaseTableRowsRequest", val: readDatabaseTableRowsRequest3(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare5.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody5(bc, x) {
+  switch (x.tag) {
+    case "PatchStateRequest": {
+      bare5.writeU8(bc, 0);
+      writePatchStateRequest5(bc, x.val);
+      break;
+    }
+    case "StateRequest": {
+      bare5.writeU8(bc, 1);
+      writeStateRequest5(bc, x.val);
+      break;
+    }
+    case "ConnectionsRequest": {
+      bare5.writeU8(bc, 2);
+      writeConnectionsRequest5(bc, x.val);
+      break;
+    }
+    case "ActionRequest": {
+      bare5.writeU8(bc, 3);
+      writeActionRequest5(bc, x.val);
+      break;
+    }
+    case "RpcsListRequest": {
+      bare5.writeU8(bc, 4);
+      writeRpcsListRequest5(bc, x.val);
+      break;
+    }
+    case "TraceQueryRequest": {
+      bare5.writeU8(bc, 5);
+      writeTraceQueryRequest4(bc, x.val);
+      break;
+    }
+    case "QueueRequest": {
+      bare5.writeU8(bc, 6);
+      writeQueueRequest4(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryRequest": {
+      bare5.writeU8(bc, 7);
+      writeWorkflowHistoryRequest4(bc, x.val);
+      break;
+    }
+    case "WorkflowReplayRequest": {
+      bare5.writeU8(bc, 8);
+      writeWorkflowReplayRequest2(bc, x.val);
+      break;
+    }
+    case "DatabaseSchemaRequest": {
+      bare5.writeU8(bc, 9);
+      writeDatabaseSchemaRequest3(bc, x.val);
+      break;
+    }
+    case "DatabaseTableRowsRequest": {
+      bare5.writeU8(bc, 10);
+      writeDatabaseTableRowsRequest3(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer5(bc) {
+  return {
+    body: readToServerBody5(bc)
+  };
+}
+function writeToServer5(bc, x) {
+  writeToServerBody5(bc, x.body);
+}
+function encodeToServer5(x, config2) {
+  const fullConfig = config2 != null ? bare5.Config(config2) : DEFAULT_CONFIG5;
+  const bc = new bare5.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServer5(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer5(bytes) {
+  const bc = new bare5.ByteCursor(bytes, DEFAULT_CONFIG5);
+  const result = readToServer5(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare5.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readConnection5(bc) {
+  return {
+    id: bare5.readString(bc),
+    details: bare5.readData(bc)
+  };
+}
+function writeConnection5(bc, x) {
+  bare5.writeString(bc, x.id);
+  bare5.writeData(bc, x.details);
+}
+function readTabConfigEntry(bc) {
+  return {
+    id: bare5.readString(bc),
+    label: read05(bc),
+    icon: read05(bc),
+    hidden: bare5.readBool(bc)
+  };
+}
+function writeTabConfigEntry(bc, x) {
+  bare5.writeString(bc, x.id);
+  write05(bc, x.label);
+  write05(bc, x.icon);
+  bare5.writeBool(bc, x.hidden);
+}
+function read15(bc) {
+  const len = bare5.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readConnection5(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readConnection5(bc);
+  }
+  return result;
+}
+function write15(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeConnection5(bc, x[i]);
+  }
+}
+function read25(bc) {
+  return bare5.readBool(bc) ? readState5(bc) : null;
+}
+function write25(bc, x) {
+  bare5.writeBool(bc, x != null);
+  if (x != null) {
+    writeState5(bc, x);
+  }
+}
+function read35(bc) {
+  const len = bare5.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare5.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare5.readString(bc);
+  }
+  return result;
+}
+function write35(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare5.writeString(bc, x[i]);
+  }
+}
+function read44(bc) {
+  return bare5.readBool(bc) ? readWorkflowHistory4(bc) : null;
+}
+function write44(bc, x) {
+  bare5.writeBool(bc, x != null);
+  if (x != null) {
+    writeWorkflowHistory4(bc, x);
+  }
+}
+function read52(bc) {
+  const len = bare5.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readTabConfigEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readTabConfigEntry(bc);
+  }
+  return result;
+}
+function write52(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeTabConfigEntry(bc, x[i]);
+  }
+}
+function readInit5(bc) {
+  return {
+    connections: read15(bc),
+    state: read25(bc),
+    isStateEnabled: bare5.readBool(bc),
+    rpcs: read35(bc),
+    isDatabaseEnabled: bare5.readBool(bc),
+    queueSize: bare5.readUint(bc),
+    workflowHistory: read44(bc),
+    isWorkflowEnabled: bare5.readBool(bc),
+    tabConfig: read52(bc)
+  };
+}
+function writeInit5(bc, x) {
+  write15(bc, x.connections);
+  write25(bc, x.state);
+  bare5.writeBool(bc, x.isStateEnabled);
+  write35(bc, x.rpcs);
+  bare5.writeBool(bc, x.isDatabaseEnabled);
+  bare5.writeUint(bc, x.queueSize);
+  write44(bc, x.workflowHistory);
+  bare5.writeBool(bc, x.isWorkflowEnabled);
+  write52(bc, x.tabConfig);
+}
+function readConnectionsResponse5(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    connections: read15(bc)
+  };
+}
+function writeConnectionsResponse5(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  write15(bc, x.connections);
+}
+function readStateResponse5(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    state: read25(bc),
+    isStateEnabled: bare5.readBool(bc)
+  };
+}
+function writeStateResponse5(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  write25(bc, x.state);
+  bare5.writeBool(bc, x.isStateEnabled);
+}
+function readActionResponse5(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    output: bare5.readData(bc)
+  };
+}
+function writeActionResponse5(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  bare5.writeData(bc, x.output);
+}
+function readTraceQueryResponse4(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    payload: bare5.readData(bc)
+  };
+}
+function writeTraceQueryResponse4(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  bare5.writeData(bc, x.payload);
+}
+function readQueueMessageSummary4(bc) {
+  return {
+    id: bare5.readUint(bc),
+    name: bare5.readString(bc),
+    createdAtMs: bare5.readUint(bc)
+  };
+}
+function writeQueueMessageSummary4(bc, x) {
+  bare5.writeUint(bc, x.id);
+  bare5.writeString(bc, x.name);
+  bare5.writeUint(bc, x.createdAtMs);
+}
+function read6(bc) {
+  const len = bare5.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readQueueMessageSummary4(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readQueueMessageSummary4(bc);
+  }
+  return result;
+}
+function write6(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeQueueMessageSummary4(bc, x[i]);
+  }
+}
+function readQueueStatus4(bc) {
+  return {
+    size: bare5.readUint(bc),
+    maxSize: bare5.readUint(bc),
+    messages: read6(bc),
+    truncated: bare5.readBool(bc)
+  };
+}
+function writeQueueStatus4(bc, x) {
+  bare5.writeUint(bc, x.size);
+  bare5.writeUint(bc, x.maxSize);
+  write6(bc, x.messages);
+  bare5.writeBool(bc, x.truncated);
+}
+function readQueueResponse4(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    status: readQueueStatus4(bc)
+  };
+}
+function writeQueueResponse4(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  writeQueueStatus4(bc, x.status);
+}
+function readWorkflowHistoryResponse4(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    history: read44(bc),
+    isWorkflowEnabled: bare5.readBool(bc)
+  };
+}
+function writeWorkflowHistoryResponse4(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  write44(bc, x.history);
+  bare5.writeBool(bc, x.isWorkflowEnabled);
+}
+function readWorkflowReplayResponse2(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    history: read44(bc),
+    isWorkflowEnabled: bare5.readBool(bc)
+  };
+}
+function writeWorkflowReplayResponse2(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  write44(bc, x.history);
+  bare5.writeBool(bc, x.isWorkflowEnabled);
+}
+function readDatabaseSchemaResponse3(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    schema: bare5.readData(bc)
+  };
+}
+function writeDatabaseSchemaResponse3(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  bare5.writeData(bc, x.schema);
+}
+function readDatabaseTableRowsResponse3(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    result: bare5.readData(bc)
+  };
+}
+function writeDatabaseTableRowsResponse3(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  bare5.writeData(bc, x.result);
+}
+function readStateUpdated5(bc) {
+  return {
+    state: readState5(bc)
+  };
+}
+function writeStateUpdated5(bc, x) {
+  writeState5(bc, x.state);
+}
+function readQueueUpdated4(bc) {
+  return {
+    queueSize: bare5.readUint(bc)
+  };
+}
+function writeQueueUpdated4(bc, x) {
+  bare5.writeUint(bc, x.queueSize);
+}
+function readWorkflowHistoryUpdated4(bc) {
+  return {
+    history: readWorkflowHistory4(bc)
+  };
+}
+function writeWorkflowHistoryUpdated4(bc, x) {
+  writeWorkflowHistory4(bc, x.history);
+}
+function readRpcsListResponse5(bc) {
+  return {
+    rid: bare5.readUint(bc),
+    rpcs: read35(bc)
+  };
+}
+function writeRpcsListResponse5(bc, x) {
+  bare5.writeUint(bc, x.rid);
+  write35(bc, x.rpcs);
+}
+function readConnectionsUpdated5(bc) {
+  return {
+    connections: read15(bc)
+  };
+}
+function writeConnectionsUpdated5(bc, x) {
+  write15(bc, x.connections);
+}
+function readError5(bc) {
+  return {
+    message: bare5.readString(bc)
+  };
+}
+function writeError5(bc, x) {
+  bare5.writeString(bc, x.message);
+}
+function readToClientBody5(bc) {
+  const offset = bc.offset;
+  const tag = bare5.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "StateResponse", val: readStateResponse5(bc) };
+    case 1:
+      return { tag: "ConnectionsResponse", val: readConnectionsResponse5(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse5(bc) };
+    case 3:
+      return { tag: "ConnectionsUpdated", val: readConnectionsUpdated5(bc) };
+    case 4:
+      return { tag: "QueueUpdated", val: readQueueUpdated4(bc) };
+    case 5:
+      return { tag: "StateUpdated", val: readStateUpdated5(bc) };
+    case 6:
+      return { tag: "WorkflowHistoryUpdated", val: readWorkflowHistoryUpdated4(bc) };
+    case 7:
+      return { tag: "RpcsListResponse", val: readRpcsListResponse5(bc) };
+    case 8:
+      return { tag: "TraceQueryResponse", val: readTraceQueryResponse4(bc) };
+    case 9:
+      return { tag: "QueueResponse", val: readQueueResponse4(bc) };
+    case 10:
+      return { tag: "WorkflowHistoryResponse", val: readWorkflowHistoryResponse4(bc) };
+    case 11:
+      return { tag: "WorkflowReplayResponse", val: readWorkflowReplayResponse2(bc) };
+    case 12:
+      return { tag: "Error", val: readError5(bc) };
+    case 13:
+      return { tag: "Init", val: readInit5(bc) };
+    case 14:
+      return { tag: "DatabaseSchemaResponse", val: readDatabaseSchemaResponse3(bc) };
+    case 15:
+      return { tag: "DatabaseTableRowsResponse", val: readDatabaseTableRowsResponse3(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare5.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody5(bc, x) {
+  switch (x.tag) {
+    case "StateResponse": {
+      bare5.writeU8(bc, 0);
+      writeStateResponse5(bc, x.val);
+      break;
+    }
+    case "ConnectionsResponse": {
+      bare5.writeU8(bc, 1);
+      writeConnectionsResponse5(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare5.writeU8(bc, 2);
+      writeActionResponse5(bc, x.val);
+      break;
+    }
+    case "ConnectionsUpdated": {
+      bare5.writeU8(bc, 3);
+      writeConnectionsUpdated5(bc, x.val);
+      break;
+    }
+    case "QueueUpdated": {
+      bare5.writeU8(bc, 4);
+      writeQueueUpdated4(bc, x.val);
+      break;
+    }
+    case "StateUpdated": {
+      bare5.writeU8(bc, 5);
+      writeStateUpdated5(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryUpdated": {
+      bare5.writeU8(bc, 6);
+      writeWorkflowHistoryUpdated4(bc, x.val);
+      break;
+    }
+    case "RpcsListResponse": {
+      bare5.writeU8(bc, 7);
+      writeRpcsListResponse5(bc, x.val);
+      break;
+    }
+    case "TraceQueryResponse": {
+      bare5.writeU8(bc, 8);
+      writeTraceQueryResponse4(bc, x.val);
+      break;
+    }
+    case "QueueResponse": {
+      bare5.writeU8(bc, 9);
+      writeQueueResponse4(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryResponse": {
+      bare5.writeU8(bc, 10);
+      writeWorkflowHistoryResponse4(bc, x.val);
+      break;
+    }
+    case "WorkflowReplayResponse": {
+      bare5.writeU8(bc, 11);
+      writeWorkflowReplayResponse2(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare5.writeU8(bc, 12);
+      writeError5(bc, x.val);
+      break;
+    }
+    case "Init": {
+      bare5.writeU8(bc, 13);
+      writeInit5(bc, x.val);
+      break;
+    }
+    case "DatabaseSchemaResponse": {
+      bare5.writeU8(bc, 14);
+      writeDatabaseSchemaResponse3(bc, x.val);
+      break;
+    }
+    case "DatabaseTableRowsResponse": {
+      bare5.writeU8(bc, 15);
+      writeDatabaseTableRowsResponse3(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient5(bc) {
+  return {
+    body: readToClientBody5(bc)
+  };
+}
+function writeToClient5(bc, x) {
+  writeToClientBody5(bc, x.body);
+}
+function encodeToClient5(x, config2) {
+  const fullConfig = config2 != null ? bare5.Config(config2) : DEFAULT_CONFIG5;
+  const bc = new bare5.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToClient5(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient5(bytes) {
+  const bc = new bare5.ByteCursor(bytes, DEFAULT_CONFIG5);
+  const result = readToClient5(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare5.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/common/bare/transport/v1.ts
+import * as bare6 from "@rivetkit/bare-ts";
+var config = /* @__PURE__ */ bare6.Config({});
+function readWorkflowCbor(bc) {
+  return bare6.readData(bc);
+}
+function writeWorkflowCbor(bc, x) {
+  bare6.writeData(bc, x);
+}
 function readWorkflowNameIndex(bc) {
-  return bare5.readU32(bc);
+  return bare6.readU32(bc);
 }
 function writeWorkflowNameIndex(bc, x) {
-  bare5.writeU32(bc, x);
+  bare6.writeU32(bc, x);
 }
 function readWorkflowLoopIterationMarker(bc) {
   return {
     loop: readWorkflowNameIndex(bc),
-    iteration: bare5.readU32(bc)
+    iteration: bare6.readU32(bc)
   };
 }
 function writeWorkflowLoopIterationMarker(bc, x) {
   writeWorkflowNameIndex(bc, x.loop);
-  bare5.writeU32(bc, x.iteration);
+  bare6.writeU32(bc, x.iteration);
 }
 function readWorkflowPathSegment(bc) {
   const offset = bc.offset;
-  const tag = bare5.readU8(bc);
+  const tag = bare6.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "WorkflowNameIndex", val: readWorkflowNameIndex(bc) };
@@ -2448,26 +3154,26 @@ function readWorkflowPathSegment(bc) {
       };
     default: {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "invalid tag");
+      throw new bare6.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowPathSegment(bc, x) {
   switch (x.tag) {
     case "WorkflowNameIndex": {
-      bare5.writeU8(bc, 0);
+      bare6.writeU8(bc, 0);
       writeWorkflowNameIndex(bc, x.val);
       break;
     }
     case "WorkflowLoopIterationMarker": {
-      bare5.writeU8(bc, 1);
+      bare6.writeU8(bc, 1);
       writeWorkflowLoopIterationMarker(bc, x.val);
       break;
     }
   }
 }
 function readWorkflowLocation(bc) {
-  const len = bare5.readUintSafe(bc);
+  const len = bare6.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -2478,14 +3184,14 @@ function readWorkflowLocation(bc) {
   return result;
 }
 function writeWorkflowLocation(bc, x) {
-  bare5.writeUintSafe(bc, x.length);
+  bare6.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeWorkflowPathSegment(bc, x[i]);
   }
 }
 function readWorkflowEntryStatus(bc) {
   const offset = bc.offset;
-  const tag = bare5.readU8(bc);
+  const tag = bare6.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -2499,37 +3205,37 @@ function readWorkflowEntryStatus(bc) {
       return "EXHAUSTED" /* EXHAUSTED */;
     default: {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "invalid tag");
+      throw new bare6.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowEntryStatus(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare5.writeU8(bc, 0);
+      bare6.writeU8(bc, 0);
       break;
     }
     case "RUNNING" /* RUNNING */: {
-      bare5.writeU8(bc, 1);
+      bare6.writeU8(bc, 1);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare5.writeU8(bc, 2);
+      bare6.writeU8(bc, 2);
       break;
     }
     case "FAILED" /* FAILED */: {
-      bare5.writeU8(bc, 3);
+      bare6.writeU8(bc, 3);
       break;
     }
     case "EXHAUSTED" /* EXHAUSTED */: {
-      bare5.writeU8(bc, 4);
+      bare6.writeU8(bc, 4);
       break;
     }
   }
 }
 function readWorkflowSleepState(bc) {
   const offset = bc.offset;
-  const tag = bare5.readU8(bc);
+  const tag = bare6.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -2539,29 +3245,29 @@ function readWorkflowSleepState(bc) {
       return "INTERRUPTED" /* INTERRUPTED */;
     default: {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "invalid tag");
+      throw new bare6.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowSleepState(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare5.writeU8(bc, 0);
+      bare6.writeU8(bc, 0);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare5.writeU8(bc, 1);
+      bare6.writeU8(bc, 1);
       break;
     }
     case "INTERRUPTED" /* INTERRUPTED */: {
-      bare5.writeU8(bc, 2);
+      bare6.writeU8(bc, 2);
       break;
     }
   }
 }
 function readWorkflowBranchStatusType(bc) {
   const offset = bc.offset;
-  const tag = bare5.readU8(bc);
+  const tag = bare6.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -2575,166 +3281,176 @@ function readWorkflowBranchStatusType(bc) {
       return "CANCELLED" /* CANCELLED */;
     default: {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "invalid tag");
+      throw new bare6.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowBranchStatusType(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare5.writeU8(bc, 0);
+      bare6.writeU8(bc, 0);
       break;
     }
     case "RUNNING" /* RUNNING */: {
-      bare5.writeU8(bc, 1);
+      bare6.writeU8(bc, 1);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare5.writeU8(bc, 2);
+      bare6.writeU8(bc, 2);
       break;
     }
     case "FAILED" /* FAILED */: {
-      bare5.writeU8(bc, 3);
+      bare6.writeU8(bc, 3);
       break;
     }
     case "CANCELLED" /* CANCELLED */: {
-      bare5.writeU8(bc, 4);
+      bare6.writeU8(bc, 4);
       break;
     }
   }
 }
-function read05(bc) {
-  return bare5.readBool(bc) ? readWorkflowCbor(bc) : null;
+function read06(bc) {
+  return bare6.readBool(bc) ? readWorkflowCbor(bc) : null;
 }
-function write05(bc, x) {
-  bare5.writeBool(bc, x !== null);
+function write06(bc, x) {
+  bare6.writeBool(bc, x !== null);
   if (x !== null) {
     writeWorkflowCbor(bc, x);
   }
 }
-function read15(bc) {
-  return bare5.readBool(bc) ? bare5.readString(bc) : null;
+function read16(bc) {
+  return bare6.readBool(bc) ? bare6.readString(bc) : null;
 }
-function write15(bc, x) {
-  bare5.writeBool(bc, x !== null);
+function write16(bc, x) {
+  bare6.writeBool(bc, x !== null);
   if (x !== null) {
-    bare5.writeString(bc, x);
+    bare6.writeString(bc, x);
   }
 }
 function readWorkflowStepEntry(bc) {
   return {
-    output: read05(bc),
-    error: read15(bc)
+    output: read06(bc),
+    error: read16(bc)
   };
 }
 function writeWorkflowStepEntry(bc, x) {
-  write05(bc, x.output);
-  write15(bc, x.error);
+  write06(bc, x.output);
+  write16(bc, x.error);
 }
 function readWorkflowLoopEntry(bc) {
   return {
     state: readWorkflowCbor(bc),
-    iteration: bare5.readU32(bc),
-    output: read05(bc)
+    iteration: bare6.readU32(bc),
+    output: read06(bc)
   };
 }
 function writeWorkflowLoopEntry(bc, x) {
   writeWorkflowCbor(bc, x.state);
-  bare5.writeU32(bc, x.iteration);
-  write05(bc, x.output);
+  bare6.writeU32(bc, x.iteration);
+  write06(bc, x.output);
 }
 function readWorkflowSleepEntry(bc) {
   return {
-    deadline: bare5.readU64(bc),
+    deadline: bare6.readU64(bc),
     state: readWorkflowSleepState(bc)
   };
 }
 function writeWorkflowSleepEntry(bc, x) {
-  bare5.writeU64(bc, x.deadline);
+  bare6.writeU64(bc, x.deadline);
   writeWorkflowSleepState(bc, x.state);
 }
 function readWorkflowMessageEntry(bc) {
   return {
-    name: bare5.readString(bc),
+    name: bare6.readString(bc),
     messageData: readWorkflowCbor(bc)
   };
 }
 function writeWorkflowMessageEntry(bc, x) {
-  bare5.writeString(bc, x.name);
+  bare6.writeString(bc, x.name);
   writeWorkflowCbor(bc, x.messageData);
 }
 function readWorkflowRollbackCheckpointEntry(bc) {
   return {
-    name: bare5.readString(bc)
+    name: bare6.readString(bc)
   };
 }
 function writeWorkflowRollbackCheckpointEntry(bc, x) {
-  bare5.writeString(bc, x.name);
+  bare6.writeString(bc, x.name);
 }
 function readWorkflowBranchStatus(bc) {
   return {
     status: readWorkflowBranchStatusType(bc),
-    output: read05(bc),
-    error: read15(bc)
+    output: read06(bc),
+    error: read16(bc)
   };
 }
 function writeWorkflowBranchStatus(bc, x) {
   writeWorkflowBranchStatusType(bc, x.status);
-  write05(bc, x.output);
-  write15(bc, x.error);
+  write06(bc, x.output);
+  write16(bc, x.error);
 }
-function read25(bc) {
-  const len = bare5.readUintSafe(bc);
+function read26(bc) {
+  const len = bare6.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
     const offset = bc.offset;
-    const key = bare5.readString(bc);
+    const key = bare6.readString(bc);
     if (result.has(key)) {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "duplicated key");
+      throw new bare6.BareError(offset, "duplicated key");
     }
     result.set(key, readWorkflowBranchStatus(bc));
   }
   return result;
 }
-function write25(bc, x) {
-  bare5.writeUintSafe(bc, x.size);
+function write26(bc, x) {
+  bare6.writeUintSafe(bc, x.size);
   for (const kv of x) {
-    bare5.writeString(bc, kv[0]);
+    bare6.writeString(bc, kv[0]);
     writeWorkflowBranchStatus(bc, kv[1]);
   }
 }
 function readWorkflowJoinEntry(bc) {
   return {
-    branches: read25(bc)
+    branches: read26(bc)
   };
 }
 function writeWorkflowJoinEntry(bc, x) {
-  write25(bc, x.branches);
+  write26(bc, x.branches);
 }
 function readWorkflowRaceEntry(bc) {
   return {
-    winner: read15(bc),
-    branches: read25(bc)
+    winner: read16(bc),
+    branches: read26(bc)
   };
 }
 function writeWorkflowRaceEntry(bc, x) {
-  write15(bc, x.winner);
-  write25(bc, x.branches);
+  write16(bc, x.winner);
+  write26(bc, x.branches);
 }
 function readWorkflowRemovedEntry(bc) {
   return {
-    originalType: bare5.readString(bc),
-    originalName: read15(bc)
+    originalType: bare6.readString(bc),
+    originalName: read16(bc)
   };
 }
 function writeWorkflowRemovedEntry(bc, x) {
-  bare5.writeString(bc, x.originalType);
-  write15(bc, x.originalName);
+  bare6.writeString(bc, x.originalType);
+  write16(bc, x.originalName);
+}
+function readWorkflowVersionCheckEntry(bc) {
+  return {
+    resolved: bare6.readU32(bc),
+    latest: bare6.readU32(bc)
+  };
+}
+function writeWorkflowVersionCheckEntry(bc, x) {
+  bare6.writeU32(bc, x.resolved);
+  bare6.writeU32(bc, x.latest);
 }
 function readWorkflowEntryKind(bc) {
   const offset = bc.offset;
-  const tag = bare5.readU8(bc);
+  const tag = bare6.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "WorkflowStepEntry", val: readWorkflowStepEntry(bc) };
@@ -2764,118 +3480,128 @@ function readWorkflowEntryKind(bc) {
         tag: "WorkflowRemovedEntry",
         val: readWorkflowRemovedEntry(bc)
       };
+    case 8:
+      return {
+        tag: "WorkflowVersionCheckEntry",
+        val: readWorkflowVersionCheckEntry(bc)
+      };
     default: {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "invalid tag");
+      throw new bare6.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowEntryKind(bc, x) {
   switch (x.tag) {
     case "WorkflowStepEntry": {
-      bare5.writeU8(bc, 0);
+      bare6.writeU8(bc, 0);
       writeWorkflowStepEntry(bc, x.val);
       break;
     }
     case "WorkflowLoopEntry": {
-      bare5.writeU8(bc, 1);
+      bare6.writeU8(bc, 1);
       writeWorkflowLoopEntry(bc, x.val);
       break;
     }
     case "WorkflowSleepEntry": {
-      bare5.writeU8(bc, 2);
+      bare6.writeU8(bc, 2);
       writeWorkflowSleepEntry(bc, x.val);
       break;
     }
     case "WorkflowMessageEntry": {
-      bare5.writeU8(bc, 3);
+      bare6.writeU8(bc, 3);
       writeWorkflowMessageEntry(bc, x.val);
       break;
     }
     case "WorkflowRollbackCheckpointEntry": {
-      bare5.writeU8(bc, 4);
+      bare6.writeU8(bc, 4);
       writeWorkflowRollbackCheckpointEntry(bc, x.val);
       break;
     }
     case "WorkflowJoinEntry": {
-      bare5.writeU8(bc, 5);
+      bare6.writeU8(bc, 5);
       writeWorkflowJoinEntry(bc, x.val);
       break;
     }
     case "WorkflowRaceEntry": {
-      bare5.writeU8(bc, 6);
+      bare6.writeU8(bc, 6);
       writeWorkflowRaceEntry(bc, x.val);
       break;
     }
     case "WorkflowRemovedEntry": {
-      bare5.writeU8(bc, 7);
+      bare6.writeU8(bc, 7);
       writeWorkflowRemovedEntry(bc, x.val);
       break;
     }
+    case "WorkflowVersionCheckEntry": {
+      bare6.writeU8(bc, 8);
+      writeWorkflowVersionCheckEntry(bc, x.val);
+      break;
+    }
   }
 }
 function readWorkflowEntry(bc) {
   return {
-    id: bare5.readString(bc),
+    id: bare6.readString(bc),
     location: readWorkflowLocation(bc),
     kind: readWorkflowEntryKind(bc)
   };
 }
 function writeWorkflowEntry(bc, x) {
-  bare5.writeString(bc, x.id);
+  bare6.writeString(bc, x.id);
   writeWorkflowLocation(bc, x.location);
   writeWorkflowEntryKind(bc, x.kind);
 }
-function read35(bc) {
-  return bare5.readBool(bc) ? bare5.readU64(bc) : null;
+function read36(bc) {
+  return bare6.readBool(bc) ? bare6.readU64(bc) : null;
 }
-function write35(bc, x) {
-  bare5.writeBool(bc, x !== null);
+function write36(bc, x) {
+  bare6.writeBool(bc, x !== null);
   if (x !== null) {
-    bare5.writeU64(bc, x);
+    bare6.writeU64(bc, x);
   }
 }
 function readWorkflowEntryMetadata(bc) {
   return {
     status: readWorkflowEntryStatus(bc),
-    error: read15(bc),
-    attempts: bare5.readU32(bc),
-    lastAttemptAt: bare5.readU64(bc),
-    createdAt: bare5.readU64(bc),
-    completedAt: read35(bc),
-    rollbackCompletedAt: read35(bc),
-    rollbackError: read15(bc)
+    error: read16(bc),
+    attempts: bare6.readU32(bc),
+    lastAttemptAt: bare6.readU64(bc),
+    createdAt: bare6.readU64(bc),
+    completedAt: read36(bc),
+    rollbackCompletedAt: read36(bc),
+    rollbackError: read16(bc)
   };
 }
 function writeWorkflowEntryMetadata(bc, x) {
   writeWorkflowEntryStatus(bc, x.status);
-  write15(bc, x.error);
-  bare5.writeU32(bc, x.attempts);
-  bare5.writeU64(bc, x.lastAttemptAt);
-  bare5.writeU64(bc, x.createdAt);
-  write35(bc, x.completedAt);
-  write35(bc, x.rollbackCompletedAt);
-  write15(bc, x.rollbackError);
-}
-function read44(bc) {
-  const len = bare5.readUintSafe(bc);
+  write16(bc, x.error);
+  bare6.writeU32(bc, x.attempts);
+  bare6.writeU64(bc, x.lastAttemptAt);
+  bare6.writeU64(bc, x.createdAt);
+  write36(bc, x.completedAt);
+  write36(bc, x.rollbackCompletedAt);
+  write16(bc, x.rollbackError);
+}
+function read45(bc) {
+  const len = bare6.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
-  const result = [bare5.readString(bc)];
+  const result = [bare6.readString(bc)];
   for (let i = 1; i < len; i++) {
-    result[i] = bare5.readString(bc);
+    result[i] = bare6.readString(bc);
   }
   return result;
 }
-function write44(bc, x) {
-  bare5.writeUintSafe(bc, x.length);
+function write45(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
-    bare5.writeString(bc, x[i]);
+    bare6.writeString(bc, x[i]);
   }
 }
-function read52(bc) {
-  const len = bare5.readUintSafe(bc);
+function read53(bc) {
+  const len = bare6.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -2885,58 +3611,58 @@ function read52(bc) {
   }
   return result;
 }
-function write52(bc, x) {
-  bare5.writeUintSafe(bc, x.length);
+function write53(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeWorkflowEntry(bc, x[i]);
   }
 }
-function read6(bc) {
-  const len = bare5.readUintSafe(bc);
+function read62(bc) {
+  const len = bare6.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
     const offset = bc.offset;
-    const key = bare5.readString(bc);
+    const key = bare6.readString(bc);
     if (result.has(key)) {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "duplicated key");
+      throw new bare6.BareError(offset, "duplicated key");
     }
     result.set(key, readWorkflowEntryMetadata(bc));
   }
   return result;
 }
-function write6(bc, x) {
-  bare5.writeUintSafe(bc, x.size);
+function write62(bc, x) {
+  bare6.writeUintSafe(bc, x.size);
   for (const kv of x) {
-    bare5.writeString(bc, kv[0]);
+    bare6.writeString(bc, kv[0]);
     writeWorkflowEntryMetadata(bc, kv[1]);
   }
 }
-function readWorkflowHistory4(bc) {
+function readWorkflowHistory5(bc) {
   return {
-    nameRegistry: read44(bc),
-    entries: read52(bc),
-    entryMetadata: read6(bc)
+    nameRegistry: read45(bc),
+    entries: read53(bc),
+    entryMetadata: read62(bc)
   };
 }
-function writeWorkflowHistory4(bc, x) {
-  write44(bc, x.nameRegistry);
-  write52(bc, x.entries);
-  write6(bc, x.entryMetadata);
+function writeWorkflowHistory5(bc, x) {
+  write45(bc, x.nameRegistry);
+  write53(bc, x.entries);
+  write62(bc, x.entryMetadata);
 }
 function encodeWorkflowHistory(x) {
-  const bc = new bare5.ByteCursor(
+  const bc = new bare6.ByteCursor(
     new Uint8Array(config.initialBufferLength),
     config
   );
-  writeWorkflowHistory4(bc, x);
+  writeWorkflowHistory5(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodeWorkflowHistory(bytes) {
-  const bc = new bare5.ByteCursor(bytes, config);
-  const result = readWorkflowHistory4(bc);
+  const bc = new bare6.ByteCursor(bytes, config);
+  const result = readWorkflowHistory5(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare5.BareError(bc.offset, "remaining bytes");
+    throw new bare6.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
@@ -2944,7 +3670,7 @@ function decodeWorkflowHistory(bytes) {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "2.3.2",
+  version: "2.3.3-rc.2",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -3225,7 +3951,7 @@ function decodeWorkflowHistoryTransport(data) {
 }
 
 // src/inspector/client.browser.ts
-var CURRENT_VERSION = 4;
+var CURRENT_VERSION = 5;
 var EVENTS_DROPPED_ERROR = "inspector.events_dropped";
 var WORKFLOW_HISTORY_DROPPED_ERROR = "inspector.workflow_history_dropped";
 var QUEUE_DROPPED_ERROR = "inspector.queue_dropped";
@@ -3339,6 +4065,32 @@ var v4ToClientToV3 = (v4Data) => {
   }
   return v4Data;
 };
+var v4ToClientToV5 = (v4Data) => {
+  if (v4Data.body.tag === "Init") {
+    const init = v4Data.body.val;
+    return {
+      body: {
+        tag: "Init",
+        val: { ...init, tabConfig: [] }
+      }
+    };
+  }
+  return v4Data;
+};
+var v5ToClientToV4 = (v5Data) => {
+  if (v5Data.body.tag === "Init") {
+    const { tabConfig: _tabConfig, ...rest } = v5Data.body.val;
+    return {
+      body: {
+        tag: "Init",
+        val: rest
+      }
+    };
+  }
+  return v5Data;
+};
+var v4ToServerToV5 = (v4Data) => v4Data;
+var v5ToServerToV4 = (v5Data) => v5Data;
 var v1ToServerToV2 = (v1Data) => {
   if (v1Data.body.tag === "EventsRequest" || v1Data.body.tag === "ClearEventsRequest") {
     throw new Error("Cannot convert events requests to v2");
@@ -3378,6 +4130,8 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
         return encodeToServer3(data);
       case 4:
         return encodeToServer4(data);
+      case 5:
+        return encodeToServer5(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -3392,6 +4146,8 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
         return decodeToServer3(bytes);
       case 4:
         return decodeToServer4(bytes);
+      case 5:
+        return decodeToServer5(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -3399,9 +4155,15 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
   deserializeConverters: () => [
     v1ToServerToV2,
     v2ToServerToV3,
-    v3ToServerToV4
+    v3ToServerToV4,
+    v4ToServerToV5
   ],
-  serializeConverters: () => [v4ToServerToV3, v3ToServerToV2, v2ToServerToV1]
+  serializeConverters: () => [
+    v5ToServerToV4,
+    v4ToServerToV3,
+    v3ToServerToV2,
+    v2ToServerToV1
+  ]
 });
 var TO_CLIENT_VERSIONED = createVersionedDataHandler({
   serializeVersion: (data, version) => {
@@ -3414,6 +4176,8 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
         return encodeToClient3(data);
       case 4:
         return encodeToClient4(data);
+      case 5:
+        return encodeToClient5(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -3428,6 +4192,8 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
         return decodeToClient3(bytes);
       case 4:
         return decodeToClient4(bytes);
+      case 5:
+        return decodeToClient5(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -3435,91 +4201,99 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
   deserializeConverters: () => [
     v1ToClientToV2,
     v2ToClientToV3,
-    v3ToClientToV4
+    v3ToClientToV4,
+    v4ToClientToV5
   ],
-  serializeConverters: () => [v4ToClientToV3, v3ToClientToV2, v2ToClientToV1]
+  serializeConverters: () => [
+    v5ToClientToV4,
+    v4ToClientToV3,
+    v3ToClientToV2,
+    v2ToClientToV1
+  ]
 });
 export {
   CURRENT_VERSION,
   TO_CLIENT_VERSIONED,
   TO_SERVER_VERSIONED,
-  decodeToClient4 as decodeToClient,
-  decodeToServer4 as decodeToServer,
+  decodeToClient5 as decodeToClient,
+  decodeToServer5 as decodeToServer,
   decodeWorkflowHistoryTransport,
-  encodeToClient4 as encodeToClient,
-  encodeToServer4 as encodeToServer,
+  encodeToClient5 as encodeToClient,
+  encodeToServer5 as encodeToServer,
   encodeWorkflowHistoryTransport,
-  readActionRequest4 as readActionRequest,
-  readActionResponse4 as readActionResponse,
-  readConnection4 as readConnection,
-  readConnectionsRequest4 as readConnectionsRequest,
-  readConnectionsResponse4 as readConnectionsResponse,
-  readConnectionsUpdated4 as readConnectionsUpdated,
-  readDatabaseSchemaRequest2 as readDatabaseSchemaRequest,
-  readDatabaseSchemaResponse2 as readDatabaseSchemaResponse,
-  readDatabaseTableRowsRequest2 as readDatabaseTableRowsRequest,
-  readDatabaseTableRowsResponse2 as readDatabaseTableRowsResponse,
-  readError4 as readError,
-  readInit4 as readInit,
-  readPatchStateRequest4 as readPatchStateRequest,
-  readQueueMessageSummary3 as readQueueMessageSummary,
-  readQueueRequest3 as readQueueRequest,
-  readQueueResponse3 as readQueueResponse,
-  readQueueStatus3 as readQueueStatus,
-  readQueueUpdated3 as readQueueUpdated,
-  readRpcsListRequest4 as readRpcsListRequest,
-  readRpcsListResponse4 as readRpcsListResponse,
-  readState4 as readState,
-  readStateRequest4 as readStateRequest,
-  readStateResponse4 as readStateResponse,
-  readStateUpdated4 as readStateUpdated,
-  readToClient4 as readToClient,
-  readToClientBody4 as readToClientBody,
-  readToServer4 as readToServer,
-  readToServerBody4 as readToServerBody,
-  readTraceQueryRequest3 as readTraceQueryRequest,
-  readTraceQueryResponse3 as readTraceQueryResponse,
-  readWorkflowHistory3 as readWorkflowHistory,
-  readWorkflowHistoryRequest3 as readWorkflowHistoryRequest,
-  readWorkflowHistoryResponse3 as readWorkflowHistoryResponse,
-  readWorkflowHistoryUpdated3 as readWorkflowHistoryUpdated,
-  readWorkflowReplayRequest,
-  readWorkflowReplayResponse,
-  writeActionRequest4 as writeActionRequest,
-  writeActionResponse4 as writeActionResponse,
-  writeConnection4 as writeConnection,
-  writeConnectionsRequest4 as writeConnectionsRequest,
-  writeConnectionsResponse4 as writeConnectionsResponse,
-  writeConnectionsUpdated4 as writeConnectionsUpdated,
-  writeDatabaseSchemaRequest2 as writeDatabaseSchemaRequest,
-  writeDatabaseSchemaResponse2 as writeDatabaseSchemaResponse,
-  writeDatabaseTableRowsRequest2 as writeDatabaseTableRowsRequest,
-  writeDatabaseTableRowsResponse2 as writeDatabaseTableRowsResponse,
-  writeError4 as writeError,
-  writeInit4 as writeInit,
-  writePatchStateRequest4 as writePatchStateRequest,
-  writeQueueMessageSummary3 as writeQueueMessageSummary,
-  writeQueueRequest3 as writeQueueRequest,
-  writeQueueResponse3 as writeQueueResponse,
-  writeQueueStatus3 as writeQueueStatus,
-  writeQueueUpdated3 as writeQueueUpdated,
-  writeRpcsListRequest4 as writeRpcsListRequest,
-  writeRpcsListResponse4 as writeRpcsListResponse,
-  writeState4 as writeState,
-  writeStateRequest4 as writeStateRequest,
-  writeStateResponse4 as writeStateResponse,
-  writeStateUpdated4 as writeStateUpdated,
-  writeToClient4 as writeToClient,
-  writeToClientBody4 as writeToClientBody,
-  writeToServer4 as writeToServer,
-  writeToServerBody4 as writeToServerBody,
-  writeTraceQueryRequest3 as writeTraceQueryRequest,
-  writeTraceQueryResponse3 as writeTraceQueryResponse,
-  writeWorkflowHistory3 as writeWorkflowHistory,
-  writeWorkflowHistoryRequest3 as writeWorkflowHistoryRequest,
-  writeWorkflowHistoryResponse3 as writeWorkflowHistoryResponse,
-  writeWorkflowHistoryUpdated3 as writeWorkflowHistoryUpdated,
-  writeWorkflowReplayRequest,
-  writeWorkflowReplayResponse
+  readActionRequest5 as readActionRequest,
+  readActionResponse5 as readActionResponse,
+  readConnection5 as readConnection,
+  readConnectionsRequest5 as readConnectionsRequest,
+  readConnectionsResponse5 as readConnectionsResponse,
+  readConnectionsUpdated5 as readConnectionsUpdated,
+  readDatabaseSchemaRequest3 as readDatabaseSchemaRequest,
+  readDatabaseSchemaResponse3 as readDatabaseSchemaResponse,
+  readDatabaseTableRowsRequest3 as readDatabaseTableRowsRequest,
+  readDatabaseTableRowsResponse3 as readDatabaseTableRowsResponse,
+  readError5 as readError,
+  readInit5 as readInit,
+  readPatchStateRequest5 as readPatchStateRequest,
+  readQueueMessageSummary4 as readQueueMessageSummary,
+  readQueueRequest4 as readQueueRequest,
+  readQueueResponse4 as readQueueResponse,
+  readQueueStatus4 as readQueueStatus,
+  readQueueUpdated4 as readQueueUpdated,
+  readRpcsListRequest5 as readRpcsListRequest,
+  readRpcsListResponse5 as readRpcsListResponse,
+  readState5 as readState,
+  readStateRequest5 as readStateRequest,
+  readStateResponse5 as readStateResponse,
+  readStateUpdated5 as readStateUpdated,
+  readTabConfigEntry,
+  readToClient5 as readToClient,
+  readToClientBody5 as readToClientBody,
+  readToServer5 as readToServer,
+  readToServerBody5 as readToServerBody,
+  readTraceQueryRequest4 as readTraceQueryRequest,
+  readTraceQueryResponse4 as readTraceQueryResponse,
+  readWorkflowHistory4 as readWorkflowHistory,
+  readWorkflowHistoryRequest4 as readWorkflowHistoryRequest,
+  readWorkflowHistoryResponse4 as readWorkflowHistoryResponse,
+  readWorkflowHistoryUpdated4 as readWorkflowHistoryUpdated,
+  readWorkflowReplayRequest2 as readWorkflowReplayRequest,
+  readWorkflowReplayResponse2 as readWorkflowReplayResponse,
+  writeActionRequest5 as writeActionRequest,
+  writeActionResponse5 as writeActionResponse,
+  writeConnection5 as writeConnection,
+  writeConnectionsRequest5 as writeConnectionsRequest,
+  writeConnectionsResponse5 as writeConnectionsResponse,
+  writeConnectionsUpdated5 as writeConnectionsUpdated,
+  writeDatabaseSchemaRequest3 as writeDatabaseSchemaRequest,
+  writeDatabaseSchemaResponse3 as writeDatabaseSchemaResponse,
+  writeDatabaseTableRowsRequest3 as writeDatabaseTableRowsRequest,
+  writeDatabaseTableRowsResponse3 as writeDatabaseTableRowsResponse,
+  writeError5 as writeError,
+  writeInit5 as writeInit,
+  writePatchStateRequest5 as writePatchStateRequest,
+  writeQueueMessageSummary4 as writeQueueMessageSummary,
+  writeQueueRequest4 as writeQueueRequest,
+  writeQueueResponse4 as writeQueueResponse,
+  writeQueueStatus4 as writeQueueStatus,
+  writeQueueUpdated4 as writeQueueUpdated,
+  writeRpcsListRequest5 as writeRpcsListRequest,
+  writeRpcsListResponse5 as writeRpcsListResponse,
+  writeState5 as writeState,
+  writeStateRequest5 as writeStateRequest,
+  writeStateResponse5 as writeStateResponse,
+  writeStateUpdated5 as writeStateUpdated,
+  writeTabConfigEntry,
+  writeToClient5 as writeToClient,
+  writeToClientBody5 as writeToClientBody,
+  writeToServer5 as writeToServer,
+  writeToServerBody5 as writeToServerBody,
+  writeTraceQueryRequest4 as writeTraceQueryRequest,
+  writeTraceQueryResponse4 as writeTraceQueryResponse,
+  writeWorkflowHistory4 as writeWorkflowHistory,
+  writeWorkflowHistoryRequest4 as writeWorkflowHistoryRequest,
+  writeWorkflowHistoryResponse4 as writeWorkflowHistoryResponse,
+  writeWorkflowHistoryUpdated4 as writeWorkflowHistoryUpdated,
+  writeWorkflowReplayRequest2 as writeWorkflowReplayRequest,
+  writeWorkflowReplayResponse2 as writeWorkflowReplayResponse
 };
 //# sourceMappingURL=client.js.map