rivetkit 2.0.27 → 2.0.29-rc.1

package/dist/tsup/{chunk-XU4GGB6J.js → chunk-QKDCNAPW.js}

@@ -4,12 +4,13 @@ import {
   inspectorLogger,
   isInspectorEnabled,
   secureInspector
-} from "./chunk-2NNICHGY.js";
+} from "./chunk-EVQJYFFP.js";
 import {
   ActionContext,
   ActorDefinition,
   CONN_DRIVER_SYMBOL,
   CONN_STATE_MANAGER_SYMBOL,
+  CURRENT_VERSION,
   HTTP_ACTION_REQUEST_VERSIONED,
   HTTP_ACTION_RESPONSE_VERSIONED,
   HTTP_RESPONSE_ERROR_VERSIONED,
@@ -28,17 +29,16 @@ import {
   parseMessage,
   serializeActorKey,
   updateRunnerConfig
-} from "./chunk-BBTOBXEO.js";
+} from "./chunk-CHPLLKNL.js";
 import {
   CreateActorSchema
-} from "./chunk-6F2NCX7R.js";
+} from "./chunk-WUFUT7CZ.js";
 import {
   ClientConfigSchema,
   KEYS,
   RunnerConfigSchema,
-  createVersionedDataHandler,
   getInitialActorKvState
-} from "./chunk-5YDKTW6Y.js";
+} from "./chunk-CGIRSKRW.js";
 import {
   EncodingSchema,
   HEADER_ACTOR_ID,
@@ -60,7 +60,7 @@ import {
   generateRandomString,
   loggerWithoutContext,
   serializeWithEncoding
-} from "./chunk-C3UREFUI.js";
+} from "./chunk-HXWPIIEM.js";
 import {
   VERSION,
   arrayBuffersEqual,
@@ -76,7 +76,7 @@ import {
   promiseWithResolvers,
   setLongTimeout,
   stringifyError
-} from "./chunk-KSQQU7NC.js";
+} from "./chunk-YJXB7BPR.js";
 import {
   ActorDuplicateKey,
   ActorStopping,
@@ -87,30 +87,31 @@ import {
   Unsupported,
   UserError,
   WebSocketsNotEnabled
-} from "./chunk-LQOCWGP6.js";
+} from "./chunk-P2RZJPYI.js";
 
 // src/actor/config.ts
 import { z } from "zod";
+var zFunction = () => z.custom((val) => typeof val === "function");
 var ActorConfigSchema = z.object({
-  onCreate: z.function().optional(),
-  onDestroy: z.function().optional(),
-  onWake: z.function().optional(),
-  onSleep: z.function().optional(),
-  onStateChange: z.function().optional(),
-  onBeforeConnect: z.function().optional(),
-  onConnect: z.function().optional(),
-  onDisconnect: z.function().optional(),
-  onBeforeActionResponse: z.function().optional(),
-  onRequest: z.function().optional(),
-  onWebSocket: z.function().optional(),
-  actions: z.record(z.function()).default({}),
+  onCreate: zFunction().optional(),
+  onDestroy: zFunction().optional(),
+  onWake: zFunction().optional(),
+  onSleep: zFunction().optional(),
+  onStateChange: zFunction().optional(),
+  onBeforeConnect: zFunction().optional(),
+  onConnect: zFunction().optional(),
+  onDisconnect: zFunction().optional(),
+  onBeforeActionResponse: zFunction().optional(),
+  onRequest: zFunction().optional(),
+  onWebSocket: zFunction().optional(),
+  actions: z.record(z.string(), zFunction()).default(() => ({})),
   state: z.any().optional(),
-  createState: z.function().optional(),
+  createState: zFunction().optional(),
   connState: z.any().optional(),
-  createConnState: z.function().optional(),
+  createConnState: zFunction().optional(),
   vars: z.any().optional(),
   db: z.any().optional(),
-  createVars: z.function().optional(),
+  createVars: zFunction().optional(),
   options: z.object({
     createVarsTimeout: z.number().positive().default(5e3),
     createConnStateTimeout: z.number().positive().default(5e3),
@@ -135,9 +136,9 @@ var ActorConfigSchema = z.object({
      **/
     canHibernateWebSocket: z.union([
       z.boolean(),
-      z.function().args(z.custom()).returns(z.boolean())
+      zFunction()
     ]).default(false)
-  }).strict().default({})
+  }).strict().prefault(() => ({}))
 }).strict().refine(
   (data) => !(data.state !== void 0 && data.createState !== void 0),
   {
@@ -190,7 +191,7 @@ async function handleAction(c, _runConfig, actorDriver, actionName, actorId) {
     // JSON: args is already the decoded value (raw object/array)
     (json) => json.args,
     // BARE/CBOR: args is ArrayBuffer that needs CBOR-decoding
-    (bare2) => cbor.decode(new Uint8Array(bare2.args))
+    (bare4) => cbor.decode(new Uint8Array(bare4.args))
   );
   const actionArgs = request;
   let actor2;
@@ -217,6 +218,7 @@ async function handleAction(c, _runConfig, actorDriver, actionName, actorId) {
     encoding,
     output,
     HTTP_ACTION_RESPONSE_VERSIONED,
+    CURRENT_VERSION,
     HttpActionResponseSchema,
     // JSON: output is the raw value (will be serialized by jsonStringifyCompat)
     (value) => ({ output: value }),
@@ -353,6 +355,7 @@ function handleRouteError(error, c) {
     encoding,
     errorData,
     HTTP_RESPONSE_ERROR_VERSIONED,
+    CURRENT_VERSION,
     HttpResponseErrorSchema,
     // JSON: metadata is the raw value (will be serialized by jsonStringifyCompat)
     (value) => ({
@@ -885,8 +888,8 @@ function createActorRouter(runConfig, actorDriver, isTest) {
 
 // src/actor/mod.ts
 function actor(input) {
-  const config2 = ActorConfigSchema.parse(input);
-  return new ActorDefinition(config2);
+  const config4 = ActorConfigSchema.parse(input);
+  return new ActorDefinition(config4);
 }
 
 // src/common/inline-websocket-adapter.ts
@@ -2031,19 +2034,12 @@ var FileSystemActorDriver = class {
 // src/drivers/file-system/global-state.ts
 import invariant4 from "invariant";
 
-// dist/schemas/file-system-driver/v2.ts
+// src/schemas/file-system-driver/versioned.ts
+import { createVersionedDataHandler } from "vbare";
+
+// dist/schemas/file-system-driver/v1.ts
 import * as bare from "@bare-ts/lib";
 var config = /* @__PURE__ */ bare.Config({});
-function readActorKvEntry(bc) {
-  return {
-    key: bare.readData(bc),
-    value: bare.readData(bc)
-  };
-}
-function writeActorKvEntry(bc, x) {
-  bare.writeData(bc, x.key);
-  bare.writeData(bc, x.value);
-}
 function read0(bc) {
   const len = bare.readUintSafe(bc);
   if (len === 0) {
@@ -2061,29 +2057,12 @@ function write0(bc, x) {
     bare.writeString(bc, x[i]);
   }
 }
-function read1(bc) {
-  const len = bare.readUintSafe(bc);
-  if (len === 0) {
-    return [];
-  }
-  const result = [readActorKvEntry(bc)];
-  for (let i = 1; i < len; i++) {
-    result[i] = readActorKvEntry(bc);
-  }
-  return result;
-}
-function write1(bc, x) {
-  bare.writeUintSafe(bc, x.length);
-  for (let i = 0; i < x.length; i++) {
-    writeActorKvEntry(bc, x[i]);
-  }
-}
 function readActorState(bc) {
   return {
     actorId: bare.readString(bc),
     name: bare.readString(bc),
     key: read0(bc),
-    kvStorage: read1(bc),
+    persistedData: bare.readData(bc),
     createdAt: bare.readU64(bc)
   };
 }
@@ -2091,7 +2070,7 @@ function writeActorState(bc, x) {
   bare.writeString(bc, x.actorId);
   bare.writeString(bc, x.name);
   write0(bc, x.key);
-  write1(bc, x.kvStorage);
+  bare.writeData(bc, x.persistedData);
   bare.writeU64(bc, x.createdAt);
 }
 function encodeActorState(x) {
@@ -2137,41 +2116,344 @@ function decodeActorAlarm(bytes) {
   return result;
 }
 
+// dist/schemas/file-system-driver/v2.ts
+import * as bare2 from "@bare-ts/lib";
+var config2 = /* @__PURE__ */ bare2.Config({});
+function readActorKvEntry(bc) {
+  return {
+    key: bare2.readData(bc),
+    value: bare2.readData(bc)
+  };
+}
+function writeActorKvEntry(bc, x) {
+  bare2.writeData(bc, x.key);
+  bare2.writeData(bc, x.value);
+}
+function read02(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare2.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare2.readString(bc);
+  }
+  return result;
+}
+function write02(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare2.writeString(bc, x[i]);
+  }
+}
+function read1(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readActorKvEntry(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readActorKvEntry(bc);
+  }
+  return result;
+}
+function write1(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeActorKvEntry(bc, x[i]);
+  }
+}
+function readActorState2(bc) {
+  return {
+    actorId: bare2.readString(bc),
+    name: bare2.readString(bc),
+    key: read02(bc),
+    kvStorage: read1(bc),
+    createdAt: bare2.readU64(bc)
+  };
+}
+function writeActorState2(bc, x) {
+  bare2.writeString(bc, x.actorId);
+  bare2.writeString(bc, x.name);
+  write02(bc, x.key);
+  write1(bc, x.kvStorage);
+  bare2.writeU64(bc, x.createdAt);
+}
+function encodeActorState2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeActorState2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorState2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readActorState2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActorAlarm2(bc) {
+  return {
+    actorId: bare2.readString(bc),
+    timestamp: bare2.readUint(bc)
+  };
+}
+function writeActorAlarm2(bc, x) {
+  bare2.writeString(bc, x.actorId);
+  bare2.writeUint(bc, x.timestamp);
+}
+function encodeActorAlarm2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writeActorAlarm2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorAlarm2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readActorAlarm2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// dist/schemas/file-system-driver/v3.ts
+import * as bare3 from "@bare-ts/lib";
+var config3 = /* @__PURE__ */ bare3.Config({});
+function readActorKvEntry2(bc) {
+  return {
+    key: bare3.readData(bc),
+    value: bare3.readData(bc)
+  };
+}
+function writeActorKvEntry2(bc, x) {
+  bare3.writeData(bc, x.key);
+  bare3.writeData(bc, x.value);
+}
+function read03(bc) {
+  const len = bare3.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare3.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare3.readString(bc);
+  }
+  return result;
+}
+function write03(bc, x) {
+  bare3.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare3.writeString(bc, x[i]);
+  }
+}
+function read12(bc) {
+  const len = bare3.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readActorKvEntry2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readActorKvEntry2(bc);
+  }
+  return result;
+}
+function write12(bc, x) {
+  bare3.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeActorKvEntry2(bc, x[i]);
+  }
+}
+function read2(bc) {
+  return bare3.readBool(bc) ? bare3.readU64(bc) : null;
+}
+function write2(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeU64(bc, x);
+  }
+}
+function readActorState3(bc) {
+  return {
+    actorId: bare3.readString(bc),
+    name: bare3.readString(bc),
+    key: read03(bc),
+    kvStorage: read12(bc),
+    createdAt: bare3.readU64(bc),
+    startTs: read2(bc),
+    connectableTs: read2(bc),
+    sleepTs: read2(bc),
+    destroyTs: read2(bc)
+  };
+}
+function writeActorState3(bc, x) {
+  bare3.writeString(bc, x.actorId);
+  bare3.writeString(bc, x.name);
+  write03(bc, x.key);
+  write12(bc, x.kvStorage);
+  bare3.writeU64(bc, x.createdAt);
+  write2(bc, x.startTs);
+  write2(bc, x.connectableTs);
+  write2(bc, x.sleepTs);
+  write2(bc, x.destroyTs);
+}
+function encodeActorState3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeActorState3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorState3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readActorState3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActorAlarm3(bc) {
+  return {
+    actorId: bare3.readString(bc),
+    timestamp: bare3.readUint(bc)
+  };
+}
+function writeActorAlarm3(bc, x) {
+  bare3.writeString(bc, x.actorId);
+  bare3.writeUint(bc, x.timestamp);
+}
+function encodeActorAlarm3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeActorAlarm3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorAlarm3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readActorAlarm3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
 // src/schemas/file-system-driver/versioned.ts
-var CURRENT_VERSION = 2;
-var migrations = /* @__PURE__ */ new Map([
-  [
-    2,
-    (v1State) => {
-      const kvStorage = [];
-      if (v1State.persistedData) {
-        const key = new Uint8Array([1]);
-        kvStorage.push({
-          key: bufferToArrayBuffer(key),
-          value: v1State.persistedData
-        });
-      }
-      return {
-        actorId: v1State.actorId,
-        name: v1State.name,
-        key: v1State.key,
-        kvStorage,
-        createdAt: v1State.createdAt
-      };
-    }
-  ]
-]);
+var CURRENT_VERSION2 = 3;
+var v1ToV2 = (v1State) => {
+  const kvStorage = [];
+  if (v1State.persistedData) {
+    const key = new Uint8Array([1]);
+    kvStorage.push({
+      key: bufferToArrayBuffer(key),
+      value: v1State.persistedData
+    });
+  }
+  return {
+    actorId: v1State.actorId,
+    name: v1State.name,
+    key: v1State.key,
+    kvStorage,
+    createdAt: v1State.createdAt
+  };
+};
+var v2ToV3 = (v2State) => {
+  return {
+    actorId: v2State.actorId,
+    name: v2State.name,
+    key: v2State.key,
+    kvStorage: v2State.kvStorage,
+    createdAt: v2State.createdAt,
+    startTs: null,
+    connectableTs: null,
+    sleepTs: null,
+    destroyTs: null
+  };
+};
+var v3ToV2 = (v3State) => {
+  return {
+    actorId: v3State.actorId,
+    name: v3State.name,
+    key: v3State.key,
+    kvStorage: v3State.kvStorage,
+    createdAt: v3State.createdAt
+  };
+};
+var v2ToV1 = (v2State) => {
+  const persistDataEntry = v2State.kvStorage.find((entry) => {
+    const key = new Uint8Array(entry.key);
+    return key.length === 1 && key[0] === 1;
+  });
+  return {
+    actorId: v2State.actorId,
+    name: v2State.name,
+    key: v2State.key,
+    persistedData: (persistDataEntry == null ? void 0 : persistDataEntry.value) || new ArrayBuffer(0),
+    createdAt: v2State.createdAt
+  };
+};
 var ACTOR_STATE_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeActorState(data),
-  deserializeVersion: (bytes) => decodeActorState(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeActorState(bytes);
+      case 2:
+        return decodeActorState2(bytes);
+      case 3:
+        return decodeActorState3(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeActorState(data);
+      case 2:
+        return encodeActorState2(data);
+      case 3:
+        return encodeActorState3(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [v1ToV2, v2ToV3],
+  serializeConverters: () => [v3ToV2, v2ToV1]
 });
 var ACTOR_ALARM_VERSIONED = createVersionedDataHandler({
-  currentVersion: CURRENT_VERSION,
-  migrations,
-  serializeVersion: (data) => encodeActorAlarm(data),
-  deserializeVersion: (bytes) => decodeActorAlarm(bytes)
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeActorAlarm(bytes);
+      case 2:
+        return decodeActorAlarm2(bytes);
+      case 3:
+        return decodeActorAlarm3(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeActorAlarm(data);
+      case 2:
+        return encodeActorAlarm2(data);
+      case 3:
+        return encodeActorAlarm3(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
 });
 
 // src/drivers/file-system/log.ts
@@ -2383,7 +2665,11 @@ var FileSystemGlobalState = class {
       name,
       key,
       createdAt: BigInt(Date.now()),
-      kvStorage
+      kvStorage,
+      startTs: null,
+      connectableTs: null,
+      sleepTs: null,
+      destroyTs: null
     };
     entry.lifecycleState = 1 /* AWAKE */;
     await this.writeActor(actorId, entry.generation, entry.state);
@@ -2453,7 +2739,11 @@ var FileSystemGlobalState = class {
         name,
         key,
         createdAt: BigInt(Date.now()),
-        kvStorage
+        kvStorage,
+        startTs: null,
+        connectableTs: null,
+        sleepTs: null,
+        destroyTs: null
       };
       await this.writeActor(actorId, entry.generation, entry.state);
     }
@@ -2474,6 +2764,13 @@ var FileSystemGlobalState = class {
     if (actor2.loadPromise) await actor2.loadPromise.catch();
     if ((_a = actor2.startPromise) == null ? void 0 : _a.promise)
       await actor2.startPromise.promise.catch();
+    if (actor2.state) {
+      actor2.state = {
+        ...actor2.state,
+        sleepTs: BigInt(Date.now())
+      };
+      await this.writeActor(actorId, actor2.generation, actor2.state);
+    }
     invariant4(actor2.actor, "actor should be loaded");
     await actor2.actor.onStop("sleep");
     this.#actors.delete(actorId);
@@ -2488,6 +2785,13 @@ var FileSystemGlobalState = class {
     if (actor2.loadPromise) await actor2.loadPromise.catch();
     if ((_a = actor2.startPromise) == null ? void 0 : _a.promise)
       await actor2.startPromise.promise.catch();
+    if (actor2.state) {
+      actor2.state = {
+        ...actor2.state,
+        destroyTs: BigInt(Date.now())
+      };
+      await this.writeActor(actorId, actor2.generation, actor2.state);
+    }
     if (actor2.actor) {
       await actor2.actor.onStop("destroy");
     }
@@ -2591,7 +2895,8 @@ var FileSystemGlobalState = class {
           timestamp: BigInt(timestamp)
         };
         const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(
-          alarmData
+          alarmData,
+          CURRENT_VERSION2
         );
         const fs = getNodeFs();
         await fs.writeFile(tempPath, data);
@@ -2636,9 +2941,16 @@ var FileSystemGlobalState = class {
         name: state.name,
         key: state.key,
         createdAt: state.createdAt,
-        kvStorage: state.kvStorage
+        kvStorage: state.kvStorage,
+        startTs: state.startTs,
+        connectableTs: state.connectableTs,
+        sleepTs: state.sleepTs,
+        destroyTs: state.destroyTs
       };
-      const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);
+      const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(
+        bareState,
+        CURRENT_VERSION2
+      );
       const fs = getNodeFs();
       await fs.writeFile(tempPath, serializedState);
       if (!this.isGenerationCurrentAndNotDestroyed(actorId, generation)) {
@@ -2719,6 +3031,13 @@ var FileSystemGlobalState = class {
         entry.state.key,
         "unknown"
       );
+      const now = BigInt(Date.now());
+      entry.state = {
+        ...entry.state,
+        startTs: now,
+        connectableTs: now
+      };
+      await this.writeActor(actorId, entry.generation, entry.state);
       entry.startPromise.resolve();
       entry.startPromise = void 0;
       return entry.actor;
@@ -3293,7 +3612,11 @@ var FileSystemManagerDriver = class {
           actorId: actor2.actorId,
           name: actor2.name,
           key: actor2.key,
-          createTs: Number(actor2.createdAt)
+          createTs: Number(actor2.createdAt),
+          startTs: actor2.startTs !== null ? Number(actor2.startTs) : null,
+          connectableTs: actor2.connectableTs !== null ? Number(actor2.connectableTs) : null,
+          sleepTs: actor2.sleepTs !== null ? Number(actor2.sleepTs) : null,
+          destroyTs: actor2.destroyTs !== null ? Number(actor2.destroyTs) : null
         });
       }
     }
@@ -4237,17 +4560,17 @@ async function createTestWebSocketProxy(clientWsPromise) {
 import { z as z5 } from "zod";
 var ServerlessStartHeadersSchema = z5.object({
   endpoint: z5.string({
-    required_error: "x-rivet-endpoint header is required"
+    error: "x-rivet-endpoint header is required"
   }),
-  token: z5.string({ invalid_type_error: "x-rivet-token header must be a string" }).optional(),
+  token: z5.string({ error: "x-rivet-token header must be a string" }).optional(),
   totalSlots: z5.coerce.number({
-    invalid_type_error: "x-rivet-total-slots header must be a number"
-  }).int("x-rivet-total-slots header must be an integer").gte(1, "x-rivet-total-slots header must be positive"),
+    error: "x-rivet-total-slots header must be a number"
+  }).int({ error: "x-rivet-total-slots header must be an integer" }).gte(1, { error: "x-rivet-total-slots header must be positive" }),
   runnerName: z5.string({
-    required_error: "x-rivet-runner-name header is required"
+    error: "x-rivet-runner-name header is required"
   }),
   namespace: z5.string({
-    required_error: "x-rivet-namespace-name header is required"
+    error: "x-rivet-namespace-name header is required"
   })
 });
 
@@ -4754,10 +5077,10 @@ function createApiActor(actor2, runnerName = "default") {
     // Assert default namespace
     runner_name_selector: runnerName,
     create_ts: actor2.createTs ?? Date.now(),
-    connectable_ts: null,
-    destroy_ts: null,
-    sleep_ts: null,
-    start_ts: null
+    connectable_ts: actor2.connectableTs ?? null,
+    destroy_ts: actor2.destroyTs ?? null,
+    sleep_ts: actor2.sleepTs ?? null,
+    start_ts: actor2.startTs ?? null
   };
 }
 
@@ -4814,76 +5137,76 @@ var Registry = class {
   get config() {
     return this.#config;
   }
-  constructor(config2) {
-    this.#config = config2;
+  constructor(config4) {
+    this.#config = config4;
   }
   /**
    * Runs the registry for a server.
    */
   start(inputConfig) {
     var _a, _b, _c;
-    const config2 = RunnerConfigSchema.parse(inputConfig);
-    if (config2.autoConfigureServerless && config2.runnerKind !== "serverless") {
+    const config4 = RunnerConfigSchema.parse(inputConfig);
+    if (config4.autoConfigureServerless && config4.runnerKind !== "serverless") {
       throw new Error(
         "autoConfigureServerless can only be configured when runnerKind is 'serverless'"
       );
     }
     const readyPromises = [];
-    if (config2.runnerKind === "serverless") {
+    if (config4.runnerKind === "serverless") {
       logger7().debug("disabling health check since using serverless");
-      config2.disableMetadataLookup = true;
+      config4.disableMetadataLookup = true;
     }
-    if (process.env.NODE_ENV !== "production" && config2.runnerKind === "serverless") {
-      if ((inputConfig == null ? void 0 : inputConfig.runEngine) === void 0) config2.runEngine = true;
+    if (process.env.NODE_ENV !== "production" && config4.runnerKind === "serverless") {
+      if ((inputConfig == null ? void 0 : inputConfig.runEngine) === void 0) config4.runEngine = true;
       if ((inputConfig == null ? void 0 : inputConfig.autoConfigureServerless) === void 0)
-        config2.autoConfigureServerless = true;
+        config4.autoConfigureServerless = true;
     }
-    if (config2.runEngine) {
+    if (config4.runEngine) {
       logger7().debug({
         msg: "run engine requested",
-        version: config2.runEngineVersion
+        version: config4.runEngineVersion
       });
       invariant7(
-        config2.endpoint === void 0,
+        config4.endpoint === void 0,
         "cannot specify 'endpoint' with 'runEngine'"
       );
-      config2.endpoint = ENGINE_ENDPOINT;
-      config2.disableActorDriver = true;
+      config4.endpoint = ENGINE_ENDPOINT;
+      config4.disableActorDriver = true;
       const engineProcessPromise = ensureEngineProcess({
-        version: config2.runEngineVersion
+        version: config4.runEngineVersion
       });
       readyPromises.push(engineProcessPromise);
     }
-    if (config2.runnerKind === "serverless") {
-      config2.defaultServerPort = 8080;
-      config2.overrideServerAddress = config2.endpoint;
-      config2.disableActorDriver = true;
+    if (config4.runnerKind === "serverless") {
+      config4.defaultServerPort = 8080;
+      config4.overrideServerAddress = config4.endpoint;
+      config4.disableActorDriver = true;
     }
-    if ((_a = config2.logging) == null ? void 0 : _a.baseLogger) {
-      configureBaseLogger(config2.logging.baseLogger);
+    if ((_a = config4.logging) == null ? void 0 : _a.baseLogger) {
+      configureBaseLogger(config4.logging.baseLogger);
     } else {
-      configureDefaultLogger((_b = config2.logging) == null ? void 0 : _b.level);
+      configureDefaultLogger((_b = config4.logging) == null ? void 0 : _b.level);
     }
-    const driver = chooseDefaultDriver(config2);
+    const driver = chooseDefaultDriver(config4);
     if (driver.name === "engine") {
-      config2.inspector.enabled = { manager: false, actor: true };
-      if (config2.runnerKind !== "serverless") {
-        config2.disableDefaultServer = true;
+      config4.inspector.enabled = { manager: false, actor: true };
+      if (config4.runnerKind !== "serverless") {
+        config4.disableDefaultServer = true;
       }
     }
     if (driver.name === "cloudflare-workers") {
-      config2.inspector.enabled = { manager: false, actor: true };
-      config2.disableDefaultServer = true;
-      config2.disableActorDriver = true;
-      config2.noWelcome = true;
+      config4.inspector.enabled = { manager: false, actor: true };
+      config4.disableDefaultServer = true;
+      config4.disableActorDriver = true;
+      config4.noWelcome = true;
     }
     let upgradeWebSocket;
-    if (!config2.getUpgradeWebSocket) {
-      config2.getUpgradeWebSocket = () => upgradeWebSocket;
+    if (!config4.getUpgradeWebSocket) {
+      config4.getUpgradeWebSocket = () => upgradeWebSocket;
     }
-    const managerDriver = driver.manager(this.#config, config2);
-    configureInspectorAccessToken(config2, managerDriver);
-    const client = createClientWithDriver(managerDriver, config2);
+    const managerDriver = driver.manager(this.#config, config4);
+    configureInspectorAccessToken(config4, managerDriver);
+    const client = createClientWithDriver(managerDriver, config4);
     const driverLog = ((_c = managerDriver.extraStartupLog) == null ? void 0 : _c.call(managerDriver)) ?? {};
     logger7().info({
       msg: "rivetkit ready",
@@ -4891,59 +5214,59 @@ var Registry = class {
       definitions: Object.keys(this.#config.use).length,
       ...driverLog
     });
-    if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
+    if (isInspectorEnabled(config4, "manager") && managerDriver.inspector) {
       logger7().info({
         msg: "inspector ready",
-        url: getInspectorUrl(config2)
+        url: getInspectorUrl(config4)
       });
     }
-    if (!config2.noWelcome) {
+    if (!config4.noWelcome) {
       const displayInfo = managerDriver.displayInformation();
       console.log();
       console.log(`  RivetKit ${package_default.version} (${displayInfo.name})`);
-      if (!config2.disableDefaultServer) {
-        console.log(`  - Endpoint:     ${getEndpoint(config2)}`);
-      } else if (config2.overrideServerAddress) {
+      if (!config4.disableDefaultServer) {
+        console.log(`  - Endpoint:     ${getEndpoint(config4)}`);
+      } else if (config4.overrideServerAddress) {
         console.log(
-          `  - Endpoint:     ${config2.overrideServerAddress}`
+          `  - Endpoint:     ${config4.overrideServerAddress}`
         );
       }
-      if (config2.runEngine) {
+      if (config4.runEngine) {
         const padding = " ".repeat(Math.max(0, 13 - "Engine".length));
-        console.log(`  - Engine:${padding}v${config2.runEngineVersion}`);
+        console.log(`  - Engine:${padding}v${config4.runEngineVersion}`);
       }
       for (const [k, v] of Object.entries(displayInfo.properties)) {
         const padding = " ".repeat(Math.max(0, 13 - k.length));
         console.log(`  - ${k}:${padding}${v}`);
       }
-      if (isInspectorEnabled(config2, "manager") && managerDriver.inspector) {
-        console.log(`  - Inspector:    ${getInspectorUrl(config2)}`);
+      if (isInspectorEnabled(config4, "manager") && managerDriver.inspector) {
+        console.log(`  - Inspector:    ${getInspectorUrl(config4)}`);
       }
       console.log();
     }
     const { router: hono } = createManagerRouter(
       this.#config,
-      config2,
+      config4,
       managerDriver,
       driver,
       client
     );
-    if (!config2.disableDefaultServer) {
+    if (!config4.disableDefaultServer) {
       const serverPromise = (async () => {
-        const out = await crossPlatformServe(config2, hono);
+        const out = await crossPlatformServe(config4, hono);
         upgradeWebSocket = out.upgradeWebSocket;
       })();
       readyPromises.push(serverPromise);
     }
-    if (!config2.disableActorDriver) {
+    if (!config4.disableActorDriver) {
       Promise.all(readyPromises).then(async () => {
         logger7().debug("starting actor driver");
-        driver.actor(this.#config, config2, managerDriver, client);
+        driver.actor(this.#config, config4, managerDriver, client);
       });
     }
-    if (config2.runnerKind === "serverless" && config2.autoConfigureServerless) {
+    if (config4.runnerKind === "serverless" && config4.autoConfigureServerless) {
       Promise.all(readyPromises).then(async () => {
-        await configureServerlessRunner(config2);
+        await configureServerlessRunner(config4);
       });
     }
     return {
@@ -4952,67 +5275,67 @@ var Registry = class {
     };
   }
 };
-async function configureServerlessRunner(config2) {
+async function configureServerlessRunner(config4) {
   logger7().debug("configuring serverless runner");
   try {
-    if (!config2.runnerName) {
+    if (!config4.runnerName) {
       throw new Error(
         "runnerName is required for serverless configuration"
       );
     }
-    if (!config2.namespace) {
+    if (!config4.namespace) {
       throw new Error(
         "namespace is required for serverless configuration"
       );
     }
-    if (!config2.endpoint) {
+    if (!config4.endpoint) {
       throw new Error(
         "endpoint is required for serverless configuration"
       );
     }
-    const customConfig = typeof config2.autoConfigureServerless === "object" ? config2.autoConfigureServerless : {};
+    const customConfig = typeof config4.autoConfigureServerless === "object" ? config4.autoConfigureServerless : {};
     const clientConfig = {
-      endpoint: config2.endpoint,
-      token: config2.token,
-      namespace: config2.namespace,
-      runnerName: config2.runnerName,
-      encoding: config2.encoding,
-      headers: config2.headers,
-      getUpgradeWebSocket: config2.getUpgradeWebSocket,
+      endpoint: config4.endpoint,
+      token: config4.token,
+      namespace: config4.namespace,
+      runnerName: config4.runnerName,
+      encoding: config4.encoding,
+      headers: config4.headers,
+      getUpgradeWebSocket: config4.getUpgradeWebSocket,
       disableMetadataLookup: true
       // We don't need health check for this operation
     };
     logger7().debug({
       msg: "fetching datacenters",
-      endpoint: config2.endpoint
+      endpoint: config4.endpoint
     });
     const dcsRes = await getDatacenters(clientConfig);
     logger7().debug({
       msg: "configuring serverless runner",
-      runnerName: config2.runnerName,
-      namespace: config2.namespace
+      runnerName: config4.runnerName,
+      namespace: config4.namespace
     });
     const serverlessConfig = {
       serverless: {
-        url: customConfig.url || `http://localhost:${config2.defaultServerPort}`,
+        url: customConfig.url || `http://localhost:${config4.defaultServerPort}`,
         headers: customConfig.headers || {},
         max_runners: customConfig.maxRunners ?? 100,
         min_runners: customConfig.minRunners ?? 0,
         request_lifespan: customConfig.requestLifespan ?? 15 * 60,
         runners_margin: customConfig.runnersMargin ?? 0,
-        slots_per_runner: customConfig.slotsPerRunner ?? config2.totalSlots ?? 1e3
+        slots_per_runner: customConfig.slotsPerRunner ?? config4.totalSlots ?? 1e3
       },
       metadata: customConfig.metadata ?? {}
     };
-    await updateRunnerConfig(clientConfig, config2.runnerName, {
+    await updateRunnerConfig(clientConfig, config4.runnerName, {
       datacenters: Object.fromEntries(
         dcsRes.datacenters.map((dc) => [dc.name, serverlessConfig])
       )
     });
     logger7().info({
       msg: "serverless runner configured successfully",
-      runnerName: config2.runnerName,
-      namespace: config2.namespace
+      runnerName: config4.runnerName,
+      namespace: config4.namespace
     });
   } catch (error) {
     logger7().error({
@@ -5022,8 +5345,8 @@ async function configureServerlessRunner(config2) {
   }
 }
 function setup(input) {
-  const config2 = RegistryConfigSchema.parse(input);
-  return new Registry(config2);
+  const config4 = RegistryConfigSchema.parse(input);
+  return new Registry(config4);
 }
 
 export {
@@ -5041,4 +5364,4 @@ export {
   setup
 };
 //! These configs configs hold anything that's not platform-specific about running actors.
-//# sourceMappingURL=chunk-XU4GGB6J.js.map
+//# sourceMappingURL=chunk-QKDCNAPW.js.map