rivetkit 2.3.4 → 2.3.5-rc.1

package/dist/browser/inspector/client.js

@@ -3116,34 +3116,986 @@ function decodeToClient5(bytes) {
   return result;
 }
 
+// src/common/bare/generated/inspector/v6.ts
+import * as bare6 from "@rivetkit/bare-ts";
+var DEFAULT_CONFIG6 = /* @__PURE__ */ bare6.Config({});
+function readState6(bc) {
+  return bare6.readData(bc);
+}
+function writeState6(bc, x) {
+  bare6.writeData(bc, x);
+}
+function readWorkflowHistory5(bc) {
+  return bare6.readData(bc);
+}
+function writeWorkflowHistory5(bc, x) {
+  bare6.writeData(bc, x);
+}
+function readPatchStateRequest6(bc) {
+  return {
+    state: bare6.readData(bc)
+  };
+}
+function writePatchStateRequest6(bc, x) {
+  bare6.writeData(bc, x.state);
+}
+function readActionRequest6(bc) {
+  return {
+    id: bare6.readUint(bc),
+    name: bare6.readString(bc),
+    args: bare6.readData(bc)
+  };
+}
+function writeActionRequest6(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeString(bc, x.name);
+  bare6.writeData(bc, x.args);
+}
+function readStateRequest6(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeStateRequest6(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function readConnectionsRequest6(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeConnectionsRequest6(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function readRpcsListRequest6(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeRpcsListRequest6(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function readTraceQueryRequest5(bc) {
+  return {
+    id: bare6.readUint(bc),
+    startMs: bare6.readUint(bc),
+    endMs: bare6.readUint(bc),
+    limit: bare6.readUint(bc)
+  };
+}
+function writeTraceQueryRequest5(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeUint(bc, x.startMs);
+  bare6.writeUint(bc, x.endMs);
+  bare6.writeUint(bc, x.limit);
+}
+function readQueueRequest5(bc) {
+  return {
+    id: bare6.readUint(bc),
+    limit: bare6.readUint(bc)
+  };
+}
+function writeQueueRequest5(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeUint(bc, x.limit);
+}
+function readWorkflowHistoryRequest5(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeWorkflowHistoryRequest5(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function read06(bc) {
+  return bare6.readBool(bc) ? bare6.readString(bc) : null;
+}
+function write06(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    bare6.writeString(bc, x);
+  }
+}
+function readWorkflowReplayRequest3(bc) {
+  return {
+    id: bare6.readUint(bc),
+    entryId: read06(bc)
+  };
+}
+function writeWorkflowReplayRequest3(bc, x) {
+  bare6.writeUint(bc, x.id);
+  write06(bc, x.entryId);
+}
+function readDatabaseSchemaRequest4(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeDatabaseSchemaRequest4(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function readDatabaseTableRowsRequest4(bc) {
+  return {
+    id: bare6.readUint(bc),
+    table: bare6.readString(bc),
+    limit: bare6.readUint(bc),
+    offset: bare6.readUint(bc)
+  };
+}
+function writeDatabaseTableRowsRequest4(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeString(bc, x.table);
+  bare6.writeUint(bc, x.limit);
+  bare6.writeUint(bc, x.offset);
+}
+function readSchedulesRequest(bc) {
+  return {
+    id: bare6.readUint(bc)
+  };
+}
+function writeSchedulesRequest(bc, x) {
+  bare6.writeUint(bc, x.id);
+}
+function readScheduleHistoryRequest(bc) {
+  return {
+    id: bare6.readUint(bc),
+    scheduleId: bare6.readString(bc),
+    limit: bare6.readUint(bc)
+  };
+}
+function writeScheduleHistoryRequest(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeString(bc, x.scheduleId);
+  bare6.writeUint(bc, x.limit);
+}
+function readScheduleDeleteRequest(bc) {
+  return {
+    id: bare6.readUint(bc),
+    scheduleId: bare6.readString(bc),
+    kind: bare6.readString(bc)
+  };
+}
+function writeScheduleDeleteRequest(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeString(bc, x.scheduleId);
+  bare6.writeString(bc, x.kind);
+}
+function readToServerBody6(bc) {
+  const offset = bc.offset;
+  const tag = bare6.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "PatchStateRequest", val: readPatchStateRequest6(bc) };
+    case 1:
+      return { tag: "StateRequest", val: readStateRequest6(bc) };
+    case 2:
+      return { tag: "ConnectionsRequest", val: readConnectionsRequest6(bc) };
+    case 3:
+      return { tag: "ActionRequest", val: readActionRequest6(bc) };
+    case 4:
+      return { tag: "RpcsListRequest", val: readRpcsListRequest6(bc) };
+    case 5:
+      return { tag: "TraceQueryRequest", val: readTraceQueryRequest5(bc) };
+    case 6:
+      return { tag: "QueueRequest", val: readQueueRequest5(bc) };
+    case 7:
+      return { tag: "WorkflowHistoryRequest", val: readWorkflowHistoryRequest5(bc) };
+    case 8:
+      return { tag: "WorkflowReplayRequest", val: readWorkflowReplayRequest3(bc) };
+    case 9:
+      return { tag: "DatabaseSchemaRequest", val: readDatabaseSchemaRequest4(bc) };
+    case 10:
+      return { tag: "DatabaseTableRowsRequest", val: readDatabaseTableRowsRequest4(bc) };
+    case 11:
+      return { tag: "SchedulesRequest", val: readSchedulesRequest(bc) };
+    case 12:
+      return { tag: "ScheduleHistoryRequest", val: readScheduleHistoryRequest(bc) };
+    case 13:
+      return { tag: "ScheduleDeleteRequest", val: readScheduleDeleteRequest(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare6.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody6(bc, x) {
+  switch (x.tag) {
+    case "PatchStateRequest": {
+      bare6.writeU8(bc, 0);
+      writePatchStateRequest6(bc, x.val);
+      break;
+    }
+    case "StateRequest": {
+      bare6.writeU8(bc, 1);
+      writeStateRequest6(bc, x.val);
+      break;
+    }
+    case "ConnectionsRequest": {
+      bare6.writeU8(bc, 2);
+      writeConnectionsRequest6(bc, x.val);
+      break;
+    }
+    case "ActionRequest": {
+      bare6.writeU8(bc, 3);
+      writeActionRequest6(bc, x.val);
+      break;
+    }
+    case "RpcsListRequest": {
+      bare6.writeU8(bc, 4);
+      writeRpcsListRequest6(bc, x.val);
+      break;
+    }
+    case "TraceQueryRequest": {
+      bare6.writeU8(bc, 5);
+      writeTraceQueryRequest5(bc, x.val);
+      break;
+    }
+    case "QueueRequest": {
+      bare6.writeU8(bc, 6);
+      writeQueueRequest5(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryRequest": {
+      bare6.writeU8(bc, 7);
+      writeWorkflowHistoryRequest5(bc, x.val);
+      break;
+    }
+    case "WorkflowReplayRequest": {
+      bare6.writeU8(bc, 8);
+      writeWorkflowReplayRequest3(bc, x.val);
+      break;
+    }
+    case "DatabaseSchemaRequest": {
+      bare6.writeU8(bc, 9);
+      writeDatabaseSchemaRequest4(bc, x.val);
+      break;
+    }
+    case "DatabaseTableRowsRequest": {
+      bare6.writeU8(bc, 10);
+      writeDatabaseTableRowsRequest4(bc, x.val);
+      break;
+    }
+    case "SchedulesRequest": {
+      bare6.writeU8(bc, 11);
+      writeSchedulesRequest(bc, x.val);
+      break;
+    }
+    case "ScheduleHistoryRequest": {
+      bare6.writeU8(bc, 12);
+      writeScheduleHistoryRequest(bc, x.val);
+      break;
+    }
+    case "ScheduleDeleteRequest": {
+      bare6.writeU8(bc, 13);
+      writeScheduleDeleteRequest(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer6(bc) {
+  return {
+    body: readToServerBody6(bc)
+  };
+}
+function writeToServer6(bc, x) {
+  writeToServerBody6(bc, x.body);
+}
+function encodeToServer6(x, config2) {
+  const fullConfig = config2 != null ? bare6.Config(config2) : DEFAULT_CONFIG6;
+  const bc = new bare6.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServer6(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer6(bytes) {
+  const bc = new bare6.ByteCursor(bytes, DEFAULT_CONFIG6);
+  const result = readToServer6(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare6.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readConnection6(bc) {
+  return {
+    id: bare6.readString(bc),
+    details: bare6.readData(bc)
+  };
+}
+function writeConnection6(bc, x) {
+  bare6.writeString(bc, x.id);
+  bare6.writeData(bc, x.details);
+}
+function readTabConfigEntry2(bc) {
+  return {
+    id: bare6.readString(bc),
+    label: read06(bc),
+    icon: read06(bc),
+    hidden: bare6.readBool(bc)
+  };
+}
+function writeTabConfigEntry2(bc, x) {
+  bare6.writeString(bc, x.id);
+  write06(bc, x.label);
+  write06(bc, x.icon);
+  bare6.writeBool(bc, x.hidden);
+}
+function read16(bc) {
+  return bare6.readBool(bc) ? bare6.readUint(bc) : null;
+}
+function write16(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    bare6.writeUint(bc, x);
+  }
+}
+function readSchedule(bc) {
+  return {
+    id: bare6.readString(bc),
+    name: read06(bc),
+    kind: bare6.readString(bc),
+    action: bare6.readString(bc),
+    args: bare6.readData(bc),
+    nextRunAt: bare6.readUint(bc),
+    lastRunAt: read16(bc),
+    expression: read06(bc),
+    timezone: read06(bc),
+    intervalMs: read16(bc),
+    maxHistory: read16(bc)
+  };
+}
+function writeSchedule(bc, x) {
+  bare6.writeString(bc, x.id);
+  write06(bc, x.name);
+  bare6.writeString(bc, x.kind);
+  bare6.writeString(bc, x.action);
+  bare6.writeData(bc, x.args);
+  bare6.writeUint(bc, x.nextRunAt);
+  write16(bc, x.lastRunAt);
+  write06(bc, x.expression);
+  write06(bc, x.timezone);
+  write16(bc, x.intervalMs);
+  write16(bc, x.maxHistory);
+}
+function read26(bc) {
+  return bare6.readBool(bc) ? bare6.readData(bc) : null;
+}
+function write26(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    bare6.writeData(bc, x);
+  }
+}
+function readScheduleError(bc) {
+  return {
+    group: bare6.readString(bc),
+    code: bare6.readString(bc),
+    message: bare6.readString(bc),
+    metadata: read26(bc)
+  };
+}
+function writeScheduleError(bc, x) {
+  bare6.writeString(bc, x.group);
+  bare6.writeString(bc, x.code);
+  bare6.writeString(bc, x.message);
+  write26(bc, x.metadata);
+}
+function read36(bc) {
+  return bare6.readBool(bc) ? readScheduleError(bc) : null;
+}
+function write36(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    writeScheduleError(bc, x);
+  }
+}
+function readScheduleFire(bc) {
+  return {
+    action: bare6.readString(bc),
+    scheduledAt: bare6.readUint(bc),
+    firedAt: bare6.readUint(bc),
+    finishedAt: read16(bc),
+    result: bare6.readString(bc),
+    error: read36(bc)
+  };
+}
+function writeScheduleFire(bc, x) {
+  bare6.writeString(bc, x.action);
+  bare6.writeUint(bc, x.scheduledAt);
+  bare6.writeUint(bc, x.firedAt);
+  write16(bc, x.finishedAt);
+  bare6.writeString(bc, x.result);
+  write36(bc, x.error);
+}
+function read45(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readConnection6(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readConnection6(bc);
+  }
+  return result;
+}
+function write45(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeConnection6(bc, x[i]);
+  }
+}
+function read53(bc) {
+  return bare6.readBool(bc) ? readState6(bc) : null;
+}
+function write53(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    writeState6(bc, x);
+  }
+}
+function read62(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare6.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare6.readString(bc);
+  }
+  return result;
+}
+function write62(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare6.writeString(bc, x[i]);
+  }
+}
+function read7(bc) {
+  return bare6.readBool(bc) ? readWorkflowHistory5(bc) : null;
+}
+function write7(bc, x) {
+  bare6.writeBool(bc, x != null);
+  if (x != null) {
+    writeWorkflowHistory5(bc, x);
+  }
+}
+function read8(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readTabConfigEntry2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readTabConfigEntry2(bc);
+  }
+  return result;
+}
+function write8(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeTabConfigEntry2(bc, x[i]);
+  }
+}
+function read9(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSchedule(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSchedule(bc);
+  }
+  return result;
+}
+function write9(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSchedule(bc, x[i]);
+  }
+}
+function readInit6(bc) {
+  return {
+    connections: read45(bc),
+    state: read53(bc),
+    isStateEnabled: bare6.readBool(bc),
+    rpcs: read62(bc),
+    isDatabaseEnabled: bare6.readBool(bc),
+    queueSize: bare6.readUint(bc),
+    workflowHistory: read7(bc),
+    isWorkflowEnabled: bare6.readBool(bc),
+    tabConfig: read8(bc),
+    schedules: read9(bc)
+  };
+}
+function writeInit6(bc, x) {
+  write45(bc, x.connections);
+  write53(bc, x.state);
+  bare6.writeBool(bc, x.isStateEnabled);
+  write62(bc, x.rpcs);
+  bare6.writeBool(bc, x.isDatabaseEnabled);
+  bare6.writeUint(bc, x.queueSize);
+  write7(bc, x.workflowHistory);
+  bare6.writeBool(bc, x.isWorkflowEnabled);
+  write8(bc, x.tabConfig);
+  write9(bc, x.schedules);
+}
+function readConnectionsResponse6(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    connections: read45(bc)
+  };
+}
+function writeConnectionsResponse6(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write45(bc, x.connections);
+}
+function readStateResponse6(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    state: read53(bc),
+    isStateEnabled: bare6.readBool(bc)
+  };
+}
+function writeStateResponse6(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write53(bc, x.state);
+  bare6.writeBool(bc, x.isStateEnabled);
+}
+function readActionResponse6(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    output: bare6.readData(bc)
+  };
+}
+function writeActionResponse6(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeData(bc, x.output);
+}
+function readTraceQueryResponse5(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    payload: bare6.readData(bc)
+  };
+}
+function writeTraceQueryResponse5(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeData(bc, x.payload);
+}
+function readQueueMessageSummary5(bc) {
+  return {
+    id: bare6.readUint(bc),
+    name: bare6.readString(bc),
+    createdAtMs: bare6.readUint(bc)
+  };
+}
+function writeQueueMessageSummary5(bc, x) {
+  bare6.writeUint(bc, x.id);
+  bare6.writeString(bc, x.name);
+  bare6.writeUint(bc, x.createdAtMs);
+}
+function read10(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readQueueMessageSummary5(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readQueueMessageSummary5(bc);
+  }
+  return result;
+}
+function write10(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeQueueMessageSummary5(bc, x[i]);
+  }
+}
+function readQueueStatus5(bc) {
+  return {
+    size: bare6.readUint(bc),
+    maxSize: bare6.readUint(bc),
+    messages: read10(bc),
+    truncated: bare6.readBool(bc)
+  };
+}
+function writeQueueStatus5(bc, x) {
+  bare6.writeUint(bc, x.size);
+  bare6.writeUint(bc, x.maxSize);
+  write10(bc, x.messages);
+  bare6.writeBool(bc, x.truncated);
+}
+function readQueueResponse5(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    status: readQueueStatus5(bc)
+  };
+}
+function writeQueueResponse5(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  writeQueueStatus5(bc, x.status);
+}
+function readWorkflowHistoryResponse5(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    history: read7(bc),
+    isWorkflowEnabled: bare6.readBool(bc)
+  };
+}
+function writeWorkflowHistoryResponse5(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write7(bc, x.history);
+  bare6.writeBool(bc, x.isWorkflowEnabled);
+}
+function readWorkflowReplayResponse3(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    history: read7(bc),
+    isWorkflowEnabled: bare6.readBool(bc)
+  };
+}
+function writeWorkflowReplayResponse3(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write7(bc, x.history);
+  bare6.writeBool(bc, x.isWorkflowEnabled);
+}
+function readDatabaseSchemaResponse4(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    schema: bare6.readData(bc)
+  };
+}
+function writeDatabaseSchemaResponse4(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeData(bc, x.schema);
+}
+function readDatabaseTableRowsResponse4(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    result: bare6.readData(bc)
+  };
+}
+function writeDatabaseTableRowsResponse4(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeData(bc, x.result);
+}
+function readSchedulesResponse(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    schedules: read9(bc)
+  };
+}
+function writeSchedulesResponse(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write9(bc, x.schedules);
+}
+function read11(bc) {
+  const len = bare6.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readScheduleFire(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readScheduleFire(bc);
+  }
+  return result;
+}
+function write11(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeScheduleFire(bc, x[i]);
+  }
+}
+function readScheduleHistoryResponse(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    scheduleId: bare6.readString(bc),
+    history: read11(bc)
+  };
+}
+function writeScheduleHistoryResponse(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeString(bc, x.scheduleId);
+  write11(bc, x.history);
+}
+function readScheduleDeleteResponse(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    scheduleId: bare6.readString(bc),
+    deleted: bare6.readBool(bc)
+  };
+}
+function writeScheduleDeleteResponse(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  bare6.writeString(bc, x.scheduleId);
+  bare6.writeBool(bc, x.deleted);
+}
+function readStateUpdated6(bc) {
+  return {
+    state: readState6(bc)
+  };
+}
+function writeStateUpdated6(bc, x) {
+  writeState6(bc, x.state);
+}
+function readQueueUpdated5(bc) {
+  return {
+    queueSize: bare6.readUint(bc)
+  };
+}
+function writeQueueUpdated5(bc, x) {
+  bare6.writeUint(bc, x.queueSize);
+}
+function readWorkflowHistoryUpdated5(bc) {
+  return {
+    history: readWorkflowHistory5(bc)
+  };
+}
+function writeWorkflowHistoryUpdated5(bc, x) {
+  writeWorkflowHistory5(bc, x.history);
+}
+function readSchedulesUpdated(bc) {
+  return {
+    schedules: read9(bc)
+  };
+}
+function writeSchedulesUpdated(bc, x) {
+  write9(bc, x.schedules);
+}
+function readRpcsListResponse6(bc) {
+  return {
+    rid: bare6.readUint(bc),
+    rpcs: read62(bc)
+  };
+}
+function writeRpcsListResponse6(bc, x) {
+  bare6.writeUint(bc, x.rid);
+  write62(bc, x.rpcs);
+}
+function readConnectionsUpdated6(bc) {
+  return {
+    connections: read45(bc)
+  };
+}
+function writeConnectionsUpdated6(bc, x) {
+  write45(bc, x.connections);
+}
+function readError6(bc) {
+  return {
+    message: bare6.readString(bc)
+  };
+}
+function writeError6(bc, x) {
+  bare6.writeString(bc, x.message);
+}
+function readToClientBody6(bc) {
+  const offset = bc.offset;
+  const tag = bare6.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "StateResponse", val: readStateResponse6(bc) };
+    case 1:
+      return { tag: "ConnectionsResponse", val: readConnectionsResponse6(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse6(bc) };
+    case 3:
+      return { tag: "ConnectionsUpdated", val: readConnectionsUpdated6(bc) };
+    case 4:
+      return { tag: "QueueUpdated", val: readQueueUpdated5(bc) };
+    case 5:
+      return { tag: "StateUpdated", val: readStateUpdated6(bc) };
+    case 6:
+      return { tag: "WorkflowHistoryUpdated", val: readWorkflowHistoryUpdated5(bc) };
+    case 7:
+      return { tag: "SchedulesUpdated", val: readSchedulesUpdated(bc) };
+    case 8:
+      return { tag: "RpcsListResponse", val: readRpcsListResponse6(bc) };
+    case 9:
+      return { tag: "TraceQueryResponse", val: readTraceQueryResponse5(bc) };
+    case 10:
+      return { tag: "QueueResponse", val: readQueueResponse5(bc) };
+    case 11:
+      return { tag: "WorkflowHistoryResponse", val: readWorkflowHistoryResponse5(bc) };
+    case 12:
+      return { tag: "WorkflowReplayResponse", val: readWorkflowReplayResponse3(bc) };
+    case 13:
+      return { tag: "SchedulesResponse", val: readSchedulesResponse(bc) };
+    case 14:
+      return { tag: "ScheduleHistoryResponse", val: readScheduleHistoryResponse(bc) };
+    case 15:
+      return { tag: "ScheduleDeleteResponse", val: readScheduleDeleteResponse(bc) };
+    case 16:
+      return { tag: "Error", val: readError6(bc) };
+    case 17:
+      return { tag: "Init", val: readInit6(bc) };
+    case 18:
+      return { tag: "DatabaseSchemaResponse", val: readDatabaseSchemaResponse4(bc) };
+    case 19:
+      return { tag: "DatabaseTableRowsResponse", val: readDatabaseTableRowsResponse4(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare6.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody6(bc, x) {
+  switch (x.tag) {
+    case "StateResponse": {
+      bare6.writeU8(bc, 0);
+      writeStateResponse6(bc, x.val);
+      break;
+    }
+    case "ConnectionsResponse": {
+      bare6.writeU8(bc, 1);
+      writeConnectionsResponse6(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare6.writeU8(bc, 2);
+      writeActionResponse6(bc, x.val);
+      break;
+    }
+    case "ConnectionsUpdated": {
+      bare6.writeU8(bc, 3);
+      writeConnectionsUpdated6(bc, x.val);
+      break;
+    }
+    case "QueueUpdated": {
+      bare6.writeU8(bc, 4);
+      writeQueueUpdated5(bc, x.val);
+      break;
+    }
+    case "StateUpdated": {
+      bare6.writeU8(bc, 5);
+      writeStateUpdated6(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryUpdated": {
+      bare6.writeU8(bc, 6);
+      writeWorkflowHistoryUpdated5(bc, x.val);
+      break;
+    }
+    case "SchedulesUpdated": {
+      bare6.writeU8(bc, 7);
+      writeSchedulesUpdated(bc, x.val);
+      break;
+    }
+    case "RpcsListResponse": {
+      bare6.writeU8(bc, 8);
+      writeRpcsListResponse6(bc, x.val);
+      break;
+    }
+    case "TraceQueryResponse": {
+      bare6.writeU8(bc, 9);
+      writeTraceQueryResponse5(bc, x.val);
+      break;
+    }
+    case "QueueResponse": {
+      bare6.writeU8(bc, 10);
+      writeQueueResponse5(bc, x.val);
+      break;
+    }
+    case "WorkflowHistoryResponse": {
+      bare6.writeU8(bc, 11);
+      writeWorkflowHistoryResponse5(bc, x.val);
+      break;
+    }
+    case "WorkflowReplayResponse": {
+      bare6.writeU8(bc, 12);
+      writeWorkflowReplayResponse3(bc, x.val);
+      break;
+    }
+    case "SchedulesResponse": {
+      bare6.writeU8(bc, 13);
+      writeSchedulesResponse(bc, x.val);
+      break;
+    }
+    case "ScheduleHistoryResponse": {
+      bare6.writeU8(bc, 14);
+      writeScheduleHistoryResponse(bc, x.val);
+      break;
+    }
+    case "ScheduleDeleteResponse": {
+      bare6.writeU8(bc, 15);
+      writeScheduleDeleteResponse(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare6.writeU8(bc, 16);
+      writeError6(bc, x.val);
+      break;
+    }
+    case "Init": {
+      bare6.writeU8(bc, 17);
+      writeInit6(bc, x.val);
+      break;
+    }
+    case "DatabaseSchemaResponse": {
+      bare6.writeU8(bc, 18);
+      writeDatabaseSchemaResponse4(bc, x.val);
+      break;
+    }
+    case "DatabaseTableRowsResponse": {
+      bare6.writeU8(bc, 19);
+      writeDatabaseTableRowsResponse4(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient6(bc) {
+  return {
+    body: readToClientBody6(bc)
+  };
+}
+function writeToClient6(bc, x) {
+  writeToClientBody6(bc, x.body);
+}
+function encodeToClient6(x, config2) {
+  const fullConfig = config2 != null ? bare6.Config(config2) : DEFAULT_CONFIG6;
+  const bc = new bare6.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToClient6(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient6(bytes) {
+  const bc = new bare6.ByteCursor(bytes, DEFAULT_CONFIG6);
+  const result = readToClient6(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare6.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({});
+import * as bare7 from "@rivetkit/bare-ts";
+var config = /* @__PURE__ */ bare7.Config({});
 function readWorkflowCbor(bc) {
-  return bare6.readData(bc);
+  return bare7.readData(bc);
 }
 function writeWorkflowCbor(bc, x) {
-  bare6.writeData(bc, x);
+  bare7.writeData(bc, x);
 }
 function readWorkflowNameIndex(bc) {
-  return bare6.readU32(bc);
+  return bare7.readU32(bc);
 }
 function writeWorkflowNameIndex(bc, x) {
-  bare6.writeU32(bc, x);
+  bare7.writeU32(bc, x);
 }
 function readWorkflowLoopIterationMarker(bc) {
   return {
     loop: readWorkflowNameIndex(bc),
-    iteration: bare6.readU32(bc)
+    iteration: bare7.readU32(bc)
   };
 }
 function writeWorkflowLoopIterationMarker(bc, x) {
   writeWorkflowNameIndex(bc, x.loop);
-  bare6.writeU32(bc, x.iteration);
+  bare7.writeU32(bc, x.iteration);
 }
 function readWorkflowPathSegment(bc) {
   const offset = bc.offset;
-  const tag = bare6.readU8(bc);
+  const tag = bare7.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "WorkflowNameIndex", val: readWorkflowNameIndex(bc) };
@@ -3154,26 +4106,26 @@ function readWorkflowPathSegment(bc) {
       };
     default: {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "invalid tag");
+      throw new bare7.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowPathSegment(bc, x) {
   switch (x.tag) {
     case "WorkflowNameIndex": {
-      bare6.writeU8(bc, 0);
+      bare7.writeU8(bc, 0);
       writeWorkflowNameIndex(bc, x.val);
       break;
     }
     case "WorkflowLoopIterationMarker": {
-      bare6.writeU8(bc, 1);
+      bare7.writeU8(bc, 1);
       writeWorkflowLoopIterationMarker(bc, x.val);
       break;
     }
   }
 }
 function readWorkflowLocation(bc) {
-  const len = bare6.readUintSafe(bc);
+  const len = bare7.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -3184,14 +4136,14 @@ function readWorkflowLocation(bc) {
   return result;
 }
 function writeWorkflowLocation(bc, x) {
-  bare6.writeUintSafe(bc, x.length);
+  bare7.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 = bare6.readU8(bc);
+  const tag = bare7.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -3205,37 +4157,37 @@ function readWorkflowEntryStatus(bc) {
       return "EXHAUSTED" /* EXHAUSTED */;
     default: {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "invalid tag");
+      throw new bare7.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowEntryStatus(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare6.writeU8(bc, 0);
+      bare7.writeU8(bc, 0);
       break;
     }
     case "RUNNING" /* RUNNING */: {
-      bare6.writeU8(bc, 1);
+      bare7.writeU8(bc, 1);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare6.writeU8(bc, 2);
+      bare7.writeU8(bc, 2);
       break;
     }
     case "FAILED" /* FAILED */: {
-      bare6.writeU8(bc, 3);
+      bare7.writeU8(bc, 3);
       break;
     }
     case "EXHAUSTED" /* EXHAUSTED */: {
-      bare6.writeU8(bc, 4);
+      bare7.writeU8(bc, 4);
       break;
     }
   }
 }
 function readWorkflowSleepState(bc) {
   const offset = bc.offset;
-  const tag = bare6.readU8(bc);
+  const tag = bare7.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -3245,29 +4197,29 @@ function readWorkflowSleepState(bc) {
       return "INTERRUPTED" /* INTERRUPTED */;
     default: {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "invalid tag");
+      throw new bare7.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowSleepState(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare6.writeU8(bc, 0);
+      bare7.writeU8(bc, 0);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare6.writeU8(bc, 1);
+      bare7.writeU8(bc, 1);
       break;
     }
     case "INTERRUPTED" /* INTERRUPTED */: {
-      bare6.writeU8(bc, 2);
+      bare7.writeU8(bc, 2);
       break;
     }
   }
 }
 function readWorkflowBranchStatusType(bc) {
   const offset = bc.offset;
-  const tag = bare6.readU8(bc);
+  const tag = bare7.readU8(bc);
   switch (tag) {
     case 0:
       return "PENDING" /* PENDING */;
@@ -3281,176 +4233,176 @@ function readWorkflowBranchStatusType(bc) {
       return "CANCELLED" /* CANCELLED */;
     default: {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "invalid tag");
+      throw new bare7.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowBranchStatusType(bc, x) {
   switch (x) {
     case "PENDING" /* PENDING */: {
-      bare6.writeU8(bc, 0);
+      bare7.writeU8(bc, 0);
       break;
     }
     case "RUNNING" /* RUNNING */: {
-      bare6.writeU8(bc, 1);
+      bare7.writeU8(bc, 1);
       break;
     }
     case "COMPLETED" /* COMPLETED */: {
-      bare6.writeU8(bc, 2);
+      bare7.writeU8(bc, 2);
       break;
     }
     case "FAILED" /* FAILED */: {
-      bare6.writeU8(bc, 3);
+      bare7.writeU8(bc, 3);
       break;
     }
     case "CANCELLED" /* CANCELLED */: {
-      bare6.writeU8(bc, 4);
+      bare7.writeU8(bc, 4);
       break;
     }
   }
 }
-function read06(bc) {
-  return bare6.readBool(bc) ? readWorkflowCbor(bc) : null;
+function read07(bc) {
+  return bare7.readBool(bc) ? readWorkflowCbor(bc) : null;
 }
-function write06(bc, x) {
-  bare6.writeBool(bc, x !== null);
+function write07(bc, x) {
+  bare7.writeBool(bc, x !== null);
   if (x !== null) {
     writeWorkflowCbor(bc, x);
   }
 }
-function read16(bc) {
-  return bare6.readBool(bc) ? bare6.readString(bc) : null;
+function read17(bc) {
+  return bare7.readBool(bc) ? bare7.readString(bc) : null;
 }
-function write16(bc, x) {
-  bare6.writeBool(bc, x !== null);
+function write17(bc, x) {
+  bare7.writeBool(bc, x !== null);
   if (x !== null) {
-    bare6.writeString(bc, x);
+    bare7.writeString(bc, x);
   }
 }
 function readWorkflowStepEntry(bc) {
   return {
-    output: read06(bc),
-    error: read16(bc)
+    output: read07(bc),
+    error: read17(bc)
   };
 }
 function writeWorkflowStepEntry(bc, x) {
-  write06(bc, x.output);
-  write16(bc, x.error);
+  write07(bc, x.output);
+  write17(bc, x.error);
 }
 function readWorkflowLoopEntry(bc) {
   return {
     state: readWorkflowCbor(bc),
-    iteration: bare6.readU32(bc),
-    output: read06(bc)
+    iteration: bare7.readU32(bc),
+    output: read07(bc)
   };
 }
 function writeWorkflowLoopEntry(bc, x) {
   writeWorkflowCbor(bc, x.state);
-  bare6.writeU32(bc, x.iteration);
-  write06(bc, x.output);
+  bare7.writeU32(bc, x.iteration);
+  write07(bc, x.output);
 }
 function readWorkflowSleepEntry(bc) {
   return {
-    deadline: bare6.readU64(bc),
+    deadline: bare7.readU64(bc),
     state: readWorkflowSleepState(bc)
   };
 }
 function writeWorkflowSleepEntry(bc, x) {
-  bare6.writeU64(bc, x.deadline);
+  bare7.writeU64(bc, x.deadline);
   writeWorkflowSleepState(bc, x.state);
 }
 function readWorkflowMessageEntry(bc) {
   return {
-    name: bare6.readString(bc),
+    name: bare7.readString(bc),
     messageData: readWorkflowCbor(bc)
   };
 }
 function writeWorkflowMessageEntry(bc, x) {
-  bare6.writeString(bc, x.name);
+  bare7.writeString(bc, x.name);
   writeWorkflowCbor(bc, x.messageData);
 }
 function readWorkflowRollbackCheckpointEntry(bc) {
   return {
-    name: bare6.readString(bc)
+    name: bare7.readString(bc)
   };
 }
 function writeWorkflowRollbackCheckpointEntry(bc, x) {
-  bare6.writeString(bc, x.name);
+  bare7.writeString(bc, x.name);
 }
 function readWorkflowBranchStatus(bc) {
   return {
     status: readWorkflowBranchStatusType(bc),
-    output: read06(bc),
-    error: read16(bc)
+    output: read07(bc),
+    error: read17(bc)
   };
 }
 function writeWorkflowBranchStatus(bc, x) {
   writeWorkflowBranchStatusType(bc, x.status);
-  write06(bc, x.output);
-  write16(bc, x.error);
+  write07(bc, x.output);
+  write17(bc, x.error);
 }
-function read26(bc) {
-  const len = bare6.readUintSafe(bc);
+function read27(bc) {
+  const len = bare7.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
     const offset = bc.offset;
-    const key = bare6.readString(bc);
+    const key = bare7.readString(bc);
     if (result.has(key)) {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "duplicated key");
+      throw new bare7.BareError(offset, "duplicated key");
     }
     result.set(key, readWorkflowBranchStatus(bc));
   }
   return result;
 }
-function write26(bc, x) {
-  bare6.writeUintSafe(bc, x.size);
+function write27(bc, x) {
+  bare7.writeUintSafe(bc, x.size);
   for (const kv of x) {
-    bare6.writeString(bc, kv[0]);
+    bare7.writeString(bc, kv[0]);
     writeWorkflowBranchStatus(bc, kv[1]);
   }
 }
 function readWorkflowJoinEntry(bc) {
   return {
-    branches: read26(bc)
+    branches: read27(bc)
   };
 }
 function writeWorkflowJoinEntry(bc, x) {
-  write26(bc, x.branches);
+  write27(bc, x.branches);
 }
 function readWorkflowRaceEntry(bc) {
   return {
-    winner: read16(bc),
-    branches: read26(bc)
+    winner: read17(bc),
+    branches: read27(bc)
   };
 }
 function writeWorkflowRaceEntry(bc, x) {
-  write16(bc, x.winner);
-  write26(bc, x.branches);
+  write17(bc, x.winner);
+  write27(bc, x.branches);
 }
 function readWorkflowRemovedEntry(bc) {
   return {
-    originalType: bare6.readString(bc),
-    originalName: read16(bc)
+    originalType: bare7.readString(bc),
+    originalName: read17(bc)
   };
 }
 function writeWorkflowRemovedEntry(bc, x) {
-  bare6.writeString(bc, x.originalType);
-  write16(bc, x.originalName);
+  bare7.writeString(bc, x.originalType);
+  write17(bc, x.originalName);
 }
 function readWorkflowVersionCheckEntry(bc) {
   return {
-    resolved: bare6.readU32(bc),
-    latest: bare6.readU32(bc)
+    resolved: bare7.readU32(bc),
+    latest: bare7.readU32(bc)
   };
 }
 function writeWorkflowVersionCheckEntry(bc, x) {
-  bare6.writeU32(bc, x.resolved);
-  bare6.writeU32(bc, x.latest);
+  bare7.writeU32(bc, x.resolved);
+  bare7.writeU32(bc, x.latest);
 }
 function readWorkflowEntryKind(bc) {
   const offset = bc.offset;
-  const tag = bare6.readU8(bc);
+  const tag = bare7.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "WorkflowStepEntry", val: readWorkflowStepEntry(bc) };
@@ -3487,54 +4439,54 @@ function readWorkflowEntryKind(bc) {
       };
     default: {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "invalid tag");
+      throw new bare7.BareError(offset, "invalid tag");
     }
   }
 }
 function writeWorkflowEntryKind(bc, x) {
   switch (x.tag) {
     case "WorkflowStepEntry": {
-      bare6.writeU8(bc, 0);
+      bare7.writeU8(bc, 0);
       writeWorkflowStepEntry(bc, x.val);
       break;
     }
     case "WorkflowLoopEntry": {
-      bare6.writeU8(bc, 1);
+      bare7.writeU8(bc, 1);
       writeWorkflowLoopEntry(bc, x.val);
       break;
     }
     case "WorkflowSleepEntry": {
-      bare6.writeU8(bc, 2);
+      bare7.writeU8(bc, 2);
       writeWorkflowSleepEntry(bc, x.val);
       break;
     }
     case "WorkflowMessageEntry": {
-      bare6.writeU8(bc, 3);
+      bare7.writeU8(bc, 3);
       writeWorkflowMessageEntry(bc, x.val);
       break;
     }
     case "WorkflowRollbackCheckpointEntry": {
-      bare6.writeU8(bc, 4);
+      bare7.writeU8(bc, 4);
       writeWorkflowRollbackCheckpointEntry(bc, x.val);
       break;
     }
     case "WorkflowJoinEntry": {
-      bare6.writeU8(bc, 5);
+      bare7.writeU8(bc, 5);
       writeWorkflowJoinEntry(bc, x.val);
       break;
     }
     case "WorkflowRaceEntry": {
-      bare6.writeU8(bc, 6);
+      bare7.writeU8(bc, 6);
       writeWorkflowRaceEntry(bc, x.val);
       break;
     }
     case "WorkflowRemovedEntry": {
-      bare6.writeU8(bc, 7);
+      bare7.writeU8(bc, 7);
       writeWorkflowRemovedEntry(bc, x.val);
       break;
     }
     case "WorkflowVersionCheckEntry": {
-      bare6.writeU8(bc, 8);
+      bare7.writeU8(bc, 8);
       writeWorkflowVersionCheckEntry(bc, x.val);
       break;
     }
@@ -3542,66 +4494,66 @@ function writeWorkflowEntryKind(bc, x) {
 }
 function readWorkflowEntry(bc) {
   return {
-    id: bare6.readString(bc),
+    id: bare7.readString(bc),
     location: readWorkflowLocation(bc),
     kind: readWorkflowEntryKind(bc)
   };
 }
 function writeWorkflowEntry(bc, x) {
-  bare6.writeString(bc, x.id);
+  bare7.writeString(bc, x.id);
   writeWorkflowLocation(bc, x.location);
   writeWorkflowEntryKind(bc, x.kind);
 }
-function read36(bc) {
-  return bare6.readBool(bc) ? bare6.readU64(bc) : null;
+function read37(bc) {
+  return bare7.readBool(bc) ? bare7.readU64(bc) : null;
 }
-function write36(bc, x) {
-  bare6.writeBool(bc, x !== null);
+function write37(bc, x) {
+  bare7.writeBool(bc, x !== null);
   if (x !== null) {
-    bare6.writeU64(bc, x);
+    bare7.writeU64(bc, x);
   }
 }
 function readWorkflowEntryMetadata(bc) {
   return {
     status: readWorkflowEntryStatus(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)
+    error: read17(bc),
+    attempts: bare7.readU32(bc),
+    lastAttemptAt: bare7.readU64(bc),
+    createdAt: bare7.readU64(bc),
+    completedAt: read37(bc),
+    rollbackCompletedAt: read37(bc),
+    rollbackError: read17(bc)
   };
 }
 function writeWorkflowEntryMetadata(bc, x) {
   writeWorkflowEntryStatus(bc, x.status);
-  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);
+  write17(bc, x.error);
+  bare7.writeU32(bc, x.attempts);
+  bare7.writeU64(bc, x.lastAttemptAt);
+  bare7.writeU64(bc, x.createdAt);
+  write37(bc, x.completedAt);
+  write37(bc, x.rollbackCompletedAt);
+  write17(bc, x.rollbackError);
+}
+function read46(bc) {
+  const len = bare7.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
-  const result = [bare6.readString(bc)];
+  const result = [bare7.readString(bc)];
   for (let i = 1; i < len; i++) {
-    result[i] = bare6.readString(bc);
+    result[i] = bare7.readString(bc);
   }
   return result;
 }
-function write45(bc, x) {
-  bare6.writeUintSafe(bc, x.length);
+function write46(bc, x) {
+  bare7.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
-    bare6.writeString(bc, x[i]);
+    bare7.writeString(bc, x[i]);
   }
 }
-function read53(bc) {
-  const len = bare6.readUintSafe(bc);
+function read54(bc) {
+  const len = bare7.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -3611,58 +4563,58 @@ function read53(bc) {
   }
   return result;
 }
-function write53(bc, x) {
-  bare6.writeUintSafe(bc, x.length);
+function write54(bc, x) {
+  bare7.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeWorkflowEntry(bc, x[i]);
   }
 }
-function read62(bc) {
-  const len = bare6.readUintSafe(bc);
+function read63(bc) {
+  const len = bare7.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
     const offset = bc.offset;
-    const key = bare6.readString(bc);
+    const key = bare7.readString(bc);
     if (result.has(key)) {
       bc.offset = offset;
-      throw new bare6.BareError(offset, "duplicated key");
+      throw new bare7.BareError(offset, "duplicated key");
     }
     result.set(key, readWorkflowEntryMetadata(bc));
   }
   return result;
 }
-function write62(bc, x) {
-  bare6.writeUintSafe(bc, x.size);
+function write63(bc, x) {
+  bare7.writeUintSafe(bc, x.size);
   for (const kv of x) {
-    bare6.writeString(bc, kv[0]);
+    bare7.writeString(bc, kv[0]);
     writeWorkflowEntryMetadata(bc, kv[1]);
   }
 }
-function readWorkflowHistory5(bc) {
+function readWorkflowHistory6(bc) {
   return {
-    nameRegistry: read45(bc),
-    entries: read53(bc),
-    entryMetadata: read62(bc)
+    nameRegistry: read46(bc),
+    entries: read54(bc),
+    entryMetadata: read63(bc)
   };
 }
-function writeWorkflowHistory5(bc, x) {
-  write45(bc, x.nameRegistry);
-  write53(bc, x.entries);
-  write62(bc, x.entryMetadata);
+function writeWorkflowHistory6(bc, x) {
+  write46(bc, x.nameRegistry);
+  write54(bc, x.entries);
+  write63(bc, x.entryMetadata);
 }
 function encodeWorkflowHistory(x) {
-  const bc = new bare6.ByteCursor(
+  const bc = new bare7.ByteCursor(
     new Uint8Array(config.initialBufferLength),
     config
   );
-  writeWorkflowHistory5(bc, x);
+  writeWorkflowHistory6(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodeWorkflowHistory(bytes) {
-  const bc = new bare6.ByteCursor(bytes, config);
-  const result = readWorkflowHistory5(bc);
+  const bc = new bare7.ByteCursor(bytes, config);
+  const result = readWorkflowHistory6(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare6.BareError(bc.offset, "remaining bytes");
+    throw new bare7.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
@@ -3670,7 +4622,7 @@ function decodeWorkflowHistory(bytes) {
 // package.json
 var package_default = {
   name: "rivetkit",
-  version: "2.3.4",
+  version: "2.3.5-rc.1",
   description: "Lightweight libraries for building stateful actors on edge platforms",
   license: "Apache-2.0",
   keywords: [
@@ -3951,12 +4903,13 @@ function decodeWorkflowHistoryTransport(data) {
 }
 
 // src/inspector/client.browser.ts
-var CURRENT_VERSION = 5;
+var CURRENT_VERSION = 6;
 var EVENTS_DROPPED_ERROR = "inspector.events_dropped";
 var WORKFLOW_HISTORY_DROPPED_ERROR = "inspector.workflow_history_dropped";
 var QUEUE_DROPPED_ERROR = "inspector.queue_dropped";
 var TRACE_DROPPED_ERROR = "inspector.trace_dropped";
 var DATABASE_DROPPED_ERROR = "inspector.database_dropped";
+var SCHEDULES_DROPPED_ERROR = "inspector.schedules_dropped";
 var v1ToClientToV2 = (v1Data) => {
   if (v1Data.body.tag === "Init") {
     const init = v1Data.body.val;
@@ -4089,8 +5042,41 @@ var v5ToClientToV4 = (v5Data) => {
   }
   return v5Data;
 };
+var v5ToClientToV6 = (v5Data) => {
+  if (v5Data.body.tag === "Init") {
+    return {
+      body: {
+        tag: "Init",
+        val: { ...v5Data.body.val, schedules: [] }
+      }
+    };
+  }
+  return v5Data;
+};
+var v6ToClientToV5 = (v6Data) => {
+  if (v6Data.body.tag === "Init") {
+    const { schedules: _schedules, ...rest } = v6Data.body.val;
+    return { body: { tag: "Init", val: rest } };
+  }
+  if (v6Data.body.tag === "SchedulesUpdated" || v6Data.body.tag === "SchedulesResponse" || v6Data.body.tag === "ScheduleHistoryResponse" || v6Data.body.tag === "ScheduleDeleteResponse") {
+    return {
+      body: {
+        tag: "Error",
+        val: { message: SCHEDULES_DROPPED_ERROR }
+      }
+    };
+  }
+  return v6Data;
+};
 var v4ToServerToV5 = (v4Data) => v4Data;
 var v5ToServerToV4 = (v5Data) => v5Data;
+var v5ToServerToV6 = (v5Data) => v5Data;
+var v6ToServerToV5 = (v6Data) => {
+  if (v6Data.body.tag === "SchedulesRequest" || v6Data.body.tag === "ScheduleHistoryRequest" || v6Data.body.tag === "ScheduleDeleteRequest") {
+    throw new Error("Cannot convert v6-only schedule requests to v5");
+  }
+  return v6Data;
+};
 var v1ToServerToV2 = (v1Data) => {
   if (v1Data.body.tag === "EventsRequest" || v1Data.body.tag === "ClearEventsRequest") {
     throw new Error("Cannot convert events requests to v2");
@@ -4132,6 +5118,8 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
         return encodeToServer4(data);
       case 5:
         return encodeToServer5(data);
+      case 6:
+        return encodeToServer6(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -4148,6 +5136,8 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
         return decodeToServer4(bytes);
       case 5:
         return decodeToServer5(bytes);
+      case 6:
+        return decodeToServer6(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -4156,9 +5146,11 @@ var TO_SERVER_VERSIONED = createVersionedDataHandler({
     v1ToServerToV2,
     v2ToServerToV3,
     v3ToServerToV4,
-    v4ToServerToV5
+    v4ToServerToV5,
+    v5ToServerToV6
   ],
   serializeConverters: () => [
+    v6ToServerToV5,
     v5ToServerToV4,
     v4ToServerToV3,
     v3ToServerToV2,
@@ -4178,6 +5170,8 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
         return encodeToClient4(data);
       case 5:
         return encodeToClient5(data);
+      case 6:
+        return encodeToClient6(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -4194,6 +5188,8 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
         return decodeToClient4(bytes);
       case 5:
         return decodeToClient5(bytes);
+      case 6:
+        return decodeToClient6(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -4202,9 +5198,11 @@ var TO_CLIENT_VERSIONED = createVersionedDataHandler({
     v1ToClientToV2,
     v2ToClientToV3,
     v3ToClientToV4,
-    v4ToClientToV5
+    v4ToClientToV5,
+    v5ToClientToV6
   ],
   serializeConverters: () => [
+    v6ToClientToV5,
     v5ToClientToV4,
     v4ToClientToV3,
     v3ToClientToV2,
@@ -4215,85 +5213,105 @@ export {
   CURRENT_VERSION,
   TO_CLIENT_VERSIONED,
   TO_SERVER_VERSIONED,
-  decodeToClient5 as decodeToClient,
-  decodeToServer5 as decodeToServer,
+  decodeToClient6 as decodeToClient,
+  decodeToServer6 as decodeToServer,
   decodeWorkflowHistoryTransport,
-  encodeToClient5 as encodeToClient,
-  encodeToServer5 as encodeToServer,
+  encodeToClient6 as encodeToClient,
+  encodeToServer6 as encodeToServer,
   encodeWorkflowHistoryTransport,
-  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
+  readActionRequest6 as readActionRequest,
+  readActionResponse6 as readActionResponse,
+  readConnection6 as readConnection,
+  readConnectionsRequest6 as readConnectionsRequest,
+  readConnectionsResponse6 as readConnectionsResponse,
+  readConnectionsUpdated6 as readConnectionsUpdated,
+  readDatabaseSchemaRequest4 as readDatabaseSchemaRequest,
+  readDatabaseSchemaResponse4 as readDatabaseSchemaResponse,
+  readDatabaseTableRowsRequest4 as readDatabaseTableRowsRequest,
+  readDatabaseTableRowsResponse4 as readDatabaseTableRowsResponse,
+  readError6 as readError,
+  readInit6 as readInit,
+  readPatchStateRequest6 as readPatchStateRequest,
+  readQueueMessageSummary5 as readQueueMessageSummary,
+  readQueueRequest5 as readQueueRequest,
+  readQueueResponse5 as readQueueResponse,
+  readQueueStatus5 as readQueueStatus,
+  readQueueUpdated5 as readQueueUpdated,
+  readRpcsListRequest6 as readRpcsListRequest,
+  readRpcsListResponse6 as readRpcsListResponse,
+  readSchedule,
+  readScheduleDeleteRequest,
+  readScheduleDeleteResponse,
+  readScheduleError,
+  readScheduleFire,
+  readScheduleHistoryRequest,
+  readScheduleHistoryResponse,
+  readSchedulesRequest,
+  readSchedulesResponse,
+  readSchedulesUpdated,
+  readState6 as readState,
+  readStateRequest6 as readStateRequest,
+  readStateResponse6 as readStateResponse,
+  readStateUpdated6 as readStateUpdated,
+  readTabConfigEntry2 as readTabConfigEntry,
+  readToClient6 as readToClient,
+  readToClientBody6 as readToClientBody,
+  readToServer6 as readToServer,
+  readToServerBody6 as readToServerBody,
+  readTraceQueryRequest5 as readTraceQueryRequest,
+  readTraceQueryResponse5 as readTraceQueryResponse,
+  readWorkflowHistory5 as readWorkflowHistory,
+  readWorkflowHistoryRequest5 as readWorkflowHistoryRequest,
+  readWorkflowHistoryResponse5 as readWorkflowHistoryResponse,
+  readWorkflowHistoryUpdated5 as readWorkflowHistoryUpdated,
+  readWorkflowReplayRequest3 as readWorkflowReplayRequest,
+  readWorkflowReplayResponse3 as readWorkflowReplayResponse,
+  writeActionRequest6 as writeActionRequest,
+  writeActionResponse6 as writeActionResponse,
+  writeConnection6 as writeConnection,
+  writeConnectionsRequest6 as writeConnectionsRequest,
+  writeConnectionsResponse6 as writeConnectionsResponse,
+  writeConnectionsUpdated6 as writeConnectionsUpdated,
+  writeDatabaseSchemaRequest4 as writeDatabaseSchemaRequest,
+  writeDatabaseSchemaResponse4 as writeDatabaseSchemaResponse,
+  writeDatabaseTableRowsRequest4 as writeDatabaseTableRowsRequest,
+  writeDatabaseTableRowsResponse4 as writeDatabaseTableRowsResponse,
+  writeError6 as writeError,
+  writeInit6 as writeInit,
+  writePatchStateRequest6 as writePatchStateRequest,
+  writeQueueMessageSummary5 as writeQueueMessageSummary,
+  writeQueueRequest5 as writeQueueRequest,
+  writeQueueResponse5 as writeQueueResponse,
+  writeQueueStatus5 as writeQueueStatus,
+  writeQueueUpdated5 as writeQueueUpdated,
+  writeRpcsListRequest6 as writeRpcsListRequest,
+  writeRpcsListResponse6 as writeRpcsListResponse,
+  writeSchedule,
+  writeScheduleDeleteRequest,
+  writeScheduleDeleteResponse,
+  writeScheduleError,
+  writeScheduleFire,
+  writeScheduleHistoryRequest,
+  writeScheduleHistoryResponse,
+  writeSchedulesRequest,
+  writeSchedulesResponse,
+  writeSchedulesUpdated,
+  writeState6 as writeState,
+  writeStateRequest6 as writeStateRequest,
+  writeStateResponse6 as writeStateResponse,
+  writeStateUpdated6 as writeStateUpdated,
+  writeTabConfigEntry2 as writeTabConfigEntry,
+  writeToClient6 as writeToClient,
+  writeToClientBody6 as writeToClientBody,
+  writeToServer6 as writeToServer,
+  writeToServerBody6 as writeToServerBody,
+  writeTraceQueryRequest5 as writeTraceQueryRequest,
+  writeTraceQueryResponse5 as writeTraceQueryResponse,
+  writeWorkflowHistory5 as writeWorkflowHistory,
+  writeWorkflowHistoryRequest5 as writeWorkflowHistoryRequest,
+  writeWorkflowHistoryResponse5 as writeWorkflowHistoryResponse,
+  writeWorkflowHistoryUpdated5 as writeWorkflowHistoryUpdated,
+  writeWorkflowReplayRequest3 as writeWorkflowReplayRequest,
+  writeWorkflowReplayResponse3 as writeWorkflowReplayResponse
 };
 //# sourceMappingURL=client.js.map