rivetkit 2.3.0-rc.5 → 2.3.0-rc.6

package/dist/tsup/{chunk-JY73X7VU.js → chunk-FLODVLYW.js}

@@ -12,14 +12,14 @@ import {
   jsonStringifyCompat,
   serializeWithEncoding,
   uint8ArrayToBase64
-} from "./chunk-LDTT6WKJ.js";
+} from "./chunk-RTC2AZGB.js";
 import {
   AsyncMutex
 } from "./chunk-PCBNKI2J.js";
 import {
   importWebSocket,
   logger
-} from "./chunk-UXTP4EBU.js";
+} from "./chunk-ZI5QJMKO.js";
 import {
   assertUnreachable,
   bufferToArrayBuffer,
@@ -37,13 +37,13 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-N2DQSJIW.js";
+} from "./chunk-6S25NVAP.js";
 import {
   INTERNAL_ERROR_CODE,
   RivetError,
   actorNotFound,
   invalidRequest
-} from "./chunk-K34B3OVG.js";
+} from "./chunk-KIWH5H3K.js";
 
 // src/common/actor-router-consts.ts
 var PATH_CONNECT = "/connect";
@@ -53,6 +53,8 @@ var HEADER_ACTOR_QUERY = "x-rivet-query";
 var HEADER_ENCODING = "x-rivet-encoding";
 var HEADER_CONN_PARAMS = "x-rivet-conn-params";
 var HEADER_ACTOR_ID = "x-rivet-actor";
+var HEADER_ACTOR_GENERATION = "x-rivet-actor-generation";
+var HEADER_ACTOR_KEY = "x-rivet-actor-key";
 var HEADER_RIVET_TOKEN = "x-rivet-token";
 var HEADER_RIVET_TARGET = "x-rivet-target";
 var HEADER_RIVET_ACTOR = "x-rivet-actor";
@@ -73,6 +75,8 @@ var ALLOWED_PUBLIC_HEADERS = [
   HEADER_ENCODING,
   HEADER_CONN_PARAMS,
   HEADER_ACTOR_ID,
+  HEADER_ACTOR_GENERATION,
+  HEADER_ACTOR_KEY,
   HEADER_RIVET_TARGET,
   HEADER_RIVET_ACTOR,
   HEADER_RIVET_NAMESPACE,
@@ -1180,8 +1184,440 @@ function decodeHttpResolveResponse3(bytes) {
   return result;
 }
 
+// src/common/bare/generated/client-protocol/v4.ts
+import * as bare4 from "@rivetkit/bare-ts";
+var DEFAULT_CONFIG4 = /* @__PURE__ */ bare4.Config({});
+function readCbor4(bc) {
+  return bare4.readData(bc);
+}
+function writeCbor4(bc, x) {
+  bare4.writeData(bc, x);
+}
+function read04(bc) {
+  return bare4.readBool(bc) ? bare4.readString(bc) : null;
+}
+function write04(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeString(bc, x);
+  }
+}
+function readActorSpecifier(bc) {
+  return {
+    actorId: bare4.readString(bc),
+    generation: bare4.readUint(bc),
+    key: read04(bc)
+  };
+}
+function writeActorSpecifier(bc, x) {
+  bare4.writeString(bc, x.actorId);
+  bare4.writeUint(bc, x.generation);
+  write04(bc, x.key);
+}
+function readInit4(bc) {
+  return {
+    actorId: bare4.readString(bc),
+    connectionId: bare4.readString(bc)
+  };
+}
+function writeInit4(bc, x) {
+  bare4.writeString(bc, x.actorId);
+  bare4.writeString(bc, x.connectionId);
+}
+function read14(bc) {
+  return bare4.readBool(bc) ? readCbor4(bc) : null;
+}
+function write14(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    writeCbor4(bc, x);
+  }
+}
+function read22(bc) {
+  return bare4.readBool(bc) ? bare4.readUint(bc) : null;
+}
+function write22(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeUint(bc, x);
+  }
+}
+function read32(bc) {
+  return bare4.readBool(bc) ? readActorSpecifier(bc) : null;
+}
+function write32(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    writeActorSpecifier(bc, x);
+  }
+}
+function readError4(bc) {
+  return {
+    group: bare4.readString(bc),
+    code: bare4.readString(bc),
+    message: bare4.readString(bc),
+    metadata: read14(bc),
+    actionId: read22(bc),
+    actor: read32(bc)
+  };
+}
+function writeError4(bc, x) {
+  bare4.writeString(bc, x.group);
+  bare4.writeString(bc, x.code);
+  bare4.writeString(bc, x.message);
+  write14(bc, x.metadata);
+  write22(bc, x.actionId);
+  write32(bc, x.actor);
+}
+function readActionResponse4(bc) {
+  return {
+    id: bare4.readUint(bc),
+    output: readCbor4(bc)
+  };
+}
+function writeActionResponse4(bc, x) {
+  bare4.writeUint(bc, x.id);
+  writeCbor4(bc, x.output);
+}
+function readEvent4(bc) {
+  return {
+    name: bare4.readString(bc),
+    args: readCbor4(bc)
+  };
+}
+function writeEvent4(bc, x) {
+  bare4.writeString(bc, x.name);
+  writeCbor4(bc, x.args);
+}
+function readToClientBody4(bc) {
+  const offset = bc.offset;
+  const tag = bare4.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "Init", val: readInit4(bc) };
+    case 1:
+      return { tag: "Error", val: readError4(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse4(bc) };
+    case 3:
+      return { tag: "Event", val: readEvent4(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare4.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody4(bc, x) {
+  switch (x.tag) {
+    case "Init": {
+      bare4.writeU8(bc, 0);
+      writeInit4(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare4.writeU8(bc, 1);
+      writeError4(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare4.writeU8(bc, 2);
+      writeActionResponse4(bc, x.val);
+      break;
+    }
+    case "Event": {
+      bare4.writeU8(bc, 3);
+      writeEvent4(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient4(bc) {
+  return {
+    body: readToClientBody4(bc)
+  };
+}
+function writeToClient4(bc, x) {
+  writeToClientBody4(bc, x.body);
+}
+function encodeToClient4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToClient4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readToClient4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActionRequest4(bc) {
+  return {
+    id: bare4.readUint(bc),
+    name: bare4.readString(bc),
+    args: readCbor4(bc)
+  };
+}
+function writeActionRequest4(bc, x) {
+  bare4.writeUint(bc, x.id);
+  bare4.writeString(bc, x.name);
+  writeCbor4(bc, x.args);
+}
+function readSubscriptionRequest4(bc) {
+  return {
+    eventName: bare4.readString(bc),
+    subscribe: bare4.readBool(bc)
+  };
+}
+function writeSubscriptionRequest4(bc, x) {
+  bare4.writeString(bc, x.eventName);
+  bare4.writeBool(bc, x.subscribe);
+}
+function readToServerBody4(bc) {
+  const offset = bc.offset;
+  const tag = bare4.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActionRequest", val: readActionRequest4(bc) };
+    case 1:
+      return { tag: "SubscriptionRequest", val: readSubscriptionRequest4(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare4.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody4(bc, x) {
+  switch (x.tag) {
+    case "ActionRequest": {
+      bare4.writeU8(bc, 0);
+      writeActionRequest4(bc, x.val);
+      break;
+    }
+    case "SubscriptionRequest": {
+      bare4.writeU8(bc, 1);
+      writeSubscriptionRequest4(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer4(bc) {
+  return {
+    body: readToServerBody4(bc)
+  };
+}
+function writeToServer4(bc, x) {
+  writeToServerBody4(bc, x.body);
+}
+function encodeToServer4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeToServer4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readToServer4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionRequest4(bc) {
+  return {
+    args: readCbor4(bc)
+  };
+}
+function writeHttpActionRequest4(bc, x) {
+  writeCbor4(bc, x.args);
+}
+function encodeHttpActionRequest4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpActionRequest4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionRequest4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpActionRequest4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionResponse4(bc) {
+  return {
+    output: readCbor4(bc)
+  };
+}
+function writeHttpActionResponse4(bc, x) {
+  writeCbor4(bc, x.output);
+}
+function encodeHttpActionResponse4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpActionResponse4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionResponse4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpActionResponse4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read42(bc) {
+  return bare4.readBool(bc) ? bare4.readBool(bc) : null;
+}
+function write42(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeBool(bc, x);
+  }
+}
+function read5(bc) {
+  return bare4.readBool(bc) ? bare4.readU64(bc) : null;
+}
+function write5(bc, x) {
+  bare4.writeBool(bc, x != null);
+  if (x != null) {
+    bare4.writeU64(bc, x);
+  }
+}
+function readHttpQueueSendRequest2(bc) {
+  return {
+    body: readCbor4(bc),
+    name: read04(bc),
+    wait: read42(bc),
+    timeout: read5(bc)
+  };
+}
+function writeHttpQueueSendRequest2(bc, x) {
+  writeCbor4(bc, x.body);
+  write04(bc, x.name);
+  write42(bc, x.wait);
+  write5(bc, x.timeout);
+}
+function encodeHttpQueueSendRequest2(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpQueueSendRequest2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendRequest2(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpQueueSendRequest2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpQueueSendResponse2(bc) {
+  return {
+    status: bare4.readString(bc),
+    response: read14(bc)
+  };
+}
+function writeHttpQueueSendResponse2(bc, x) {
+  bare4.writeString(bc, x.status);
+  write14(bc, x.response);
+}
+function encodeHttpQueueSendResponse2(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpQueueSendResponse2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendResponse2(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpQueueSendResponse2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResponseError4(bc) {
+  return {
+    group: bare4.readString(bc),
+    code: bare4.readString(bc),
+    message: bare4.readString(bc),
+    metadata: read14(bc),
+    actor: read32(bc)
+  };
+}
+function writeHttpResponseError4(bc, x) {
+  bare4.writeString(bc, x.group);
+  bare4.writeString(bc, x.code);
+  bare4.writeString(bc, x.message);
+  write14(bc, x.metadata);
+  write32(bc, x.actor);
+}
+function encodeHttpResponseError4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpResponseError4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResponseError4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpResponseError4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResolveResponse4(bc) {
+  return {
+    actorId: bare4.readString(bc)
+  };
+}
+function writeHttpResolveResponse4(bc, x) {
+  bare4.writeString(bc, x.actorId);
+}
+function encodeHttpResolveResponse4(x, config) {
+  const fullConfig = config != null ? bare4.Config(config) : DEFAULT_CONFIG4;
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(fullConfig.initialBufferLength),
+    fullConfig
+  );
+  writeHttpResolveResponse4(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResolveResponse4(bytes) {
+  const bc = new bare4.ByteCursor(bytes, DEFAULT_CONFIG4);
+  const result = readHttpResolveResponse4(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare4.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
 // src/common/client-protocol-versioned.ts
-var CURRENT_VERSION = 3;
+var CURRENT_VERSION = 4;
 var v1ToV2 = (v1Data) => {
   if (v1Data.body.tag === "Init") {
     const { actorId, connectionId } = v1Data.body.val;
@@ -1217,6 +1653,32 @@ var v2ToV1 = (v2Data) => {
 var v2ToV3 = (v2Data) => {
   return v2Data;
 };
+var v3ToV4 = (v3Data) => {
+  if (v3Data.body.tag === "Error") {
+    return {
+      body: {
+        tag: "Error",
+        val: {
+          ...v3Data.body.val,
+          actor: null
+        }
+      }
+    };
+  }
+  return v3Data;
+};
+var v4ToV3 = (v4Data) => {
+  if (v4Data.body.tag === "Error") {
+    const { actor: _, ...val } = v4Data.body.val;
+    return {
+      body: {
+        tag: "Error",
+        val
+      }
+    };
+  }
+  return v4Data;
+};
 var v3ToV2 = (v3Data) => {
   return v3Data;
 };
@@ -1226,12 +1688,26 @@ var v1ToServerV2 = (v1Data) => {
 var v2ToServerV3 = (v2Data) => {
   return v2Data;
 };
+var v3ToServerV4 = (v3Data) => {
+  return v3Data;
+};
+var v4ToServerV3 = (v4Data) => {
+  return v4Data;
+};
 var v3ToServerV2 = (v3Data) => {
   return v3Data;
 };
 var v2ToServerV1 = (v2Data) => {
   return v2Data;
 };
+var v3HttpResponseErrorToV4 = (v3Data) => ({
+  ...v3Data,
+  actor: null
+});
+var v4HttpResponseErrorToV3 = (v4Data) => {
+  const { actor: _, ...rest } = v4Data;
+  return rest;
+};
 var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
     switch (version) {
@@ -1241,6 +1717,8 @@ var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
         return decodeToServer2(bytes);
       case 3:
         return decodeToServer3(bytes);
+      case 4:
+        return decodeToServer4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1253,12 +1731,14 @@ var CLIENT_PROTOCOL_TO_SERVER = createVersionedDataHandler({
         return encodeToServer2(data);
       case 3:
         return encodeToServer3(data);
+      case 4:
+        return encodeToServer4(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
-  serializeConverters: () => [v3ToServerV2, v2ToServerV1]
+  deserializeConverters: () => [v1ToServerV2, v2ToServerV3, v3ToServerV4],
+  serializeConverters: () => [v4ToServerV3, v3ToServerV2, v2ToServerV1]
 });
 var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -1269,6 +1749,8 @@ var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
         return decodeToClient2(bytes);
       case 3:
         return decodeToClient3(bytes);
+      case 4:
+        return decodeToClient4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1281,12 +1763,14 @@ var CLIENT_PROTOCOL_TO_CLIENT = createVersionedDataHandler({
         return encodeToClient2(data);
       case 3:
         return encodeToClient3(data);
+      case 4:
+        return encodeToClient4(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToV2, v2ToV3],
-  serializeConverters: () => [v3ToV2, v2ToV1]
+  deserializeConverters: () => [v1ToV2, v2ToV3, v3ToV4],
+  serializeConverters: () => [v4ToV3, v3ToV2, v2ToV1]
 });
 var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -1297,6 +1781,8 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionRequest2(bytes);
       case 3:
         return decodeHttpActionRequest3(bytes);
+      case 4:
+        return decodeHttpActionRequest4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1315,6 +1801,10 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionRequest3(
           data
         );
+      case 4:
+        return encodeHttpActionRequest4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1331,6 +1821,8 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionResponse2(bytes);
       case 3:
         return decodeHttpActionResponse3(bytes);
+      case 4:
+        return decodeHttpActionResponse4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1349,6 +1841,10 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionResponse3(
           data
         );
+      case 4:
+        return encodeHttpActionResponse4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1361,6 +1857,8 @@ var HTTP_QUEUE_SEND_REQUEST_VERSIONED = createVersionedDataHandler({
     switch (version) {
       case 3:
         return decodeHttpQueueSendRequest(bytes);
+      case 4:
+        return decodeHttpQueueSendRequest2(bytes);
       default:
         throw new Error(
           `HttpQueueSendRequest only exists in version 3+, got version ${version}`
@@ -1373,6 +1871,10 @@ var HTTP_QUEUE_SEND_REQUEST_VERSIONED = createVersionedDataHandler({
         return encodeHttpQueueSendRequest(
           data
         );
+      case 4:
+        return encodeHttpQueueSendRequest2(
+          data
+        );
       default:
         throw new Error(
           `HttpQueueSendRequest only exists in version 3+, got version ${version}`
@@ -1387,6 +1889,8 @@ var HTTP_QUEUE_SEND_RESPONSE_VERSIONED = createVersionedDataHandler({
     switch (version) {
       case 3:
         return decodeHttpQueueSendResponse(bytes);
+      case 4:
+        return decodeHttpQueueSendResponse2(bytes);
       default:
         throw new Error(
           `HttpQueueSendResponse only exists in version 3+, got version ${version}`
@@ -1399,6 +1903,10 @@ var HTTP_QUEUE_SEND_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpQueueSendResponse(
           data
         );
+      case 4:
+        return encodeHttpQueueSendResponse2(
+          data
+        );
       default:
         throw new Error(
           `HttpQueueSendResponse only exists in version 3+, got version ${version}`
@@ -1417,6 +1925,8 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return decodeHttpResponseError2(bytes);
       case 3:
         return decodeHttpResponseError3(bytes);
+      case 4:
+        return decodeHttpResponseError4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1435,12 +1945,24 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return encodeHttpResponseError3(
           data
         );
+      case 4:
+        return encodeHttpResponseError4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [],
-  serializeConverters: () => []
+  deserializeConverters: () => [
+    (data) => data,
+    (data) => data,
+    v3HttpResponseErrorToV4
+  ],
+  serializeConverters: () => [
+    v4HttpResponseErrorToV3,
+    (data) => data,
+    (data) => data
+  ]
 });
 var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -1451,6 +1973,8 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpResolveResponse2(bytes);
       case 3:
         return decodeHttpResolveResponse3(bytes);
+      case 4:
+        return decodeHttpResolveResponse4(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1469,6 +1993,10 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpResolveResponse3(
           data
         );
+      case 4:
+        return encodeHttpResolveResponse4(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1481,6 +2009,11 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
 import { z } from "zod/v4";
 var UintSchema = z.bigint();
 var OptionalUintSchema = UintSchema.nullable();
+var ActorSpecifierSchema = z.object({
+  actorId: z.string(),
+  generation: z.union([z.number(), z.bigint()]),
+  key: z.string().optional()
+});
 var InitSchema = z.object({
   actorId: z.string(),
   connectionId: z.string()
@@ -1490,7 +2023,8 @@ var ErrorSchema = z.object({
   code: z.string(),
   message: z.string(),
   metadata: z.unknown().optional(),
-  actionId: OptionalUintSchema
+  actionId: OptionalUintSchema,
+  actor: ActorSpecifierSchema.optional()
 });
 var ActionResponseSchema = z.object({
   id: UintSchema,
@@ -1548,7 +2082,8 @@ var HttpResponseErrorSchema = z.object({
   group: z.string(),
   code: z.string(),
   message: z.string(),
-  metadata: z.unknown().optional()
+  metadata: z.unknown().optional(),
+  actor: ActorSpecifierSchema.optional()
 });
 var HttpResolveRequestSchema = z.null();
 var HttpResolveResponseSchema = z.object({
@@ -1842,6 +2377,7 @@ function messageLength(message) {
   assertUnreachable(message);
 }
 async function sendHttpRequest(opts) {
+  var _a, _b, _c;
   logger().debug({
     msg: "sending http request",
     url: opts.url,
@@ -1895,21 +2431,45 @@ async function sendHttpRequest(opts) {
         new Uint8Array(bufferResponse),
         HTTP_RESPONSE_ERROR_VERSIONED,
         HttpResponseErrorSchema,
-        // JSON: metadata is already unknown
-        (json) => json,
+        // JSON/CBOR: normalize actor generation to the public number shape.
+        (json) => ({
+          ...json,
+          actor: json.actor ? {
+            ...json.actor,
+            generation: Number(json.actor.generation)
+          } : void 0
+        }),
         // BARE: decode ArrayBuffer metadata to unknown
-        (bare4) => ({
-          group: bare4.group,
-          code: bare4.code,
-          message: bare4.message,
-          metadata: bare4.metadata ? decodeCborCompat(new Uint8Array(bare4.metadata)) : void 0
+        (bare5) => ({
+          group: bare5.group,
+          code: bare5.code,
+          message: bare5.message,
+          metadata: bare5.metadata ? decodeCborCompat(new Uint8Array(bare5.metadata)) : void 0,
+          actor: bare5.actor ? {
+            actorId: bare5.actor.actorId,
+            generation: Number(bare5.actor.generation),
+            key: bare5.actor.key ?? void 0
+          } : void 0
         })
       );
+      logger().warn({
+        msg: "http error response",
+        group: responseData.group,
+        code: responseData.code,
+        message: responseData.message,
+        metadata: responseData.metadata,
+        actorId: (_a = responseData.actor) == null ? void 0 : _a.actorId,
+        generation: (_b = responseData.actor) == null ? void 0 : _b.generation,
+        actorKey: (_c = responseData.actor) == null ? void 0 : _c.key
+      });
       throw new RivetError(
         responseData.group,
         responseData.code,
         responseData.message,
-        responseData.metadata
+        {
+          metadata: responseData.metadata,
+          actor: responseData.actor
+        }
       );
     } catch (error) {
       if (error instanceof RivetError) {
@@ -1996,13 +2556,13 @@ function createQueueSender(senderOptions) {
           response: json.response
         };
       },
-      responseFromBare: (bare4) => {
-        if (bare4.response === null || bare4.response === void 0) {
-          return { status: bare4.status };
+      responseFromBare: (bare5) => {
+        if (bare5.response === null || bare5.response === void 0) {
+          return { status: bare5.status };
         }
         return {
-          status: bare4.status,
-          response: decodeCborCompat(new Uint8Array(bare4.response))
+          status: bare5.status,
+          response: decodeCborCompat(new Uint8Array(bare5.response))
         };
       }
     });
@@ -2077,13 +2637,11 @@ async function rawHttpFetch(driver, target, params, input, init, options = {}) {
     });
     return driver.sendRequest(target, proxyRequest, options);
   } catch (err) {
-    const { group, code, message, metadata } = deconstructError(
+    const { group, code, message, metadata, actor } = deconstructError(
       err,
-      logger(),
-      {},
       true
     );
-    throw new RivetError(group, code, message, metadata);
+    throw new RivetError(group, code, message, { metadata, actor });
   }
 }
 async function rawWebSocket(driver, target, params, path, _protocols, options = {}) {
@@ -2204,7 +2762,13 @@ var ActorHandleRaw = class {
       for (let attempt = 0; attempt < maxAttempts; attempt++) {
         let actorId;
         try {
-          const target = await this.#resolveActionTarget(useQueryTarget);
+          const gatewayOptions = resolveActorGatewayOptions(
+            this.#gatewayOptions
+          );
+          const target = await this.#resolveGatewayRequestTarget(
+            useQueryTarget,
+            gatewayOptions
+          );
           actorId = "directId" in target ? target.directId : void 0;
           return await createQueueSender({
             encoding: this.#encoding,
@@ -2213,17 +2777,13 @@ var ActorHandleRaw = class {
               return await this.#driver.sendRequest(
                 target,
                 request,
-                resolveActorGatewayOptions(
-                  this.#gatewayOptions
-                )
+                gatewayOptions
               );
             }
           }).send(name, body, options);
         } catch (err) {
-          const { group, code, message, metadata } = deconstructError(
+          const { group, code, message, metadata, actor } = deconstructError(
             err,
-            logger(),
-            {},
             true
           );
           if (this.#shouldRetryQueueDispatchOverload(
@@ -2266,7 +2826,7 @@ var ActorHandleRaw = class {
             }
             continue;
           }
-          throw new RivetError(group, code, message, metadata);
+          throw new RivetError(group, code, message, { metadata, actor });
         }
       }
       throw new Error("unreachable queue retry state");
@@ -2301,7 +2861,10 @@ var ActorHandleRaw = class {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       let actorId;
       try {
-        const target = await this.#resolveActionTarget(useQueryTarget);
+        const target = await this.#resolveGatewayRequestTarget(
+          useQueryTarget,
+          gatewayOptions
+        );
         actorId = "directId" in target ? target.directId : void 0;
         logger().debug(
           actorId ? { msg: "using direct actor gateway target", actorId } : {
@@ -2346,17 +2909,15 @@ var ActorHandleRaw = class {
             args: bufferToArrayBuffer(encodeCborCompat(args))
           }),
           responseFromJson: (json) => json.output,
-          responseFromBare: (bare4) => decodeCborCompat(new Uint8Array(bare4.output))
+          responseFromBare: (bare5) => decodeCborCompat(new Uint8Array(bare5.output))
         });
         if (opts.name === "destroy" && actorId) {
           await this.#waitForDestroyActionToSettle(actorId);
         }
         return output;
       } catch (err) {
-        const { group, code, message, metadata } = deconstructError(
+        const { group, code, message, metadata, actor } = deconstructError(
           err,
-          logger(),
-          {},
           true
         );
         if (await this.#shouldRetrySchedulingError(
@@ -2386,7 +2947,7 @@ var ActorHandleRaw = class {
             "actor",
             "not_found",
             "The actor does not exist or was destroyed.",
-            metadata
+            { metadata, actor }
           );
         }
         const invalidated = this.#invalidateResolvedActorId(group, code);
@@ -2397,7 +2958,7 @@ var ActorHandleRaw = class {
           }
           continue;
         }
-        throw new RivetError(group, code, message, metadata);
+        throw new RivetError(group, code, message, { metadata, actor });
       }
     }
     throw new Error("unreachable action retry state");
@@ -2490,6 +3051,12 @@ var ActorHandleRaw = class {
       this.#resolvingActorId = void 0;
     }
   }
+  async #resolveGatewayRequestTarget(useQueryTarget, gatewayOptions) {
+    if (gatewayOptions.skipReadyWait) {
+      return getGatewayTarget(this.#actorResolutionState);
+    }
+    return await this.#resolveActionTarget(useQueryTarget);
+  }
   /**
    * Establishes a persistent connection to the actor.
    *
@@ -2536,7 +3103,10 @@ var ActorHandleRaw = class {
     for (let attempt = 0; attempt < maxAttempts; attempt++) {
       let actorId;
       try {
-        const target = await this.#resolveActionTarget(useQueryTarget);
+        const target = await this.#resolveGatewayRequestTarget(
+          useQueryTarget,
+          gatewayOptions
+        );
         actorId = "directId" in target ? target.directId : void 0;
         const response = await rawHttpFetch(
           this.#driver,
@@ -2561,10 +3131,8 @@ var ActorHandleRaw = class {
         }
         return response;
       } catch (err) {
-        const { group, code, message, metadata } = deconstructError(
+        const { group, code, message, metadata, actor } = deconstructError(
           err,
-          logger(),
-          {},
           true
         );
         if (await this.#shouldRetrySchedulingError(
@@ -2597,7 +3165,7 @@ var ActorHandleRaw = class {
           }
           continue;
         }
-        throw new RivetError(group, code, message, metadata);
+        throw new RivetError(group, code, message, { metadata, actor });
       }
     }
     throw new Error("unreachable fetch retry state");
@@ -2657,12 +3225,23 @@ var ActorHandleRaw = class {
         new Uint8Array(await response.clone().arrayBuffer()),
         HTTP_RESPONSE_ERROR_VERSIONED,
         HttpResponseErrorSchema,
-        (json) => json,
-        (bare4) => ({
-          group: bare4.group,
-          code: bare4.code,
-          message: bare4.message,
-          metadata: bare4.metadata ? decodeCborCompat(new Uint8Array(bare4.metadata)) : void 0
+        (json) => ({
+          ...json,
+          actor: json.actor ? {
+            ...json.actor,
+            generation: Number(json.actor.generation)
+          } : void 0
+        }),
+        (bare5) => ({
+          group: bare5.group,
+          code: bare5.code,
+          message: bare5.message,
+          metadata: bare5.metadata ? decodeCborCompat(new Uint8Array(bare5.metadata)) : void 0,
+          actor: bare5.actor ? {
+            actorId: bare5.actor.actorId,
+            generation: Number(bare5.actor.generation),
+            key: bare5.actor.key ?? void 0
+          } : void 0
         })
       );
     } catch {
@@ -2678,7 +3257,10 @@ var ActorHandleRaw = class {
       this.#gatewayOptions,
       options
     );
-    const target = gatewayOptions.skipReadyWait ? await this.#resolveActionTarget(false) : getGatewayTarget(this.#actorResolutionState);
+    const target = await this.#resolveGatewayRequestTarget(
+      false,
+      gatewayOptions
+    );
     return await rawWebSocket(
       this.#driver,
       target,
@@ -3064,6 +3646,9 @@ var ActorConnRaw = class {
     this.#encoding = encoding;
     this.#actorResolutionState = actorResolutionState;
     this.#gatewayOptions = resolveActorGatewayOptions(gatewayOptions);
+    if ("getForId" in actorResolutionState) {
+      this.#actorId = actorResolutionState.getForId.actorId;
+    }
     this.#readyPromise = promiseWithResolvers(
       (reason) => logger().warn({
         msg: "unhandled ready promise rejection",
@@ -3314,7 +3899,7 @@ var ActorConnRaw = class {
   }
   async #connectWebSocket() {
     const params = await this.#resolveConnectionParams();
-    const target = this.#gatewayOptions.skipReadyWait ? await this.#resolveGatewayTargetForSkipReadyWait() : getGatewayTarget(this.#actorResolutionState);
+    const target = getGatewayTarget(this.#actorResolutionState);
     const ws = await this.#driver.openWebSocket(
       PATH_CONNECT,
       target,
@@ -3367,22 +3952,6 @@ var ActorConnRaw = class {
       }
     });
   }
-  async #resolveGatewayTargetForSkipReadyWait() {
-    if ("getForId" in this.#actorResolutionState) {
-      return {
-        directId: this.#actorResolutionState.getForId.actorId
-      };
-    }
-    if (this.#actorId) {
-      return { directId: this.#actorId };
-    }
-    return {
-      directId: await resolveGatewayTarget(
-        this.#driver,
-        this.#actorResolutionState
-      )
-    };
-  }
   /** Called by the onopen event from drivers. */
   #handleOnOpen() {
     if (this.#disposed) {
@@ -3462,7 +4031,7 @@ var ActorConnRaw = class {
       });
       this.#handleOnOpen();
     } else if (response.body.tag === "Error") {
-      const { group, code, message, metadata, actionId } = response.body.val;
+      const { group, code, message, metadata, actionId, actor } = response.body.val;
       if (actionId !== null) {
         const inFlight = this.#takeActionInFlight(Number(actionId));
         this.#invalidateActorIfStale(group, code);
@@ -3473,10 +4042,16 @@ var ActorConnRaw = class {
           group,
           code,
           message,
-          metadata
+          metadata,
+          actorId: actor == null ? void 0 : actor.actorId,
+          generation: actor == null ? void 0 : actor.generation,
+          actorKey: actor == null ? void 0 : actor.key
         });
         inFlight.reject(
-          new RivetError(group, code, message, metadata)
+          new RivetError(group, code, message, {
+            metadata,
+            actor
+          })
         );
       } else {
         logger().warn({
@@ -3484,12 +4059,18 @@ var ActorConnRaw = class {
           group,
           code,
           message,
-          metadata
+          metadata,
+          actorId: actor == null ? void 0 : actor.actorId,
+          generation: actor == null ? void 0 : actor.generation,
+          actorKey: actor == null ? void 0 : actor.key
         });
         if (this.#shouldReconnectForStaleActor(group, code)) {
           this.#clearResolvedActorIdentity();
           (_a = this.#onOpenPromise) == null ? void 0 : _a.reject(
-            new RivetError(group, code, message, metadata)
+            new RivetError(group, code, message, {
+              metadata,
+              actor
+            })
           );
           return;
         }
@@ -3497,7 +4078,7 @@ var ActorConnRaw = class {
           group,
           code,
           message,
-          metadata
+          { metadata, actor }
         );
         if (isSchedulingError(group, code) && this.#actorId) {
           const schedulingError = await checkForSchedulingError(
@@ -3963,8 +4544,26 @@ var ActorConnRaw = class {
       buffer,
       CLIENT_PROTOCOL_TO_CLIENT,
       ToClientSchema,
-      // JSON: values are already the correct type
-      (msg) => msg,
+      // JSON/CBOR: normalize actor generation to the public number shape.
+      (msg) => {
+        if (msg.body.tag !== "Error" || !msg.body.val.actor) {
+          return msg;
+        }
+        return {
+          body: {
+            tag: "Error",
+            val: {
+              ...msg.body.val,
+              actor: {
+                ...msg.body.val.actor,
+                generation: Number(
+                  msg.body.val.actor.generation
+                )
+              }
+            }
+          }
+        };
+      },
       // BARE: need to decode ArrayBuffer fields back to unknown
       (msg) => {
         if (msg.body.tag === "Error") {
@@ -3980,7 +4579,14 @@ var ActorConnRaw = class {
                     msg.body.val.metadata
                   )
                 ) : null,
-                actionId: msg.body.val.actionId
+                actionId: msg.body.val.actionId,
+                actor: msg.body.val.actor ? {
+                  actorId: msg.body.val.actor.actorId,
+                  generation: Number(
+                    msg.body.val.actor.generation
+                  ),
+                  key: msg.body.val.actor.key ?? void 0
+                } : void 0
               }
             }
           };
@@ -5250,12 +5856,8 @@ function apiActorToOutput(actor) {
 }
 
 export {
-  HEADER_ENCODING,
   HEADER_CONN_PARAMS,
   ALLOWED_PUBLIC_HEADERS,
-  CURRENT_VERSION,
-  HTTP_RESPONSE_ERROR_VERSIONED,
-  HttpResponseErrorSchema,
   ActorClientError,
   ManagerError,
   MalformedResponseMessage,
@@ -5271,4 +5873,4 @@ export {
   updateRunnerConfig,
   RemoteEngineControlClient
 };
-//# sourceMappingURL=chunk-JY73X7VU.js.map
+//# sourceMappingURL=chunk-FLODVLYW.js.map