rivetkit 2.0.27 → 2.0.28

package/dist/tsup/{chunk-BBTOBXEO.js → chunk-KXSSOVFA.js}

@@ -3,18 +3,18 @@ import {
   ForeignKeysSchema,
   PatchSchema,
   TablesSchema
-} from "./chunk-6F2NCX7R.js";
+} from "./chunk-AE7BB3M2.js";
 import {
   importWebSocket,
   logger
-} from "./chunk-D7A47BVR.js";
+} from "./chunk-7IAEY5UZ.js";
 import {
   ACTOR_VERSIONED,
   CONN_VERSIONED,
+  CURRENT_VERSION,
   KEYS,
-  createVersionedDataHandler,
   makeConnKey
-} from "./chunk-5YDKTW6Y.js";
+} from "./chunk-DATRTJVZ.js";
 import {
   CachedSerializer,
   DeadlineError,
@@ -37,7 +37,7 @@ import {
   jsonStringifyCompat,
   serializeWithEncoding,
   uint8ArrayToBase64
-} from "./chunk-C3UREFUI.js";
+} from "./chunk-EJXISR3H.js";
 import {
   EXTRA_ERROR_LOG,
   SinglePromiseQueue,
@@ -55,7 +55,7 @@ import {
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-KSQQU7NC.js";
+} from "./chunk-S5URQ3CI.js";
 import {
   ActionNotFound,
   ActionTimedOut,
@@ -344,18 +344,23 @@ function createHttpDriver() {
 // src/actor/conn/mod.ts
 import * as cbor from "cbor-x";
 
-// dist/schemas/client-protocol/v2.ts
+// src/schemas/client-protocol/versioned.ts
+import { createVersionedDataHandler } from "vbare";
+
+// dist/schemas/client-protocol/v1.ts
 import * as bare from "@bare-ts/lib";
 var config = /* @__PURE__ */ bare.Config({});
 function readInit(bc) {
   return {
     actorId: bare.readString(bc),
-    connectionId: bare.readString(bc)
+    connectionId: bare.readString(bc),
+    connectionToken: bare.readString(bc)
   };
 }
 function writeInit(bc, x) {
   bare.writeString(bc, x.actorId);
   bare.writeString(bc, x.connectionId);
+  bare.writeString(bc, x.connectionToken);
 }
 function read0(bc) {
   return bare.readBool(bc) ? bare.readData(bc) : null;
@@ -654,10 +659,319 @@ function decodeHttpResolveResponse(bytes) {
   return result;
 }
 
+// dist/schemas/client-protocol/v2.ts
+import * as bare2 from "@bare-ts/lib";
+var config2 = /* @__PURE__ */ bare2.Config({});
+function readInit2(bc) {
+  return {
+    actorId: bare2.readString(bc),
+    connectionId: bare2.readString(bc)
+  };
+}
+function writeInit2(bc, x) {
+  bare2.writeString(bc, x.actorId);
+  bare2.writeString(bc, x.connectionId);
+}
+function read02(bc) {
+  return bare2.readBool(bc) ? bare2.readData(bc) : null;
+}
+function write02(bc, x) {
+  bare2.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare2.writeData(bc, x);
+  }
+}
+function read12(bc) {
+  return bare2.readBool(bc) ? bare2.readUint(bc) : null;
+}
+function write12(bc, x) {
+  bare2.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare2.writeUint(bc, x);
+  }
+}
+function readError2(bc) {
+  return {
+    group: bare2.readString(bc),
+    code: bare2.readString(bc),
+    message: bare2.readString(bc),
+    metadata: read02(bc),
+    actionId: read12(bc)
+  };
+}
+function writeError2(bc, x) {
+  bare2.writeString(bc, x.group);
+  bare2.writeString(bc, x.code);
+  bare2.writeString(bc, x.message);
+  write02(bc, x.metadata);
+  write12(bc, x.actionId);
+}
+function readActionResponse2(bc) {
+  return {
+    id: bare2.readUint(bc),
+    output: bare2.readData(bc)
+  };
+}
+function writeActionResponse2(bc, x) {
+  bare2.writeUint(bc, x.id);
+  bare2.writeData(bc, x.output);
+}
+function readEvent2(bc) {
+  return {
+    name: bare2.readString(bc),
+    args: bare2.readData(bc)
+  };
+}
+function writeEvent2(bc, x) {
+  bare2.writeString(bc, x.name);
+  bare2.writeData(bc, x.args);
+}
+function readToClientBody2(bc) {
+  const offset = bc.offset;
+  const tag = bare2.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "Init", val: readInit2(bc) };
+    case 1:
+      return { tag: "Error", val: readError2(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse2(bc) };
+    case 3:
+      return { tag: "Event", val: readEvent2(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare2.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody2(bc, x) {
+  switch (x.tag) {
+    case "Init": {
+      bare2.writeU8(bc, 0);
+      writeInit2(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare2.writeU8(bc, 1);
+      writeError2(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare2.writeU8(bc, 2);
+      writeActionResponse2(bc, x.val);
+      break;
+    }
+    case "Event": {
+      bare2.writeU8(bc, 3);
+      writeEvent2(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient2(bc) {
+  return {
+    body: readToClientBody2(bc)
+  };
+}
+function writeToClient2(bc, x) {
+  writeToClientBody2(bc, x.body);
+}
+function encodeToClient2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeToClient2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readToClient2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActionRequest2(bc) {
+  return {
+    id: bare2.readUint(bc),
+    name: bare2.readString(bc),
+    args: bare2.readData(bc)
+  };
+}
+function writeActionRequest2(bc, x) {
+  bare2.writeUint(bc, x.id);
+  bare2.writeString(bc, x.name);
+  bare2.writeData(bc, x.args);
+}
+function readSubscriptionRequest2(bc) {
+  return {
+    eventName: bare2.readString(bc),
+    subscribe: bare2.readBool(bc)
+  };
+}
+function writeSubscriptionRequest2(bc, x) {
+  bare2.writeString(bc, x.eventName);
+  bare2.writeBool(bc, x.subscribe);
+}
+function readToServerBody2(bc) {
+  const offset = bc.offset;
+  const tag = bare2.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActionRequest", val: readActionRequest2(bc) };
+    case 1:
+      return { tag: "SubscriptionRequest", val: readSubscriptionRequest2(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare2.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody2(bc, x) {
+  switch (x.tag) {
+    case "ActionRequest": {
+      bare2.writeU8(bc, 0);
+      writeActionRequest2(bc, x.val);
+      break;
+    }
+    case "SubscriptionRequest": {
+      bare2.writeU8(bc, 1);
+      writeSubscriptionRequest2(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer2(bc) {
+  return {
+    body: readToServerBody2(bc)
+  };
+}
+function writeToServer2(bc, x) {
+  writeToServerBody2(bc, x.body);
+}
+function encodeToServer2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeToServer2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readToServer2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionRequest2(bc) {
+  return {
+    args: bare2.readData(bc)
+  };
+}
+function writeHttpActionRequest2(bc, x) {
+  bare2.writeData(bc, x.args);
+}
+function encodeHttpActionRequest2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeHttpActionRequest2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionRequest2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readHttpActionRequest2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionResponse2(bc) {
+  return {
+    output: bare2.readData(bc)
+  };
+}
+function writeHttpActionResponse2(bc, x) {
+  bare2.writeData(bc, x.output);
+}
+function encodeHttpActionResponse2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeHttpActionResponse2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionResponse2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readHttpActionResponse2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResponseError2(bc) {
+  return {
+    group: bare2.readString(bc),
+    code: bare2.readString(bc),
+    message: bare2.readString(bc),
+    metadata: read02(bc)
+  };
+}
+function writeHttpResponseError2(bc, x) {
+  bare2.writeString(bc, x.group);
+  bare2.writeString(bc, x.code);
+  bare2.writeString(bc, x.message);
+  write02(bc, x.metadata);
+}
+function encodeHttpResponseError2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeHttpResponseError2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResponseError2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readHttpResponseError2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResolveResponse2(bc) {
+  return {
+    actorId: bare2.readString(bc)
+  };
+}
+function writeHttpResolveResponse2(bc, x) {
+  bare2.writeString(bc, x.actorId);
+}
+function encodeHttpResolveResponse2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeHttpResolveResponse2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResolveResponse2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readHttpResolveResponse2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
 // src/schemas/client-protocol/versioned.ts
-var CURRENT_VERSION = 2;
-var migrations = /* @__PURE__ */ new Map();
-migrations.set(1, (v1Data) => {
+var CURRENT_VERSION2 = 2;
+var v1ToV2 = (v1Data) => {
   if (v1Data.body.tag === "Init") {
     const { actorId, connectionId } = v1Data.body.val;
     return {
@@ -671,48 +985,183 @@ migrations.set(1, (v1Data) => {
     };
   }
   return v1Data;
-});
+};
+var v2ToV1 = (v2Data) => {
+  if (v2Data.body.tag === "Init") {
+    const { actorId, connectionId } = v2Data.body.val;
+    return {
+      body: {
+        tag: "Init",
+        val: {
+          actorId,
+          connectionId,
+          connectionToken: ""
+          // Add empty connectionToken for v1 compatibility
+        }
+      }
+    };
+  }
+  return v2Data;
+};
 var TO_SERVER_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeToServer(data),
-  deserializeVersion: (bytes) => decodeToServer(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeToServer(bytes);
+      case 2:
+        return decodeToServer2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeToServer(data);
+      case 2:
+        return encodeToServer2(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [v1ToV2],
+  serializeConverters: () => [v2ToV1]
 });
 var TO_CLIENT_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeToClient(data),
-  deserializeVersion: (bytes) => decodeToClient(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeToClient(bytes);
+      case 2:
+        return decodeToClient2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeToClient(data);
+      case 2:
+        return encodeToClient2(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [v1ToV2],
+  serializeConverters: () => [v2ToV1]
 });
 var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeHttpActionRequest(data),
-  deserializeVersion: (bytes) => decodeHttpActionRequest(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeHttpActionRequest(bytes);
+      case 2:
+        return decodeHttpActionRequest2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeHttpActionRequest(
+          data
+        );
+      case 2:
+        return encodeHttpActionRequest2(
+          data
+        );
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
 });
 var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeHttpActionResponse(data),
-  deserializeVersion: (bytes) => decodeHttpActionResponse(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeHttpActionResponse(bytes);
+      case 2:
+        return decodeHttpActionResponse2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeHttpActionResponse(
+          data
+        );
+      case 2:
+        return encodeHttpActionResponse2(
+          data
+        );
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
 });
 var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeHttpResponseError(data),
-  deserializeVersion: (bytes) => decodeHttpResponseError(bytes)
-});
-var HTTP_RESOLVE_REQUEST_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (_) => new Uint8Array(),
-  deserializeVersion: (bytes) => null
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeHttpResponseError(bytes);
+      case 2:
+        return decodeHttpResponseError2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeHttpResponseError(
+          data
+        );
+      case 2:
+        return encodeHttpResponseError2(
+          data
+        );
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
 });
 var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeHttpResolveResponse(data),
-  deserializeVersion: (bytes) => decodeHttpResolveResponse(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeHttpResolveResponse(bytes);
+      case 2:
+        return decodeHttpResolveResponse2(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeHttpResolveResponse(
+          data
+        );
+      case 2:
+        return encodeHttpResolveResponse2(
+          data
+        );
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
 });
 
 // src/schemas/client-protocol-zod/mod.ts
@@ -1044,6 +1493,7 @@ var Conn = class {
       new CachedSerializer(
         eventData,
         TO_CLIENT_VERSIONED,
+        CURRENT_VERSION2,
         ToClientSchema,
         // JSON: args is the raw value (array of arguments)
         (value) => ({
@@ -1404,22 +1854,22 @@ async function parseMessage(value, opts) {
     // JSON: values are already the correct type
     (json) => json,
     // BARE: need to decode ArrayBuffer fields back to unknown
-    (bare2) => {
-      if (bare2.body.tag === "ActionRequest") {
+    (bare3) => {
+      if (bare3.body.tag === "ActionRequest") {
         return {
           body: {
             tag: "ActionRequest",
             val: {
-              id: bare2.body.val.id,
-              name: bare2.body.val.name,
+              id: bare3.body.val.id,
+              name: bare3.body.val.name,
               args: cbor3.decode(
-                new Uint8Array(bare2.body.val.args)
+                new Uint8Array(bare3.body.val.args)
               )
             }
           }
         };
       } else {
-        return bare2;
+        return bare3;
       }
     }
   );
@@ -1457,6 +1907,7 @@ async function processMessage(message, actor, conn, handler) {
         new CachedSerializer(
           output,
           TO_CLIENT_VERSIONED,
+          CURRENT_VERSION2,
           ToClientSchema,
           // JSON: output is the raw value
           (value) => ({
@@ -1526,6 +1977,7 @@ async function processMessage(message, actor, conn, handler) {
       new CachedSerializer(
         errorData,
         TO_CLIENT_VERSIONED,
+        CURRENT_VERSION2,
         ToClientSchema,
         // JSON: metadata is the raw value (keep as undefined if not present)
         (value) => {
@@ -1727,6 +2179,7 @@ var ConnectionManager = class {
         new CachedSerializer(
           initData,
           TO_CLIENT_VERSIONED,
+          CURRENT_VERSION2,
           ToClientSchema,
           // JSON: identity conversion (no nested data to encode)
           (value) => ({
@@ -2040,6 +2493,7 @@ var EventManager = class {
     const toClientSerializer = new CachedSerializer(
       eventData,
       TO_CLIENT_VERSIONED,
+      CURRENT_VERSION2,
       ToClientSchema,
       // JSON: args is the raw value (array of arguments)
       (value) => ({
@@ -2184,10 +2638,10 @@ var ScheduleManager = class {
   // ActorConfig type
   #persist;
   // Reference to PersistedActor
-  constructor(actor, actorDriver, config2) {
+  constructor(actor, actorDriver, config3) {
     this.#actor = actor;
     this.#actorDriver = actorDriver;
-    this.#config = config2;
+    this.#config = config3;
   }
   // MARK: - Public API
   /**
@@ -2465,11 +2919,11 @@ var StateManager2 = class {
   #config;
   // ActorConfig type
   #stateSaveInterval;
-  constructor(actor, actorDriver, config2) {
+  constructor(actor, actorDriver, config3) {
     this.#actor = actor;
     this.#actorDriver = actorDriver;
-    this.#config = config2;
-    this.#stateSaveInterval = config2.options.stateSaveInterval || 100;
+    this.#config = config3;
+    this.#stateSaveInterval = config3.options.stateSaveInterval || 100;
   }
   // MARK: - Public API
   get persist() {
@@ -2522,7 +2976,10 @@ var StateManager2 = class {
       await this.#actorDriver.kvBatchPut(this.#actor.id, [
         [
           KEYS.PERSIST_DATA,
-          ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData)
+          ACTOR_VERSIONED.serializeWithEmbeddedVersion(
+            bareData,
+            CURRENT_VERSION
+          )
         ]
       ]);
     }
@@ -2607,10 +3064,20 @@ var StateManager2 = class {
       this.#pendingSaveTimeout = setTimeout(() => {
         this.#pendingSaveTimeout = void 0;
         this.#pendingSaveScheduledTimestamp = void 0;
-        this.#savePersistInner();
+        this.#savePersistInner().catch((error) => {
+          this.#actor.rLog.error({
+            msg: "error saving persist data in scheduled save",
+            error: stringifyError(error)
+          });
+        });
       }, saveDelay);
     } else {
-      this.#savePersistInner();
+      this.#savePersistInner().catch((error) => {
+        this.#actor.rLog.error({
+          msg: "error saving persist data immediately",
+          error: stringifyError(error)
+        });
+      });
     }
   }
   /**
@@ -2711,7 +3178,8 @@ var StateManager2 = class {
             entries.push([
               KEYS.PERSIST_DATA,
               ACTOR_VERSIONED.serializeWithEmbeddedVersion(
-                bareData
+                bareData,
+                CURRENT_VERSION
               )
             ]);
           }
@@ -2747,7 +3215,8 @@ var StateManager2 = class {
               hibernatableDataRaw
             );
             const connData = CONN_VERSIONED.serializeWithEmbeddedVersion(
-              bareData
+              bareData,
+              CURRENT_VERSION
             );
             entries.push([makeConnKey(connId), connData]);
             connections.push(conn);
@@ -2921,8 +3390,8 @@ var ActorInstance = class {
     };
   });
   // MARK: - Constructor
-  constructor(config2) {
-    this.#config = config2;
+  constructor(config3) {
+    this.#config = config3;
     this.actorContext = new ActorContext(this);
   }
   // MARK: - Public Getters
@@ -3605,8 +4074,8 @@ var ActorInstance = class {
 // src/actor/definition.ts
 var ActorDefinition = class {
   #config;
-  constructor(config2) {
-    this.#config = config2;
+  constructor(config3) {
+    this.#config = config3;
   }
   get config() {
     return this.#config;
@@ -3846,6 +4315,7 @@ async function sendHttpRequest(opts) {
       opts.encoding,
       opts.body,
       opts.requestVersionedDataHandler,
+      opts.requestVersion,
       opts.requestZodSchema,
       opts.requestToJson,
       opts.requestToBare
@@ -3887,11 +4357,11 @@ async function sendHttpRequest(opts) {
         // JSON: metadata is already unknown
         (json) => json,
         // BARE: decode ArrayBuffer metadata to unknown
-        (bare2) => ({
-          group: bare2.group,
-          code: bare2.code,
-          message: bare2.message,
-          metadata: bare2.metadata ? cbor7.decode(new Uint8Array(bare2.metadata)) : void 0
+        (bare3) => ({
+          group: bare3.group,
+          code: bare3.code,
+          message: bare3.message,
+          metadata: bare3.metadata ? cbor7.decode(new Uint8Array(bare3.metadata)) : void 0
         })
       );
       throw new ActorError(
@@ -3996,7 +4466,9 @@ var ActorHandleRaw = class {
           actorId
         ),
         signal: opts == null ? void 0 : opts.signal,
+        requestVersion: CURRENT_VERSION2,
         requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
+        responseVersion: CURRENT_VERSION2,
         responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,
         requestZodSchema: HttpActionRequestSchema,
         responseZodSchema: HttpActionResponseSchema,
@@ -4011,7 +4483,7 @@ var ActorHandleRaw = class {
         // JSON Response: output is the raw value
         responseFromJson: (json) => json.output,
         // BARE Response: output is ArrayBuffer that needs CBOR-decoding
-        responseFromBare: (bare2) => cbor8.decode(new Uint8Array(bare2.output))
+        responseFromBare: (bare3) => cbor8.decode(new Uint8Array(bare3.output))
       });
       return responseData;
     } catch (err) {
@@ -4121,9 +4593,9 @@ var ClientRaw = class {
   /**
    * Creates an instance of Client.
    */
-  constructor(driver, config2) {
+  constructor(driver, config3) {
     this.#driver = driver;
-    this.#encodingKind = config2.encoding ?? "bare";
+    this.#encodingKind = config3.encoding ?? "bare";
   }
   /**
    * Gets a stateless handle to a actor by its ID.
@@ -4286,8 +4758,8 @@ var ClientRaw = class {
     await Promise.all(disposePromises);
   }
 };
-function createClientWithDriver(driver, config2) {
-  const client = new ClientRaw(driver, config2);
+function createClientWithDriver(driver, config3) {
+  const client = new ClientRaw(driver, config3);
   return new Proxy(client, {
     get: (target, prop, receiver) => {
       if (typeof prop === "symbol" || prop in target) {
@@ -4867,6 +5339,7 @@ var ActorConnRaw = class {
             this.#encoding,
             message,
             TO_SERVER_VERSIONED,
+            CURRENT_VERSION2,
             ToServerSchema,
             // JSON: args is the raw value
             (msg) => msg,
@@ -5067,20 +5540,20 @@ var EngineApiError = class extends Error {
     this.name = "EngineApiError";
   }
 };
-function getEndpoint(config2) {
-  return config2.endpoint ?? "http://127.0.0.1:6420";
+function getEndpoint(config3) {
+  return config3.endpoint ?? "http://127.0.0.1:6420";
 }
-async function apiCall(config2, method, path, body) {
-  const endpoint = getEndpoint(config2);
+async function apiCall(config3, method, path, body) {
+  const endpoint = getEndpoint(config3);
   const url = combineUrlPath(endpoint, path, {
-    namespace: config2.namespace
+    namespace: config3.namespace
   });
   logger2().debug({ msg: "making api call", method, url });
   const headers = {
-    ...config2.headers
+    ...config3.headers
   };
-  if (config2.token) {
-    headers.Authorization = `Bearer ${config2.token}`;
+  if (config3.token) {
+    headers.Authorization = `Bearer ${config3.token}`;
   }
   return await sendHttpRequest({
     method,
@@ -5090,7 +5563,9 @@ async function apiCall(config2, method, path, body) {
     encoding: "json",
     skipParseResponse: false,
     requestVersionedDataHandler: void 0,
+    requestVersion: void 0,
     responseVersionedDataHandler: void 0,
+    responseVersion: void 0,
     requestZodSchema: z3.any(),
     responseZodSchema: z3.any(),
     // Identity conversions (passthrough for generic API calls)
@@ -5183,60 +5658,60 @@ function buildWebSocketProtocols(runConfig, encoding, params) {
 }
 
 // src/remote-manager-driver/api-endpoints.ts
-async function getActor(config2, _, actorId) {
+async function getActor(config3, _, actorId) {
   return apiCall(
-    config2,
+    config3,
     "GET",
     `/actors?actor_ids=${encodeURIComponent(actorId)}`
   );
 }
-async function getActorByKey(config2, name, key) {
+async function getActorByKey(config3, name, key) {
   const serializedKey = serializeActorKey(key);
   return apiCall(
-    config2,
+    config3,
     "GET",
     `/actors?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
   );
 }
-async function listActorsByName(config2, name) {
+async function listActorsByName(config3, name) {
   return apiCall(
-    config2,
+    config3,
     "GET",
     `/actors?name=${encodeURIComponent(name)}`
   );
 }
-async function getOrCreateActor(config2, request) {
+async function getOrCreateActor(config3, request) {
   return apiCall(
-    config2,
+    config3,
     "PUT",
     `/actors`,
     request
   );
 }
-async function createActor(config2, request) {
+async function createActor(config3, request) {
   return apiCall(
-    config2,
+    config3,
     "POST",
     `/actors`,
     request
   );
 }
-async function destroyActor(config2, actorId) {
+async function destroyActor(config3, actorId) {
   return apiCall(
-    config2,
+    config3,
     "DELETE",
     `/actors/${encodeURIComponent(actorId)}`
   );
 }
-async function getMetadata(config2) {
-  return apiCall(config2, "GET", `/metadata`);
+async function getMetadata(config3) {
+  return apiCall(config3, "GET", `/metadata`);
 }
-async function getDatacenters(config2) {
-  return apiCall(config2, "GET", `/datacenters`);
+async function getDatacenters(config3) {
+  return apiCall(config3, "GET", `/datacenters`);
 }
-async function updateRunnerConfig(config2, runnerName, request) {
+async function updateRunnerConfig(config3, runnerName, request) {
   return apiCall(
-    config2,
+    config3,
     "PUT",
     `/runner-configs/${runnerName}`,
     request
@@ -5246,8 +5721,8 @@ async function updateRunnerConfig(config2, runnerName, request) {
 // src/remote-manager-driver/metadata.ts
 import pRetry2 from "p-retry";
 var metadataLookupCache = /* @__PURE__ */ new Map();
-async function lookupMetadataCached(config2) {
-  const endpoint = getEndpoint(config2);
+async function lookupMetadataCached(config3) {
+  const endpoint = getEndpoint(config3);
   const existingPromise = metadataLookupCache.get(endpoint);
   if (existingPromise) {
     return existingPromise;
@@ -5258,7 +5733,7 @@ async function lookupMetadataCached(config2) {
         msg: "fetching metadata",
         endpoint
       });
-      const metadataData = await getMetadata(config2);
+      const metadataData = await getMetadata(config3);
       logger2().debug({
         msg: "received metadata",
         endpoint,
@@ -5663,6 +6138,7 @@ var RemoteManagerDriver = class {
 export {
   createActorInspectorRouter,
   createHttpDriver,
+  CURRENT_VERSION2 as CURRENT_VERSION,
   HTTP_ACTION_REQUEST_VERSIONED,
   HTTP_ACTION_RESPONSE_VERSIONED,
   HTTP_RESPONSE_ERROR_VERSIONED,
@@ -5691,4 +6167,4 @@ export {
   updateRunnerConfig,
   RemoteManagerDriver
 };
-//# sourceMappingURL=chunk-BBTOBXEO.js.map
+//# sourceMappingURL=chunk-KXSSOVFA.js.map