rivetkit 2.0.42 → 2.1.0-rc.1

package/dist/tsup/{chunk-GMAVRZSF.js → chunk-M2T62AZQ.js}

@@ -1,7 +1,17 @@
 import {
+  CURRENT_VERSION,
   TO_CLIENT_VERSIONED,
   TO_SERVER_VERSIONED
-} from "./chunk-E6ZE2YEA.js";
+} from "./chunk-LXUQ667X.js";
+import {
+  ActorContext,
+  KEYS,
+  assertUnreachable as assertUnreachable2,
+  getRunMetadata,
+  hasSchemaConfigKey,
+  loggerWithoutContext,
+  validateSchemaSync
+} from "./chunk-T5YCUGVS.js";
 import {
   LogLevelSchema,
   VERSION,
@@ -26,28 +36,30 @@ import {
   getRivetTotalSlots,
   getRivetkitInspectorDisable,
   getRivetkitInspectorToken,
+  getRivetkitStoragePath,
   isCborSerializable,
   isDev,
   noopNext,
   promiseWithResolvers,
   stringifyError
-} from "./chunk-FJ3KTN4V.js";
+} from "./chunk-6LIBPELE.js";
 import {
   ConnStateNotEnabled,
+  EventPayloadInvalid,
   Forbidden,
   IncomingMessageTooLong,
   InternalError,
   InvalidEncoding,
   InvalidParams,
+  InvalidRequest,
   InvalidStateType,
   MalformedMessage,
   MissingActorHeader,
   OutgoingMessageTooLong,
   RestrictedFeature,
-  Unreachable,
   Unsupported,
   WebSocketsNotEnabled
-} from "./chunk-LFVF5SCU.js";
+} from "./chunk-7HTNH26M.js";
 
 // src/common/actor-router-consts.ts
 var PATH_CONNECT = "/connect";
@@ -83,10 +95,11 @@ var ALLOWED_PUBLIC_HEADERS = [
 ];
 
 // src/manager/router.ts
+import { serveStatic } from "@hono/node-server/serve-static";
 import { createRoute } from "@hono/zod-openapi";
 import * as cbor6 from "cbor-x";
 import invariant5 from "invariant";
-import { z as z10 } from "zod";
+import { z as z10 } from "zod/v4";
 
 // src/actor/keys.ts
 var EMPTY_KEY = "/";
@@ -152,344 +165,6 @@ import * as cbor3 from "cbor-x";
 // src/actor/router-endpoints.ts
 import * as cbor2 from "cbor-x";
 
-// src/actor/instance/keys.ts
-var KEYS = {
-  PERSIST_DATA: Uint8Array.from([1]),
-  CONN_PREFIX: Uint8Array.from([2]),
-  // Prefix for connection keys
-  INSPECTOR_TOKEN: Uint8Array.from([3]),
-  // Inspector token key
-  KV: Uint8Array.from([4])
-  // Prefix for user-facing KV storage
-};
-function makePrefixedKey(key) {
-  const prefixed = new Uint8Array(KEYS.KV.length + key.length);
-  prefixed.set(KEYS.KV, 0);
-  prefixed.set(key, KEYS.KV.length);
-  return prefixed;
-}
-function removePrefixFromKey(prefixedKey) {
-  return prefixedKey.slice(KEYS.KV.length);
-}
-function makeConnKey(connId) {
-  const encoder = new TextEncoder();
-  const connIdBytes = encoder.encode(connId);
-  const key = new Uint8Array(KEYS.CONN_PREFIX.length + connIdBytes.length);
-  key.set(KEYS.CONN_PREFIX, 0);
-  key.set(connIdBytes, KEYS.CONN_PREFIX.length);
-  return key;
-}
-
-// src/actor/instance/kv.ts
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-function encodeKey(key, keyType) {
-  if (key instanceof Uint8Array) {
-    return key;
-  }
-  const resolvedKeyType = keyType ?? "text";
-  if (resolvedKeyType === "binary") {
-    throw new TypeError("Expected a Uint8Array when keyType is binary");
-  }
-  return textEncoder.encode(key);
-}
-function decodeKey(key, keyType) {
-  const resolvedKeyType = keyType ?? "text";
-  switch (resolvedKeyType) {
-    case "text":
-      return textDecoder.decode(key);
-    case "binary":
-      return key;
-    default:
-      throw new TypeError("Invalid kv key type");
-  }
-}
-function resolveValueType(value) {
-  if (typeof value === "string") {
-    return "text";
-  }
-  if (value instanceof Uint8Array) {
-    return "binary";
-  }
-  if (value instanceof ArrayBuffer) {
-    return "arrayBuffer";
-  }
-  throw new TypeError("Invalid kv value");
-}
-function encodeValue(value, options) {
-  const type = (options == null ? void 0 : options.type) ?? resolveValueType(value);
-  switch (type) {
-    case "text":
-      if (typeof value !== "string") {
-        throw new TypeError("Expected a string when type is text");
-      }
-      return textEncoder.encode(value);
-    case "arrayBuffer":
-      if (!(value instanceof ArrayBuffer)) {
-        throw new TypeError("Expected an ArrayBuffer when type is arrayBuffer");
-      }
-      return new Uint8Array(value);
-    case "binary":
-      if (!(value instanceof Uint8Array)) {
-        throw new TypeError("Expected a Uint8Array when type is binary");
-      }
-      return value;
-    default:
-      throw new TypeError("Invalid kv value type");
-  }
-}
-function decodeValue(value, options) {
-  const type = (options == null ? void 0 : options.type) ?? "text";
-  switch (type) {
-    case "text":
-      return textDecoder.decode(value);
-    case "arrayBuffer": {
-      const copy = new Uint8Array(value.byteLength);
-      copy.set(value);
-      return copy.buffer;
-    }
-    case "binary":
-      return value;
-    default:
-      throw new TypeError("Invalid kv value type");
-  }
-}
-var ActorKv = class {
-  #driver;
-  #actorId;
-  constructor(driver, actorId) {
-    this.#driver = driver;
-    this.#actorId = actorId;
-  }
-  /**
-   * Get a single value by key.
-   */
-  async get(key, options) {
-    const results = await this.#driver.kvBatchGet(this.#actorId, [
-      makePrefixedKey(encodeKey(key))
-    ]);
-    const result = results[0];
-    if (!result) {
-      return null;
-    }
-    return decodeValue(result, options);
-  }
-  /**
-   * Get multiple values by keys.
-   */
-  async getBatch(keys, options) {
-    const prefixedKeys = keys.map(
-      (key) => makePrefixedKey(encodeKey(key))
-    );
-    const results = await this.#driver.kvBatchGet(
-      this.#actorId,
-      prefixedKeys
-    );
-    return results.map(
-      (result) => result ? decodeValue(result, options) : null
-    );
-  }
-  /**
-   * Put a single key-value pair.
-   */
-  async put(key, value, options) {
-    await this.#driver.kvBatchPut(this.#actorId, [
-      [makePrefixedKey(encodeKey(key)), encodeValue(value, options)]
-    ]);
-  }
-  /**
-   * Put multiple key-value pairs.
-   */
-  async putBatch(entries, options) {
-    const prefixedEntries = entries.map(
-      ([key, value]) => [
-        makePrefixedKey(encodeKey(key)),
-        encodeValue(value, options)
-      ]
-    );
-    await this.#driver.kvBatchPut(this.#actorId, prefixedEntries);
-  }
-  /**
-   * Delete a single key.
-   */
-  async delete(key) {
-    await this.#driver.kvBatchDelete(this.#actorId, [
-      makePrefixedKey(encodeKey(key))
-    ]);
-  }
-  /**
-   * Delete multiple keys.
-   */
-  async deleteBatch(keys) {
-    const prefixedKeys = keys.map(
-      (key) => makePrefixedKey(encodeKey(key))
-    );
-    await this.#driver.kvBatchDelete(this.#actorId, prefixedKeys);
-  }
-  /**
-   * List all keys with a given prefix.
-   * Returns key-value pairs where keys have the user prefix removed.
-   */
-  async list(prefix, options) {
-    const prefixedPrefix = makePrefixedKey(
-      encodeKey(prefix, options == null ? void 0 : options.keyType)
-    );
-    const results = await this.#driver.kvListPrefix(
-      this.#actorId,
-      prefixedPrefix
-    );
-    return results.map(([key, value]) => [
-      decodeKey(removePrefixFromKey(key), options == null ? void 0 : options.keyType),
-      decodeValue(value, options)
-    ]);
-  }
-};
-
-// src/actor/contexts/base/actor.ts
-var ActorContext = class {
-  #actor;
-  #kv;
-  constructor(actor) {
-    this.#actor = actor;
-  }
-  /**
-   * Gets the KV storage interface.
-   */
-  get kv() {
-    if (!this.#kv) {
-      this.#kv = new ActorKv(this.#actor.driver, this.#actor.id);
-    }
-    return this.#kv;
-  }
-  /**
-   * Get the actor state
-   *
-   * @remarks
-   * This property is not available in `createState` since the state hasn't been created yet.
-   */
-  get state() {
-    return this.#actor.state;
-  }
-  /**
-   * Get the actor variables
-   *
-   * @remarks
-   * This property is not available in `createVars` since the variables haven't been created yet.
-   * Variables are only available if you define `vars` or `createVars` in your actor config.
-   */
-  get vars() {
-    return this.#actor.vars;
-  }
-  /**
-   * Broadcasts an event to all connected clients.
-   * @param name - The name of the event.
-   * @param args - The arguments to send with the event.
-   */
-  broadcast(name, ...args) {
-    this.#actor.eventManager.broadcast(name, ...args);
-    return;
-  }
-  /**
-   * Gets the logger instance.
-   */
-  get log() {
-    return this.#actor.log;
-  }
-  /**
-   * Gets actor ID.
-   */
-  get actorId() {
-    return this.#actor.id;
-  }
-  /**
-   * Gets the actor name.
-   */
-  get name() {
-    return this.#actor.name;
-  }
-  /**
-   * Gets the actor key.
-   */
-  get key() {
-    return this.#actor.key;
-  }
-  /**
-   * Gets the region.
-   */
-  get region() {
-    return this.#actor.region;
-  }
-  /**
-   * Gets the scheduler.
-   */
-  get schedule() {
-    return this.#actor.schedule;
-  }
-  /**
-   * Gets the map of connections.
-   */
-  get conns() {
-    return this.#actor.conns;
-  }
-  /**
-   * Returns the client for the given registry.
-   */
-  client() {
-    return this.#actor.inlineClient;
-  }
-  /**
-   * Gets the database.
-   *
-   * @experimental
-   * @remarks
-   * This property is only available if you define a `db` provider in your actor config.
-   * @throws {DatabaseNotEnabled} If the database is not enabled.
-   */
-  get db() {
-    return this.#actor.db;
-  }
-  /**
-   * Forces the state to get saved.
-   *
-   * @param opts - Options for saving the state.
-   */
-  async saveState(opts) {
-    return this.#actor.stateManager.saveState(opts);
-  }
-  /**
-   * Prevents the actor from sleeping until promise is complete.
-   */
-  waitUntil(promise) {
-    this.#actor.waitUntil(promise);
-  }
-  /**
-   * AbortSignal that fires when the actor is stopping.
-   */
-  get abortSignal() {
-    return this.#actor.abortSignal;
-  }
-  /**
-   * Forces the actor to sleep.
-   *
-   * Not supported on all drivers.
-   *
-   * @experimental
-   */
-  sleep() {
-    this.#actor.startSleep();
-  }
-  /**
-   * Forces the actor to destroy.
-   *
-   * This will return immediately, then call `onStop` and `onDestroy`.
-   *
-   * @experimental
-   */
-  destroy() {
-    this.#actor.startDestroy();
-  }
-};
-
 // src/actor/contexts/base/conn.ts
 var ConnContext = class extends ActorContext {
   /**
@@ -501,6 +176,10 @@ var ConnContext = class extends ActorContext {
   }
 };
 
+// src/actor/contexts/action.ts
+var ActionContext = class extends ConnContext {
+};
+
 // src/actor/contexts/base/conn-init.ts
 var ConnInitContext = class extends ActorContext {
   /**
@@ -517,10 +196,6 @@ var ConnInitContext = class extends ActorContext {
   }
 };
 
-// src/actor/contexts/action.ts
-var ActionContext = class extends ConnContext {
-};
-
 // src/actor/contexts/before-connect.ts
 var BeforeConnectContext = class extends ConnInitContext {
 };
@@ -566,7 +241,7 @@ var WebSocketContext = class extends ConnContext {
 };
 
 // src/actor/protocol/serde.ts
-import { z } from "zod";
+import { z } from "zod/v4";
 
 // src/serde.ts
 import * as cbor from "cbor-x";
@@ -655,58 +330,6 @@ function deserializeWithEncoding(encoding, buffer, versionedDataHandler, zodSche
   }
 }
 
-// src/actor/log.ts
-function loggerWithoutContext() {
-  return getLogger("actor-runtime");
-}
-
-// src/actor/utils.ts
-function assertUnreachable2(x) {
-  loggerWithoutContext().error({
-    msg: "unreachable",
-    value: `${x}`,
-    stack: new Error().stack
-  });
-  throw new Unreachable(x);
-}
-var DeadlineError = class extends Error {
-  constructor() {
-    super("Promise did not complete before deadline.");
-  }
-};
-function deadline(promise, timeout) {
-  const controller = new AbortController();
-  const signal = controller.signal;
-  const timeoutId = setTimeout(() => controller.abort(), timeout);
-  return Promise.race([
-    promise,
-    new Promise((_, reject) => {
-      signal.addEventListener("abort", () => reject(new DeadlineError()));
-    })
-  ]).finally(() => {
-    clearTimeout(timeoutId);
-  });
-}
-function generateSecureToken(length = 32) {
-  const array = new Uint8Array(length);
-  crypto.getRandomValues(array);
-  return btoa(String.fromCharCode(...array)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
-}
-function isStatePath(path) {
-  return path === "state" || path.startsWith("state.");
-}
-function isConnStatePath(path) {
-  if (!path.startsWith("connections.")) {
-    return false;
-  }
-  const stateIndex = path.indexOf(".state", 12);
-  if (stateIndex === -1) {
-    return false;
-  }
-  const afterState = stateIndex + 6;
-  return path.length === afterState || path[afterState] === ".";
-}
-
 // src/actor/protocol/serde.ts
 var EncodingSchema = z.enum(["json", "cbor", "bare"]);
 var CachedSerializer = class {
@@ -1435,71 +1058,488 @@ function decodeHttpResolveResponse2(bytes) {
   return result;
 }
 
-// src/schemas/client-protocol/versioned.ts
-var CURRENT_VERSION = 2;
-var v1ToV2 = (v1Data) => {
-  if (v1Data.body.tag === "Init") {
-    const { actorId, connectionId } = v1Data.body.val;
-    return {
-      body: {
-        tag: "Init",
-        val: {
-          actorId,
-          connectionId
-        }
-      }
-    };
+// dist/schemas/client-protocol/v3.ts
+import * as bare3 from "@rivetkit/bare-ts";
+var config3 = /* @__PURE__ */ bare3.Config({});
+function readInit3(bc) {
+  return {
+    actorId: bare3.readString(bc),
+    connectionId: bare3.readString(bc)
+  };
+}
+function writeInit3(bc, x) {
+  bare3.writeString(bc, x.actorId);
+  bare3.writeString(bc, x.connectionId);
+}
+function read03(bc) {
+  return bare3.readBool(bc) ? bare3.readData(bc) : null;
+}
+function write03(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeData(bc, x);
   }
-  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
-        }
-      }
-    };
+}
+function read13(bc) {
+  return bare3.readBool(bc) ? bare3.readUint(bc) : null;
+}
+function write13(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeUint(bc, x);
   }
-  return v2Data;
-};
-var TO_SERVER_VERSIONED2 = createVersionedDataHandler({
-  deserializeVersion: (bytes, version) => {
-    switch (version) {
-      case 1:
-        return decodeToServer(bytes);
-      case 2:
-        return decodeToServer2(bytes);
-      default:
-        throw new Error(`Unknown version ${version}`);
+}
+function readError3(bc) {
+  return {
+    group: bare3.readString(bc),
+    code: bare3.readString(bc),
+    message: bare3.readString(bc),
+    metadata: read03(bc),
+    actionId: read13(bc)
+  };
+}
+function writeError3(bc, x) {
+  bare3.writeString(bc, x.group);
+  bare3.writeString(bc, x.code);
+  bare3.writeString(bc, x.message);
+  write03(bc, x.metadata);
+  write13(bc, x.actionId);
+}
+function readActionResponse3(bc) {
+  return {
+    id: bare3.readUint(bc),
+    output: bare3.readData(bc)
+  };
+}
+function writeActionResponse3(bc, x) {
+  bare3.writeUint(bc, x.id);
+  bare3.writeData(bc, x.output);
+}
+function readEvent3(bc) {
+  return {
+    name: bare3.readString(bc),
+    args: bare3.readData(bc)
+  };
+}
+function writeEvent3(bc, x) {
+  bare3.writeString(bc, x.name);
+  bare3.writeData(bc, x.args);
+}
+function readToClientBody3(bc) {
+  const offset = bc.offset;
+  const tag = bare3.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "Init", val: readInit3(bc) };
+    case 1:
+      return { tag: "Error", val: readError3(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse3(bc) };
+    case 3:
+      return { tag: "Event", val: readEvent3(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare3.BareError(offset, "invalid tag");
     }
-  },
-  serializeVersion: (data, version) => {
-    switch (version) {
-      case 1:
-        return encodeToServer(data);
-      case 2:
-        return encodeToServer2(data);
-      default:
-        throw new Error(`Unknown version ${version}`);
+  }
+}
+function writeToClientBody3(bc, x) {
+  switch (x.tag) {
+    case "Init": {
+      bare3.writeU8(bc, 0);
+      writeInit3(bc, x.val);
+      break;
     }
-  },
-  deserializeConverters: () => [v1ToV2],
-  serializeConverters: () => [v2ToV1]
-});
-var TO_CLIENT_VERSIONED2 = createVersionedDataHandler({
-  deserializeVersion: (bytes, version) => {
-    switch (version) {
-      case 1:
-        return decodeToClient(bytes);
-      case 2:
-        return decodeToClient2(bytes);
+    case "Error": {
+      bare3.writeU8(bc, 1);
+      writeError3(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare3.writeU8(bc, 2);
+      writeActionResponse3(bc, x.val);
+      break;
+    }
+    case "Event": {
+      bare3.writeU8(bc, 3);
+      writeEvent3(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient3(bc) {
+  return {
+    body: readToClientBody3(bc)
+  };
+}
+function writeToClient3(bc, x) {
+  writeToClientBody3(bc, x.body);
+}
+function encodeToClient3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeToClient3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readToClient3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActionRequest3(bc) {
+  return {
+    id: bare3.readUint(bc),
+    name: bare3.readString(bc),
+    args: bare3.readData(bc)
+  };
+}
+function writeActionRequest3(bc, x) {
+  bare3.writeUint(bc, x.id);
+  bare3.writeString(bc, x.name);
+  bare3.writeData(bc, x.args);
+}
+function readSubscriptionRequest3(bc) {
+  return {
+    eventName: bare3.readString(bc),
+    subscribe: bare3.readBool(bc)
+  };
+}
+function writeSubscriptionRequest3(bc, x) {
+  bare3.writeString(bc, x.eventName);
+  bare3.writeBool(bc, x.subscribe);
+}
+function readToServerBody3(bc) {
+  const offset = bc.offset;
+  const tag = bare3.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActionRequest", val: readActionRequest3(bc) };
+    case 1:
+      return { tag: "SubscriptionRequest", val: readSubscriptionRequest3(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare3.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody3(bc, x) {
+  switch (x.tag) {
+    case "ActionRequest": {
+      bare3.writeU8(bc, 0);
+      writeActionRequest3(bc, x.val);
+      break;
+    }
+    case "SubscriptionRequest": {
+      bare3.writeU8(bc, 1);
+      writeSubscriptionRequest3(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer3(bc) {
+  return {
+    body: readToServerBody3(bc)
+  };
+}
+function writeToServer3(bc, x) {
+  writeToServerBody3(bc, x.body);
+}
+function encodeToServer3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeToServer3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readToServer3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionRequest3(bc) {
+  return {
+    args: bare3.readData(bc)
+  };
+}
+function writeHttpActionRequest3(bc, x) {
+  bare3.writeData(bc, x.args);
+}
+function encodeHttpActionRequest3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpActionRequest3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionRequest3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpActionRequest3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionResponse3(bc) {
+  return {
+    output: bare3.readData(bc)
+  };
+}
+function writeHttpActionResponse3(bc, x) {
+  bare3.writeData(bc, x.output);
+}
+function encodeHttpActionResponse3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpActionResponse3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionResponse3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpActionResponse3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read2(bc) {
+  return bare3.readBool(bc) ? bare3.readString(bc) : null;
+}
+function write2(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeString(bc, x);
+  }
+}
+function read3(bc) {
+  return bare3.readBool(bc) ? bare3.readBool(bc) : null;
+}
+function write3(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeBool(bc, x);
+  }
+}
+function read4(bc) {
+  return bare3.readBool(bc) ? bare3.readU64(bc) : null;
+}
+function write4(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare3.writeU64(bc, x);
+  }
+}
+function readHttpQueueSendRequest(bc) {
+  return {
+    body: bare3.readData(bc),
+    name: read2(bc),
+    wait: read3(bc),
+    timeout: read4(bc)
+  };
+}
+function writeHttpQueueSendRequest(bc, x) {
+  bare3.writeData(bc, x.body);
+  write2(bc, x.name);
+  write3(bc, x.wait);
+  write4(bc, x.timeout);
+}
+function encodeHttpQueueSendRequest(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpQueueSendRequest(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendRequest(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpQueueSendRequest(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpQueueSendResponse(bc) {
+  return {
+    status: bare3.readString(bc),
+    response: read03(bc)
+  };
+}
+function writeHttpQueueSendResponse(bc, x) {
+  bare3.writeString(bc, x.status);
+  write03(bc, x.response);
+}
+function encodeHttpQueueSendResponse(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpQueueSendResponse(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpQueueSendResponse(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpQueueSendResponse(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResponseError3(bc) {
+  return {
+    group: bare3.readString(bc),
+    code: bare3.readString(bc),
+    message: bare3.readString(bc),
+    metadata: read03(bc)
+  };
+}
+function writeHttpResponseError3(bc, x) {
+  bare3.writeString(bc, x.group);
+  bare3.writeString(bc, x.code);
+  bare3.writeString(bc, x.message);
+  write03(bc, x.metadata);
+}
+function encodeHttpResponseError3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpResponseError3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResponseError3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpResponseError3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResolveResponse3(bc) {
+  return {
+    actorId: bare3.readString(bc)
+  };
+}
+function writeHttpResolveResponse3(bc, x) {
+  bare3.writeString(bc, x.actorId);
+}
+function encodeHttpResolveResponse3(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeHttpResolveResponse3(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResolveResponse3(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readHttpResolveResponse3(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/schemas/client-protocol/versioned.ts
+var CURRENT_VERSION2 = 3;
+var v1ToV2 = (v1Data) => {
+  if (v1Data.body.tag === "Init") {
+    const { actorId, connectionId } = v1Data.body.val;
+    return {
+      body: {
+        tag: "Init",
+        val: {
+          actorId,
+          connectionId
+        }
+      }
+    };
+  }
+  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 v2ToV3 = (v2Data) => {
+  return v2Data;
+};
+var v3ToV2 = (v3Data) => {
+  return v3Data;
+};
+var v1ToServerV2 = (v1Data) => {
+  return v1Data;
+};
+var v2ToServerV3 = (v2Data) => {
+  return v2Data;
+};
+var v3ToServerV2 = (v3Data) => {
+  return v3Data;
+};
+var v2ToServerV1 = (v2Data) => {
+  return v2Data;
+};
+var TO_SERVER_VERSIONED2 = createVersionedDataHandler({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeToServer(bytes);
+      case 2:
+        return decodeToServer2(bytes);
+      case 3:
+        return decodeToServer3(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodeToServer(data);
+      case 2:
+        return encodeToServer2(data);
+      case 3:
+        return encodeToServer3(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [v1ToServerV2, v2ToServerV3],
+  serializeConverters: () => [v3ToServerV2, v2ToServerV1]
+});
+var TO_CLIENT_VERSIONED2 = createVersionedDataHandler({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodeToClient(bytes);
+      case 2:
+        return decodeToClient2(bytes);
+      case 3:
+        return decodeToClient3(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1510,12 +1550,14 @@ var TO_CLIENT_VERSIONED2 = createVersionedDataHandler({
         return encodeToClient(data);
       case 2:
         return encodeToClient2(data);
+      case 3:
+        return encodeToClient3(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToV2],
-  serializeConverters: () => [v2ToV1]
+  deserializeConverters: () => [v1ToV2, v2ToV3],
+  serializeConverters: () => [v3ToV2, v2ToV1]
 });
 var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
@@ -1524,6 +1566,8 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionRequest(bytes);
       case 2:
         return decodeHttpActionRequest2(bytes);
+      case 3:
+        return decodeHttpActionRequest3(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1538,6 +1582,10 @@ var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionRequest2(
           data
         );
+      case 3:
+        return encodeHttpActionRequest3(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1552,6 +1600,8 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpActionResponse(bytes);
       case 2:
         return decodeHttpActionResponse2(bytes);
+      case 3:
+        return decodeHttpActionResponse3(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1566,6 +1616,10 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpActionResponse2(
           data
         );
+      case 3:
+        return encodeHttpActionResponse3(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1573,6 +1627,58 @@ var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
   deserializeConverters: () => [],
   serializeConverters: () => []
 });
+var HTTP_QUEUE_SEND_REQUEST_VERSIONED = createVersionedDataHandler({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 3:
+        return decodeHttpQueueSendRequest(bytes);
+      default:
+        throw new Error(
+          `HttpQueueSendRequest only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 3:
+        return encodeHttpQueueSendRequest(
+          data
+        );
+      default:
+        throw new Error(
+          `HttpQueueSendRequest only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+var HTTP_QUEUE_SEND_RESPONSE_VERSIONED = createVersionedDataHandler({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 3:
+        return decodeHttpQueueSendResponse(bytes);
+      default:
+        throw new Error(
+          `HttpQueueSendResponse only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 3:
+        return encodeHttpQueueSendResponse(
+          data
+        );
+      default:
+        throw new Error(
+          `HttpQueueSendResponse only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
 var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
   deserializeVersion: (bytes, version) => {
     switch (version) {
@@ -1580,6 +1686,8 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return decodeHttpResponseError(bytes);
       case 2:
         return decodeHttpResponseError2(bytes);
+      case 3:
+        return decodeHttpResponseError3(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1594,6 +1702,10 @@ var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
         return encodeHttpResponseError2(
           data
         );
+      case 3:
+        return encodeHttpResponseError3(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1608,6 +1720,8 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return decodeHttpResolveResponse(bytes);
       case 2:
         return decodeHttpResolveResponse2(bytes);
+      case 3:
+        return decodeHttpResolveResponse3(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1622,6 +1736,10 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
         return encodeHttpResolveResponse2(
           data
         );
+      case 3:
+        return encodeHttpResolveResponse3(
+          data
+        );
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -1631,7 +1749,7 @@ var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
 });
 
 // src/schemas/client-protocol-zod/mod.ts
-import { z as z2 } from "zod";
+import { z as z2 } from "zod/v4";
 var UintSchema = z2.bigint();
 var OptionalUintSchema = UintSchema.nullable();
 var InitSchema = z2.object({
@@ -1687,6 +1805,16 @@ var HttpActionRequestSchema = z2.object({
 var HttpActionResponseSchema = z2.object({
   output: z2.unknown()
 });
+var HttpQueueSendRequestSchema = z2.object({
+  body: z2.unknown(),
+  name: z2.string().optional(),
+  wait: z2.boolean().optional(),
+  timeout: z2.number().optional()
+});
+var HttpQueueSendResponseSchema = z2.object({
+  status: z2.enum(["completed", "timedOut"]),
+  response: z2.unknown().optional()
+});
 var HttpResponseErrorSchema = z2.object({
   group: z2.string(),
   code: z2.string(),
@@ -1723,11 +1851,11 @@ function createRawRequestDriver() {
 }
 
 // src/actor/router-endpoints.ts
-async function handleAction(c, config6, actorDriver, actionName, actorId) {
+async function handleAction(c, config8, actorDriver, actionName, actorId) {
   const encoding = getRequestEncoding(c.req);
   const parameters = getRequestConnParams(c.req);
   const arrayBuffer = await c.req.arrayBuffer();
-  if (arrayBuffer.byteLength > config6.maxIncomingMessageSize) {
+  if (arrayBuffer.byteLength > config8.maxIncomingMessageSize) {
     throw new IncomingMessageTooLong();
   }
   const request = deserializeWithEncoding(
@@ -1738,47 +1866,157 @@ async function handleAction(c, config6, 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
-    (bare6) => cbor2.decode(new Uint8Array(bare6.args))
+    (bare8) => cbor2.decode(new Uint8Array(bare8.args))
   );
   const actionArgs = request;
-  let actor;
-  let conn;
   let output;
-  try {
-    actor = await actorDriver.loadActor(actorId);
-    actor.rLog.debug({ msg: "handling action", actionName, encoding });
-    conn = await actor.connectionManager.prepareAndConnectConn(
-      createHttpDriver(),
-      parameters,
-      c.req.raw,
-      c.req.path,
-      c.req.header()
-    );
-    const ctx = new ActionContext(actor, conn);
-    output = await actor.executeAction(ctx, actionName, actionArgs);
-  } finally {
-    if (conn) {
-      conn.disconnect();
+  let outputReady = false;
+  const maxAttempts = 3;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    let actor;
+    let conn;
+    try {
+      actor = await actorDriver.loadActor(actorId);
+      actor.rLog.debug({ msg: "handling action", actionName, encoding });
+      conn = await actor.connectionManager.prepareAndConnectConn(
+        createHttpDriver(),
+        parameters,
+        c.req.raw,
+        c.req.path,
+        c.req.header()
+      );
+      const ctx = new ActionContext(actor, conn);
+      output = await actor.executeAction(ctx, actionName, actionArgs);
+      outputReady = true;
+      break;
+    } catch (error) {
+      const shouldRetry = error instanceof InternalError && error.message === "Actor is stopping" && attempt < maxAttempts - 1;
+      if (shouldRetry) {
+        await new Promise((resolve) => setTimeout(resolve, 25));
+        continue;
+      }
+      throw error;
+    } finally {
+      if (conn) {
+        conn.disconnect();
+      }
     }
   }
+  if (!outputReady) {
+    throw new InternalError("Action did not complete");
+  }
   const serialized = serializeWithEncoding(
     encoding,
     output,
     HTTP_ACTION_RESPONSE_VERSIONED,
-    CURRENT_VERSION,
+    CURRENT_VERSION2,
     HttpActionResponseSchema,
     // JSON: output is the raw value (will be serialized by jsonStringifyCompat)
     (value) => ({ output: value }),
     // BARE/CBOR: output needs to be CBOR-encoded to ArrayBuffer
     (value) => ({
-      output: bufferToArrayBuffer(cbor2.encode(value))
+      output: bufferToArrayBuffer(cbor2.encode(value))
+    })
+  );
+  const messageSize = serialized instanceof Uint8Array ? serialized.byteLength : serialized.length;
+  if (messageSize > config8.maxOutgoingMessageSize) {
+    throw new OutgoingMessageTooLong();
+  }
+  return c.body(serialized, 200, {
+    "Content-Type": contentTypeForEncoding(encoding)
+  });
+}
+async function handleQueueSend(c, config8, actorDriver, actorId, queueName) {
+  const encoding = getRequestEncoding(c.req);
+  const params = getRequestConnParams(c.req);
+  const arrayBuffer = await c.req.arrayBuffer();
+  if (arrayBuffer.byteLength > config8.maxIncomingMessageSize) {
+    throw new IncomingMessageTooLong();
+  }
+  const request = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+    HttpQueueSendRequestSchema,
+    (json) => json,
+    (bare8) => ({
+      name: bare8.name ?? void 0,
+      body: cbor2.decode(new Uint8Array(bare8.body)),
+      wait: bare8.wait ?? void 0,
+      timeout: bare8.timeout !== null && bare8.timeout !== void 0 ? Number(bare8.timeout) : void 0
+    })
+  );
+  const name = queueName ?? request.name;
+  if (!name) {
+    throw new InvalidRequest("missing queue name");
+  }
+  const actor = await actorDriver.loadActor(actorId);
+  if (!hasSchemaConfigKey(actor.config.queues, name)) {
+    actor.rLog.warn({
+      msg: "ignoring incoming queue message for undefined queue",
+      queueName: name,
+      hasQueueConfig: actor.config.queues !== void 0
+    });
+    const ignoredResponse = serializeWithEncoding(
+      encoding,
+      { status: "completed", response: void 0 },
+      HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+      CURRENT_VERSION2,
+      HttpQueueSendResponseSchema,
+      (value) => ({
+        status: value.status,
+        response: value.response
+      }),
+      (value) => ({
+        status: value.status,
+        response: value.response !== void 0 ? bufferToArrayBuffer(cbor2.encode(value.response)) : null
+      })
+    );
+    return c.body(ignoredResponse, 200, {
+      "Content-Type": contentTypeForEncoding(encoding)
+    });
+  }
+  const conn = await actor.connectionManager.prepareAndConnectConn(
+    createHttpDriver(),
+    params,
+    c.req.raw,
+    c.req.path,
+    c.req.header()
+  );
+  let result = {
+    status: "completed"
+  };
+  try {
+    const ctx = new ActionContext(actor, conn);
+    await actor.assertCanPublish(ctx, name);
+    if (request.wait) {
+      result = await actor.queueManager.enqueueAndWait(
+        name,
+        request.body,
+        request.timeout
+      );
+    } else {
+      await actor.queueManager.enqueue(name, request.body);
+    }
+  } finally {
+    conn.disconnect();
+  }
+  const response = serializeWithEncoding(
+    encoding,
+    result,
+    HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
+    CURRENT_VERSION2,
+    HttpQueueSendResponseSchema,
+    (value) => ({
+      status: value.status,
+      response: value.response
+    }),
+    (value) => ({
+      status: value.status,
+      response: value.response !== void 0 ? bufferToArrayBuffer(cbor2.encode(value.response)) : null
     })
   );
-  const messageSize = serialized instanceof Uint8Array ? serialized.byteLength : serialized.length;
-  if (messageSize > config6.maxOutgoingMessageSize) {
-    throw new OutgoingMessageTooLong();
-  }
-  return c.body(serialized, 200, {
+  return c.body(response, 200, {
     "Content-Type": contentTypeForEncoding(encoding)
   });
 }
@@ -1838,7 +2076,7 @@ var ENGINE_PORT = 6420;
 var ENGINE_ENDPOINT = `http://127.0.0.1:${ENGINE_PORT}`;
 
 // src/inspector/config.ts
-import { z as z3 } from "zod";
+import { z as z3 } from "zod/v4";
 var defaultTokenFn = () => {
   const envToken = getRivetkitInspectorToken();
   if (envToken) {
@@ -1931,7 +2169,7 @@ function tryParseEndpoint(ctx, options) {
 }
 
 // src/registry/config/driver.ts
-import { z as z4 } from "zod";
+import { z as z4 } from "zod/v4";
 var DriverConfigSchema = z4.object({
   /** Machine-readable name to identify this driver by. */
   name: z4.string(),
@@ -1949,7 +2187,7 @@ var DriverConfigSchema = z4.object({
 });
 
 // src/registry/config/runner.ts
-import { z as z5 } from "zod";
+import { z as z5 } from "zod/v4";
 var RunnerConfigSchema = z5.object({
   // MARK: Runner
   totalSlots: z5.number().default(() => getRivetTotalSlots() ?? 1e5),
@@ -1959,7 +2197,7 @@ var RunnerConfigSchema = z5.object({
 });
 
 // src/registry/config/serverless.ts
-import { z as z6 } from "zod";
+import { z as z6 } from "zod/v4";
 var ConfigureRunnerPoolSchema = z6.object({
   name: z6.string().optional(),
   url: z6.string(),
@@ -2045,6 +2283,14 @@ var RegistryConfigSchema = z7.object({
   test: TestConfigSchema.optional().default({ enabled: false }),
   // MARK: Driver
   driver: DriverConfigSchema.optional(),
+  /**
+   * Storage path for RivetKit file-system state when using the default driver.
+   *
+   * If not set, RivetKit uses the platform default data location.
+   *
+   * Can also be set via RIVETKIT_STORAGE_PATH.
+   */
+  storagePath: z7.string().optional().transform((val) => val ?? getRivetkitStoragePath()),
   // MARK: Networking
   /** @experimental */
   maxIncomingMessageSize: z7.number().optional().default(65536),
@@ -2122,37 +2368,37 @@ var RegistryConfigSchema = z7.object({
   runner: RunnerConfigSchema.optional().default(
     () => RunnerConfigSchema.parse({})
   )
-}).transform((config6, ctx) => {
+}).transform((config8, ctx) => {
   const isDevEnv = isDev();
-  const parsedEndpoint = config6.endpoint ? tryParseEndpoint(ctx, {
-    endpoint: config6.endpoint,
+  const parsedEndpoint = config8.endpoint ? tryParseEndpoint(ctx, {
+    endpoint: config8.endpoint,
     path: ["endpoint"],
-    namespace: config6.namespace,
-    token: config6.token
+    namespace: config8.namespace,
+    token: config8.token
   }) : void 0;
-  if (parsedEndpoint && config6.serveManager) {
+  if (parsedEndpoint && config8.serveManager) {
     ctx.addIssue({
       code: "custom",
       message: "cannot specify both endpoint and serveManager"
     });
   }
-  if (config6.serverless.spawnEngine && parsedEndpoint) {
+  if (config8.serverless.spawnEngine && parsedEndpoint) {
     ctx.addIssue({
       code: "custom",
       message: "cannot specify both spawnEngine and endpoint"
     });
   }
-  if (config6.serverless.configureRunnerPool && !parsedEndpoint && !config6.serverless.spawnEngine) {
+  if (config8.serverless.configureRunnerPool && !parsedEndpoint && !config8.serverless.spawnEngine) {
     ctx.addIssue({
       code: "custom",
       message: "configureRunnerPool requires either endpoint or spawnEngine"
     });
   }
-  const endpoint = config6.serverless.spawnEngine ? ENGINE_ENDPOINT : parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint;
-  const namespace = (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config6.namespace ?? "default";
-  const token = (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config6.token;
-  const parsedPublicEndpoint = config6.serverless.publicEndpoint ? tryParseEndpoint(ctx, {
-    endpoint: config6.serverless.publicEndpoint,
+  const endpoint = config8.serverless.spawnEngine ? ENGINE_ENDPOINT : parsedEndpoint == null ? void 0 : parsedEndpoint.endpoint;
+  const namespace = (parsedEndpoint == null ? void 0 : parsedEndpoint.namespace) ?? config8.namespace ?? "default";
+  const token = (parsedEndpoint == null ? void 0 : parsedEndpoint.token) ?? config8.token;
+  const parsedPublicEndpoint = config8.serverless.publicEndpoint ? tryParseEndpoint(ctx, {
+    endpoint: config8.serverless.publicEndpoint,
     path: ["serverless", "publicEndpoint"]
   }) : void 0;
   if ((parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.namespace) && parsedPublicEndpoint.namespace !== namespace) {
@@ -2162,17 +2408,17 @@ var RegistryConfigSchema = z7.object({
       path: ["serverless", "publicEndpoint"]
     });
   }
-  const serveManager = config6.serveManager ?? (isDevEnv && !endpoint);
-  const publicEndpoint = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.endpoint) ?? (isDevEnv && (serveManager || config6.serverless.spawnEngine) ? `http://127.0.0.1:${config6.managerPort}` : void 0);
+  const serveManager = config8.serveManager ?? (isDevEnv && !endpoint);
+  const publicEndpoint = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.endpoint) ?? (isDevEnv && (serveManager || config8.serverless.spawnEngine) ? `http://127.0.0.1:${config8.managerPort}` : void 0);
   const publicNamespace = parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.namespace;
-  const publicToken = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.token) ?? config6.serverless.publicToken;
-  const willUseEngine = !!endpoint || config6.serverless.spawnEngine;
+  const publicToken = (parsedPublicEndpoint == null ? void 0 : parsedPublicEndpoint.token) ?? config8.serverless.publicToken;
+  const willUseEngine = !!endpoint || config8.serverless.spawnEngine;
   const inspector = willUseEngine ? {
-    ...config6.inspector,
+    ...config8.inspector,
     enabled: { manager: false, actor: true }
-  } : config6.inspector;
+  } : config8.inspector;
   return {
-    ...config6,
+    ...config8,
     endpoint,
     namespace,
     token,
@@ -2182,40 +2428,72 @@ var RegistryConfigSchema = z7.object({
     publicToken,
     inspector,
     serverless: {
-      ...config6.serverless,
+      ...config8.serverless,
       publicEndpoint
     }
   };
 });
-function buildActorNames(config6) {
+function buildActorNames(config8) {
   return Object.fromEntries(
-    Object.keys(config6.use).map((name) => [name, { metadata: {} }])
+    Object.keys(config8.use).map((actorName) => {
+      const definition = config8.use[actorName];
+      const options = definition.config.options ?? {};
+      const runMeta = getRunMetadata(definition.config.run);
+      const metadata = {};
+      metadata.icon = options.icon ?? runMeta.icon;
+      metadata.name = options.name ?? runMeta.name;
+      if (!metadata.icon) delete metadata.icon;
+      if (!metadata.name) delete metadata.name;
+      return [actorName, { metadata }];
+    })
   );
 }
 var DocInspectorConfigSchema = z7.object({
-  enabled: z7.boolean().optional().describe("Whether to enable the Rivet Inspector. Defaults to true in development mode."),
+  enabled: z7.boolean().optional().describe(
+    "Whether to enable the Rivet Inspector. Defaults to true in development mode."
+  ),
   token: z7.string().optional().describe("Token used to access the Inspector."),
-  defaultEndpoint: z7.string().optional().describe("Default RivetKit server endpoint for Rivet Inspector to connect to.")
+  defaultEndpoint: z7.string().optional().describe(
+    "Default RivetKit server endpoint for Rivet Inspector to connect to."
+  )
 }).optional().describe("Inspector configuration for debugging and development.");
 var DocConfigureRunnerPoolSchema = z7.object({
   name: z7.string().optional().describe("Name of the runner pool."),
   url: z7.string().describe("URL of the serverless platform to configure runners."),
-  headers: z7.record(z7.string(), z7.string()).optional().describe("Headers to include in requests to the serverless platform."),
+  headers: z7.record(z7.string(), z7.string()).optional().describe(
+    "Headers to include in requests to the serverless platform."
+  ),
   maxRunners: z7.number().optional().describe("Maximum number of runners in the pool."),
   minRunners: z7.number().optional().describe("Minimum number of runners to keep warm."),
   requestLifespan: z7.number().optional().describe("Maximum lifespan of a request in milliseconds."),
   runnersMargin: z7.number().optional().describe("Buffer margin for scaling runners."),
   slotsPerRunner: z7.number().optional().describe("Number of actor slots per runner."),
-  metadata: z7.record(z7.string(), z7.unknown()).optional().describe("Additional metadata to pass to the serverless platform."),
-  metadataPollInterval: z7.number().optional().describe("Interval in milliseconds between metadata polls from the engine. Defaults to 10000 milliseconds (10 seconds).")
+  metadata: z7.record(z7.string(), z7.unknown()).optional().describe(
+    "Additional metadata to pass to the serverless platform."
+  ),
+  metadataPollInterval: z7.number().optional().describe(
+    "Interval in milliseconds between metadata polls from the engine. Defaults to 10000 milliseconds (10 seconds)."
+  )
 }).optional();
 var DocServerlessConfigSchema = z7.object({
-  spawnEngine: z7.boolean().optional().describe("Downloads and starts the full Rust engine process. Auto-enabled in development mode when no endpoint is provided. Default: false"),
-  engineVersion: z7.string().optional().describe("Version of the engine to download. Defaults to the current RivetKit version."),
-  configureRunnerPool: DocConfigureRunnerPoolSchema.describe("Automatically configure serverless runners in the engine."),
-  basePath: z7.string().optional().describe("Base path for serverless API routes. Default: '/api/rivet'"),
-  publicEndpoint: z7.string().optional().describe("The endpoint that clients should connect to. Supports URL auth syntax: https://namespace:token@api.rivet.dev"),
-  publicToken: z7.string().optional().describe("Token that clients should use when connecting via the public endpoint.")
+  spawnEngine: z7.boolean().optional().describe(
+    "Downloads and starts the full Rust engine process. Auto-enabled in development mode when no endpoint is provided. Default: false"
+  ),
+  engineVersion: z7.string().optional().describe(
+    "Version of the engine to download. Defaults to the current RivetKit version."
+  ),
+  configureRunnerPool: DocConfigureRunnerPoolSchema.describe(
+    "Automatically configure serverless runners in the engine."
+  ),
+  basePath: z7.string().optional().describe(
+    "Base path for serverless API routes. Default: '/api/rivet'"
+  ),
+  publicEndpoint: z7.string().optional().describe(
+    "The endpoint that clients should connect to. Supports URL auth syntax: https://namespace:token@api.rivet.dev"
+  ),
+  publicToken: z7.string().optional().describe(
+    "Token that clients should use when connecting via the public endpoint."
+  )
 }).describe("Configuration for serverless deployment mode.");
 var DocRunnerConfigSchema = z7.object({
   totalSlots: z7.number().optional().describe("Total number of actor slots available. Default: 100000"),
@@ -2224,18 +2502,39 @@ var DocRunnerConfigSchema = z7.object({
   version: z7.number().optional().describe("Version number of this runner. Default: 1")
 }).describe("Configuration for runner mode.");
 var DocRegistryConfigSchema = z7.object({
-  use: z7.record(z7.string(), z7.unknown()).describe("Actor definitions. Keys are actor names, values are actor definitions."),
-  maxIncomingMessageSize: z7.number().optional().describe("Maximum size of incoming WebSocket messages in bytes. Default: 65536"),
-  maxOutgoingMessageSize: z7.number().optional().describe("Maximum size of outgoing WebSocket messages in bytes. Default: 1048576"),
+  use: z7.record(z7.string(), z7.unknown()).describe(
+    "Actor definitions. Keys are actor names, values are actor definitions."
+  ),
+  storagePath: z7.string().optional().describe(
+    "Storage path for RivetKit file-system state when using the default driver. Can also be set via RIVETKIT_STORAGE_PATH."
+  ),
+  maxIncomingMessageSize: z7.number().optional().describe(
+    "Maximum size of incoming WebSocket messages in bytes. Default: 65536"
+  ),
+  maxOutgoingMessageSize: z7.number().optional().describe(
+    "Maximum size of outgoing WebSocket messages in bytes. Default: 1048576"
+  ),
   noWelcome: z7.boolean().optional().describe("Disable the welcome message on startup. Default: false"),
   logging: z7.object({
-    level: LogLevelSchema.optional().describe("Log level for RivetKit. Default: 'warn'")
+    level: LogLevelSchema.optional().describe(
+      "Log level for RivetKit. Default: 'warn'"
+    )
   }).optional().describe("Logging configuration."),
-  endpoint: z7.string().optional().describe("Endpoint URL to connect to Rivet Engine. Supports URL auth syntax: https://namespace:token@api.rivet.dev. Can also be set via RIVET_ENDPOINT environment variable."),
-  token: z7.string().optional().describe("Authentication token for Rivet Engine. Can also be set via RIVET_TOKEN environment variable."),
-  namespace: z7.string().optional().describe("Namespace to use. Default: 'default'. Can also be set via RIVET_NAMESPACE environment variable."),
-  headers: z7.record(z7.string(), z7.string()).optional().describe("Additional headers to include in requests to Rivet Engine."),
-  serveManager: z7.boolean().optional().describe("Whether to start the local manager server. Auto-determined based on endpoint and NODE_ENV if not specified."),
+  endpoint: z7.string().optional().describe(
+    "Endpoint URL to connect to Rivet Engine. Supports URL auth syntax: https://namespace:token@api.rivet.dev. Can also be set via RIVET_ENDPOINT environment variable."
+  ),
+  token: z7.string().optional().describe(
+    "Authentication token for Rivet Engine. Can also be set via RIVET_TOKEN environment variable."
+  ),
+  namespace: z7.string().optional().describe(
+    "Namespace to use. Default: 'default'. Can also be set via RIVET_NAMESPACE environment variable."
+  ),
+  headers: z7.record(z7.string(), z7.string()).optional().describe(
+    "Additional headers to include in requests to Rivet Engine."
+  ),
+  serveManager: z7.boolean().optional().describe(
+    "Whether to start the local manager server. Auto-determined based on endpoint and NODE_ENV if not specified."
+  ),
   managerBasePath: z7.string().optional().describe("Base path for the manager API. Default: '/'"),
   managerPort: z7.number().optional().describe("Port to run the manager on. Default: 6420"),
   inspector: DocInspectorConfigSchema,
@@ -2292,7 +2591,7 @@ function handleRouteError(error, c) {
     encoding,
     errorData,
     HTTP_RESPONSE_ERROR_VERSIONED,
-    CURRENT_VERSION,
+    CURRENT_VERSION2,
     HttpResponseErrorSchema,
     // JSON: metadata is the raw value (will be serialized by jsonStringifyCompat)
     (value) => ({
@@ -2311,15 +2610,15 @@ function handleRouteError(error, c) {
   );
   return c.body(output, { status: statusCode });
 }
-function handleMetadataRequest(c, config6, runnerKind, clientEndpoint, clientNamespace, clientToken) {
+function handleMetadataRequest(c, config8, runnerKind, clientEndpoint, clientNamespace, clientToken) {
   const response = {
     runtime: "rivetkit",
     version: VERSION,
     runner: {
       kind: runnerKind,
-      version: config6.runner.version
+      version: config8.runner.version
     },
-    actorNames: buildActorNames(config6),
+    actorNames: buildActorNames(config8),
     clientEndpoint,
     clientNamespace,
     clientToken
@@ -2334,11 +2633,169 @@ function handleHealthRequest(c) {
   });
 }
 
+// src/inspector/serve-ui.ts
+import { extract } from "tar";
+
+// src/utils/node.ts
+import { createRequire } from "module";
+var nodeCrypto;
+var nodeFsSync;
+var nodeFs;
+var nodePath;
+var nodeOs;
+var nodeChildProcess;
+var nodeStream;
+var nodeUrl;
+var hasImportedDependencies = false;
+function getRequireFn() {
+  return createRequire(import.meta.url);
+}
+function importNodeDependencies() {
+  if (hasImportedDependencies) return;
+  try {
+    const requireFn = getRequireFn();
+    nodeCrypto = requireFn(
+      /* webpackIgnore: true */
+      "node:crypto"
+    );
+    nodeFsSync = requireFn(
+      /* webpackIgnore: true */
+      "node:fs"
+    );
+    nodeFs = requireFn(
+      /* webpackIgnore: true */
+      "node:fs/promises"
+    );
+    nodePath = requireFn(
+      /* webpackIgnore: true */
+      "node:path"
+    );
+    nodeOs = requireFn(
+      /* webpackIgnore: true */
+      "node:os"
+    );
+    nodeChildProcess = requireFn(
+      /* webpackIgnore: true */
+      "node:child_process"
+    );
+    nodeStream = requireFn(
+      /* webpackIgnore: true */
+      "node:stream/promises"
+    );
+    nodeUrl = requireFn(
+      /* webpackIgnore: true */
+      "node:url"
+    );
+    hasImportedDependencies = true;
+  } catch (err) {
+    console.warn(
+      "Node.js modules not available, file system driver will not work",
+      err
+    );
+    throw err;
+  }
+}
+function getNodeCrypto() {
+  if (!nodeCrypto) {
+    throw new Error(
+      "Node crypto module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeCrypto;
+}
+function getNodeFsSync() {
+  if (!nodeFsSync) {
+    throw new Error(
+      "Node fs module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFsSync;
+}
+function getNodeFs() {
+  if (!nodeFs) {
+    throw new Error(
+      "Node fs/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeFs;
+}
+function getNodePath() {
+  if (!nodePath) {
+    throw new Error(
+      "Node path module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodePath;
+}
+function getNodeOs() {
+  if (!nodeOs) {
+    throw new Error(
+      "Node os module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeOs;
+}
+function getNodeChildProcess() {
+  if (!nodeChildProcess) {
+    throw new Error(
+      "Node child_process module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeChildProcess;
+}
+function getNodeStream() {
+  if (!nodeStream) {
+    throw new Error(
+      "Node stream/promises module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeStream;
+}
+function getNodeUrl() {
+  if (!nodeUrl) {
+    throw new Error(
+      "Node url module not loaded. Ensure importNodeDependencies() has been called."
+    );
+  }
+  return nodeUrl;
+}
+
+// src/inspector/serve-ui.ts
+var extractedDir;
+var extractionPromise;
+async function getInspectorDir() {
+  if (extractedDir !== void 0) return extractedDir;
+  if (extractionPromise !== void 0) return extractionPromise;
+  const nodeFs2 = getNodeFs();
+  const os = getNodeOs();
+  const url = getNodeUrl();
+  const path = getNodePath();
+  extractionPromise = (async () => {
+    const tarball = path.join(
+      path.dirname(url.fileURLToPath(import.meta.url)),
+      "../../dist/inspector.tar.gz"
+    );
+    try {
+      await nodeFs2.access(tarball);
+    } catch {
+      throw new Error(
+        `Inspector tarball not found at ${tarball}. Run 'pnpm build:pack-inspector' first.`
+      );
+    }
+    const dest = path.join(os.tmpdir(), "rivetkit-inspector");
+    await nodeFs2.mkdir(dest, { recursive: true });
+    await extract({ file: tarball, cwd: dest });
+    extractedDir = dest;
+    return dest;
+  })();
+  return extractionPromise;
+}
+
 // src/manager-api/actors.ts
-import { z as z9 } from "zod";
+import { z as z9 } from "zod/v4";
 
 // src/manager-api/common.ts
-import { z as z8 } from "zod";
+import { z as z8 } from "zod/v4";
 var RivetIdSchema = z8.string();
 
 // src/manager-api/actors.ts
@@ -2502,6 +2959,9 @@ import invariant4 from "invariant";
 // src/actor/router-websocket-endpoints.ts
 import invariant3 from "invariant";
 
+// src/inspector/handler.ts
+import { encodeReadRangeWire } from "@rivetkit/traces/encoding";
+
 // src/inspector/log.ts
 function inspectorLogger() {
   return getLogger("inspector");
@@ -2512,6 +2972,7 @@ async function handleWebSocketInspectorConnect({
   actor
 }) {
   const inspector = actor.inspector;
+  const maxQueueStatusLimit = 200;
   const listeners = [];
   return {
     // NOTE: onOpen cannot be async since this messes up the open event listener order
@@ -2521,11 +2982,13 @@ async function handleWebSocketInspectorConnect({
           tag: "Init",
           val: {
             connections: inspector.getConnections(),
-            events: inspector.getLastEvents(),
             rpcs: inspector.getRpcs(),
             state: inspector.isStateEnabled() ? inspector.getState() : null,
             isStateEnabled: inspector.isStateEnabled(),
-            isDatabaseEnabled: inspector.isDatabaseEnabled()
+            isDatabaseEnabled: inspector.isDatabaseEnabled(),
+            queueSize: BigInt(inspector.getQueueSize()),
+            workflowHistory: inspector.getWorkflowHistory(),
+            isWorkflowEnabled: inspector.isWorkflowEnabled()
           }
         }
       });
@@ -2546,19 +3009,21 @@ async function handleWebSocketInspectorConnect({
             }
           });
         }),
-        inspector.emitter.on("eventFired", () => {
+        inspector.emitter.on("queueUpdated", () => {
           sendMessage(ws, {
             body: {
-              tag: "EventsUpdated",
-              val: { events: inspector.getLastEvents() }
+              tag: "QueueUpdated",
+              val: {
+                queueSize: BigInt(inspector.getQueueSize())
+              }
             }
           });
         }),
-        inspector.emitter.on("eventsChanged", () => {
+        inspector.emitter.on("workflowHistoryUpdated", (history) => {
           sendMessage(ws, {
             body: {
-              tag: "EventsUpdated",
-              val: { events: inspector.getLastEvents() }
+              tag: "WorkflowHistoryUpdated",
+              val: { history }
             }
           });
         })
@@ -2604,37 +3069,111 @@ async function handleWebSocketInspectorConnect({
               }
             }
           });
-        } else if (message.body.tag === "EventsRequest") {
+        } else if (message.body.tag === "RpcsListRequest") {
           sendMessage(ws, {
             body: {
-              tag: "EventsResponse",
+              tag: "RpcsListResponse",
               val: {
                 rid: message.body.val.id,
-                events: inspector.getLastEvents()
+                rpcs: inspector.getRpcs()
               }
             }
           });
-        } else if (message.body.tag === "ClearEventsRequest") {
-          inspector.clearEvents();
+        } else if (message.body.tag === "TraceQueryRequest") {
+          const { id, startMs, endMs, limit } = message.body.val;
+          const wire = await actor.traces.readRangeWire({
+            startMs: Number(startMs),
+            endMs: Number(endMs),
+            limit: Number(limit)
+          });
           sendMessage(ws, {
             body: {
-              tag: "EventsResponse",
+              tag: "TraceQueryResponse",
               val: {
-                rid: message.body.val.id,
-                events: []
+                rid: id,
+                payload: bufferToArrayBuffer(
+                  encodeReadRangeWire(wire)
+                )
               }
             }
           });
-        } else if (message.body.tag === "RpcsListRequest") {
+        } else if (message.body.tag === "QueueRequest") {
+          const { id, limit } = message.body.val;
+          const status = await inspector.getQueueStatus(
+            Math.min(Number(limit), maxQueueStatusLimit)
+          );
           sendMessage(ws, {
             body: {
-              tag: "RpcsListResponse",
+              tag: "QueueResponse",
+              val: {
+                rid: id,
+                status
+              }
+            }
+          });
+        } else if (message.body.tag === "WorkflowHistoryRequest") {
+          sendMessage(ws, {
+            body: {
+              tag: "WorkflowHistoryResponse",
               val: {
                 rid: message.body.val.id,
-                rpcs: inspector.getRpcs()
+                history: inspector.getWorkflowHistory(),
+                isWorkflowEnabled: inspector.isWorkflowEnabled()
               }
             }
           });
+        } else if (message.body.tag === "DatabaseSchemaRequest") {
+          const { id } = message.body.val;
+          try {
+            const schema = await inspector.getDatabaseSchema();
+            sendMessage(ws, {
+              body: {
+                tag: "DatabaseSchemaResponse",
+                val: { rid: id, schema }
+              }
+            });
+          } catch (error) {
+            inspectorLogger().warn(
+              { error },
+              "Failed to get database schema"
+            );
+            sendMessage(ws, {
+              body: {
+                tag: "Error",
+                val: {
+                  message: `Failed to get database schema: ${error instanceof Error ? error.message : String(error)}`
+                }
+              }
+            });
+          }
+        } else if (message.body.tag === "DatabaseTableRowsRequest") {
+          const { id, table, limit, offset } = message.body.val;
+          try {
+            const result = await inspector.getDatabaseTableRows(
+              table,
+              Number(limit),
+              Number(offset)
+            );
+            sendMessage(ws, {
+              body: {
+                tag: "DatabaseTableRowsResponse",
+                val: { rid: id, result }
+              }
+            });
+          } catch (error) {
+            inspectorLogger().warn(
+              { error },
+              "Failed to get database table rows"
+            );
+            sendMessage(ws, {
+              body: {
+                tag: "Error",
+                val: {
+                  message: `Failed to get database rows: ${error instanceof Error ? error.message : String(error)}`
+                }
+              }
+            });
+          }
         } else {
           assertUnreachable(message.body);
         }
@@ -2662,7 +3201,7 @@ function sendMessage(ws, message) {
   ws.send(
     TO_CLIENT_VERSIONED.serializeWithEmbeddedVersion(
       message,
-      1
+      CURRENT_VERSION
     )
   );
 }
@@ -2705,7 +3244,7 @@ function createRawWebSocketDriver(hibernatable, closePromise) {
 }
 
 // src/actor/conn/drivers/websocket.ts
-function createWebSocketDriver(hibernatable, encoding, closePromise, config6) {
+function createWebSocketDriver(hibernatable, encoding, closePromise, config8) {
   loggerWithoutContext().debug({
     msg: "createWebSocketDriver creating driver",
     hibernatable
@@ -2741,11 +3280,11 @@ function createWebSocketDriver(hibernatable, encoding, closePromise, config6) {
           dataLength: serialized.byteLength || serialized.length
         });
         const messageSize = serialized.byteLength || serialized.length;
-        if (messageSize > config6.maxOutgoingMessageSize) {
+        if (messageSize > config8.maxOutgoingMessageSize) {
           actor.rLog.error({
             msg: "outgoing message exceeds maxOutgoingMessageSize",
             messageSize,
-            maxOutgoingMessageSize: config6.maxOutgoingMessageSize
+            maxOutgoingMessageSize: config8.maxOutgoingMessageSize
           });
           throw new OutgoingMessageTooLong();
         }
@@ -2936,12 +3475,12 @@ var StateManager = class {
 };
 
 // src/actor/conn/mod.ts
-var CONN_CONNECTED_SYMBOL = Symbol("connected");
-var CONN_SPEAKS_RIVETKIT_SYMBOL = Symbol("speaksRivetKit");
-var CONN_DRIVER_SYMBOL = Symbol("driver");
-var CONN_ACTOR_SYMBOL = Symbol("actor");
-var CONN_STATE_MANAGER_SYMBOL = Symbol("stateManager");
-var CONN_SEND_MESSAGE_SYMBOL = Symbol("sendMessage");
+var CONN_CONNECTED_SYMBOL = /* @__PURE__ */ Symbol("connected");
+var CONN_SPEAKS_RIVETKIT_SYMBOL = /* @__PURE__ */ Symbol("speaksRivetKit");
+var CONN_DRIVER_SYMBOL = /* @__PURE__ */ Symbol("driver");
+var CONN_ACTOR_SYMBOL = /* @__PURE__ */ Symbol("actor");
+var CONN_STATE_MANAGER_SYMBOL = /* @__PURE__ */ Symbol("stateManager");
+var CONN_SEND_MESSAGE_SYMBOL = /* @__PURE__ */ Symbol("sendMessage");
 var Conn = class {
   #actor;
   get [CONN_ACTOR_SYMBOL]() {
@@ -3007,8 +3546,7 @@ var Conn = class {
    * If the underlying connection can hibernate.
    */
   get isHibernatable() {
-    var _a;
-    return ((_a = this[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.hibernatable) !== void 0;
+    return this.#stateManager.hibernatableDataRaw !== void 0;
   }
   /**
    * Initializes a new instance of the Connection class.
@@ -3042,13 +3580,6 @@ var Conn = class {
       });
     }
   }
-  /**
-   * Sends an event with arguments to the client.
-   *
-   * @param eventName - The name of the event.
-   * @param args - The arguments for the event.
-   * @see {@link https://rivet.dev/docs/events|Events Documentation}
-   */
   send(eventName, ...args) {
     var _a;
     this.#assertConnected();
@@ -3059,18 +3590,33 @@ var Conn = class {
         connType: (_a = this[CONN_DRIVER_SYMBOL]) == null ? void 0 : _a.type
       });
     }
-    this.#actor.inspector.emitter.emit("eventFired", {
-      type: "event",
+    if (this.#actor.config.events !== void 0 && !hasSchemaConfigKey(this.#actor.config.events, eventName)) {
+      this.#actor.rLog.warn({
+        msg: "sending event not defined in actor events config",
+        eventName,
+        connId: this.id
+      });
+    }
+    const payload = args.length === 1 ? args[0] : args;
+    const result = validateSchemaSync(
+      this.#actor.config.events,
       eventName,
-      args,
-      connId: this.id
+      payload
+    );
+    if (!result.success) {
+      throw new EventPayloadInvalid(eventName, result.issues);
+    }
+    const eventArgs = args.length === 1 ? [result.data] : Array.isArray(result.data) ? result.data : args;
+    this.#actor.emitTraceEvent("message.send", {
+      "rivet.event.name": eventName,
+      "rivet.conn.id": this.id
     });
-    const eventData = { name: eventName, args };
+    const eventData = { name: eventName, args: eventArgs };
     this[CONN_SEND_MESSAGE_SYMBOL](
       new CachedSerializer(
         eventData,
         TO_CLIENT_VERSIONED2,
-        CURRENT_VERSION,
+        CURRENT_VERSION2,
         ToClientSchema,
         // JSON: args is the raw value (array of arguments)
         (value) => ({
@@ -3111,14 +3657,18 @@ var Conn = class {
           conn: this.id
         });
       }
-      this.#actor.connectionManager.connDisconnected(this);
+      try {
+        await this.#actor.connectionManager.connDisconnected(this);
+      } finally {
+        this[CONN_DRIVER_SYMBOL] = void 0;
+      }
     } else {
       this.#actor.rLog.warn({
         msg: "missing connection driver state for disconnect",
         conn: this.id
       });
+      this[CONN_DRIVER_SYMBOL] = void 0;
     }
-    this[CONN_DRIVER_SYMBOL] = void 0;
   }
 };
 
@@ -3165,22 +3715,22 @@ async function parseMessage(value, opts) {
     // JSON: values are already the correct type
     (json) => json,
     // BARE: need to decode ArrayBuffer fields back to unknown
-    (bare6) => {
-      if (bare6.body.tag === "ActionRequest") {
+    (bare8) => {
+      if (bare8.body.tag === "ActionRequest") {
         return {
           body: {
             tag: "ActionRequest",
             val: {
-              id: bare6.body.val.id,
-              name: bare6.body.val.name,
+              id: bare8.body.val.id,
+              name: bare8.body.val.name,
               args: cbor5.decode(
-                new Uint8Array(bare6.body.val.args)
+                new Uint8Array(bare8.body.val.args)
               )
             }
           }
         };
       } else {
-        return bare6;
+        return bare8;
       }
     }
   );
@@ -3201,7 +3751,10 @@ async function processMessage(message, actor, conn, handler) {
         actionId: id,
         actionName: name
       });
-      const ctx = new ActionContext(actor, conn);
+      const ctx = new ActionContext(
+        actor,
+        conn
+      );
       const output = await handler.onExecuteAction(
         ctx,
         name,
@@ -3218,7 +3771,7 @@ async function processMessage(message, actor, conn, handler) {
         new CachedSerializer(
           output,
           TO_CLIENT_VERSIONED2,
-          CURRENT_VERSION,
+          CURRENT_VERSION2,
           ToClientSchema,
           // JSON: output is the raw value
           (value) => ({
@@ -3254,6 +3807,13 @@ async function processMessage(message, actor, conn, handler) {
         subscribe
       });
       if (subscribe) {
+        await actor.assertCanSubscribe(
+          new ActionContext(
+            actor,
+            conn
+          ),
+          eventName
+        );
         await handler.onSubscribe(eventName, conn);
       } else {
         await handler.onUnsubscribe(eventName, conn);
@@ -3289,7 +3849,7 @@ async function processMessage(message, actor, conn, handler) {
       new CachedSerializer(
         errorData,
         TO_CLIENT_VERSIONED2,
-        CURRENT_VERSION,
+        CURRENT_VERSION2,
         ToClientSchema,
         // JSON: metadata is the raw value (keep as undefined if not present)
         (value) => {
@@ -3332,7 +3892,7 @@ async function processMessage(message, actor, conn, handler) {
 }
 
 // src/actor/router-websocket-endpoints.ts
-async function routeWebSocket(request, requestPath, requestHeaders, config6, actorDriver, actorId, encoding, parameters, gatewayId, requestId, isHibernatable, isRestoringHibernatable) {
+async function routeWebSocket(request, requestPath, requestHeaders, config8, actorDriver, actorId, encoding, parameters, gatewayId, requestId, isHibernatable, isRestoringHibernatable) {
   var _a;
   const exposeInternalError = request ? getRequestExposeInternalError(request) : false;
   let createdConn;
@@ -3344,7 +3904,7 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
       requestPath,
       isHibernatable
     });
-    const closePromiseResolvers = promiseWithResolvers();
+    const closePromiseResolvers = promiseWithResolvers((reason) => loggerWithoutContext().warn({ msg: "unhandled websocket close promise rejection", reason }));
     const requestPathWithoutQuery = requestPath.split("?")[0];
     let handler;
     let connDriver;
@@ -3353,7 +3913,7 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
         isHibernatable ? { gatewayId, requestId } : void 0,
         encoding,
         closePromiseResolvers.promise,
-        config6
+        config8
       );
       handler = handleWebSocketConnect.bind(void 0, setWebSocket);
       connDriver = driver;
@@ -3389,7 +3949,7 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
     );
     createdConn = conn;
     return await handler({
-      config: config6,
+      config: config8,
       request,
       encoding,
       actor,
@@ -3410,7 +3970,7 @@ async function routeWebSocket(request, requestPath, requestHeaders, config6, act
     return {
       conn: createdConn,
       onOpen: (_evt, ws) => {
-        ws.close(1011, code);
+        ws.close(1011, `${group}.${code}`);
       },
       onMessage: (_evt, ws) => {
         ws.close(1011, "actor.not_loaded");
@@ -3430,6 +3990,7 @@ async function handleWebSocketConnect(setWebSocket, {
   conn,
   exposeInternalError
 }) {
+  let pendingMessage = Promise.resolve();
   return {
     conn,
     actor,
@@ -3445,23 +4006,14 @@ async function handleWebSocketConnect(setWebSocket, {
     onMessage: (evt, ws) => {
       actor.rLog.debug({ msg: "received message" });
       const value = evt.data.valueOf();
-      parseMessage(value, {
-        encoding,
-        maxIncomingMessageSize: runConfig.maxIncomingMessageSize
-      }).then((message) => {
-        actor.processMessage(message, conn).catch((error) => {
-          const { code } = deconstructError(
-            error,
-            actor.rLog,
-            {
-              wsEvent: "message"
-            },
-            exposeInternalError
-          );
-          ws.close(1011, code);
+      pendingMessage = pendingMessage.then(async () => {
+        const message = await parseMessage(value, {
+          encoding,
+          maxIncomingMessageSize: runConfig.maxIncomingMessageSize
         });
+        await actor.processMessage(message, conn);
       }).catch((error) => {
-        const { code } = deconstructError(
+        const { group, code } = deconstructError(
           error,
           actor.rLog,
           {
@@ -3469,7 +4021,7 @@ async function handleWebSocketConnect(setWebSocket, {
           },
           exposeInternalError
         );
-        ws.close(1011, code);
+        ws.close(1011, `${group}.${code}`);
       });
     },
     onClose: (event, ws) => {
@@ -3569,7 +4121,7 @@ function logger3() {
 }
 
 // src/manager/gateway.ts
-async function handleWebSocketGatewayPathBased(config6, managerDriver, c, actorPathInfo, getUpgradeWebSocket) {
+async function handleWebSocketGatewayPathBased(config8, managerDriver, c, actorPathInfo, getUpgradeWebSocket) {
   const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
   if (!upgradeWebSocket) {
     throw new WebSocketsNotEnabled();
@@ -3614,13 +4166,13 @@ async function handleHttpGatewayPathBased(managerDriver, c, actorPathInfo) {
     actorPathInfo.actorId
   );
 }
-async function actorGateway(config6, managerDriver, getUpgradeWebSocket, c, next) {
+async function actorGateway(config8, managerDriver, getUpgradeWebSocket, c, next) {
   if (c.req.path.startsWith("/.test/")) {
     return next();
   }
   let strippedPath = c.req.path;
-  if (config6.managerBasePath && strippedPath.startsWith(config6.managerBasePath)) {
-    strippedPath = strippedPath.slice(config6.managerBasePath.length);
+  if (config8.managerBasePath && strippedPath.startsWith(config8.managerBasePath)) {
+    strippedPath = strippedPath.slice(config8.managerBasePath.length);
     if (!strippedPath.startsWith("/")) {
       strippedPath = "/" + strippedPath;
     }
@@ -3635,7 +4187,7 @@ async function actorGateway(config6, managerDriver, getUpgradeWebSocket, c, next
     const isWebSocket = c.req.header("upgrade") === "websocket";
     if (isWebSocket) {
       return await handleWebSocketGatewayPathBased(
-        config6,
+        config8,
         managerDriver,
         c,
         actorPathInfo,
@@ -3650,7 +4202,7 @@ async function actorGateway(config6, managerDriver, getUpgradeWebSocket, c, next
   }
   if (c.req.header("upgrade") === "websocket") {
     return await handleWebSocketGateway(
-      config6,
+      config8,
       managerDriver,
       getUpgradeWebSocket,
       c,
@@ -3659,7 +4211,7 @@ async function actorGateway(config6, managerDriver, getUpgradeWebSocket, c, next
   }
   return await handleHttpGateway(managerDriver, c, next, strippedPath);
 }
-async function handleWebSocketGateway(config6, managerDriver, getUpgradeWebSocket, c, strippedPath) {
+async function handleWebSocketGateway(config8, managerDriver, getUpgradeWebSocket, c, strippedPath) {
   const upgradeWebSocket = getUpgradeWebSocket == null ? void 0 : getUpgradeWebSocket();
   if (!upgradeWebSocket) {
     throw new WebSocketsNotEnabled();
@@ -3801,7 +4353,7 @@ async function createTestWebSocketProxy(proxyToActorWsPromise) {
     promise: clientToProxyWsPromise,
     resolve: clientToProxyWsResolve,
     reject: clientToProxyWsReject
-  } = promiseWithResolvers();
+  } = promiseWithResolvers((reason) => logger3().warn({ msg: "unhandled client websocket promise rejection", reason }));
   try {
     logger3().debug({ msg: "awaiting client websocket promise" });
     proxyToActorWs = await proxyToActorWsPromise;
@@ -3978,14 +4530,14 @@ async function createTestWebSocketProxy(proxyToActorWsPromise) {
 }
 
 // src/manager/router.ts
-function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
-  return createRouter(config6.managerBasePath, (router) => {
+function buildManagerRouter(config8, managerDriver, getUpgradeWebSocket) {
+  return createRouter(config8.managerBasePath, (router) => {
     var _a;
     router.use(
       "*",
       actorGateway.bind(
         void 0,
-        config6,
+        config8,
         managerDriver,
         getUpgradeWebSocket
       )
@@ -4053,7 +4605,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
                 actors.push(actorOutput);
               }
             } else {
-              for (const actorName of Object.keys(config6.use)) {
+              for (const actorName of Object.keys(config8.use)) {
                 const actorOutput = await managerDriver.getForId({
                   c,
                   name: actorName,
@@ -4070,8 +4622,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
           const actorOutput = await managerDriver.getWithKey({
             c,
             name,
-            key: [key]
-            // Convert string to ActorKey array
+            key: deserializeActorKey(key)
           });
           if (actorOutput) {
             actors.push(actorOutput);
@@ -4110,7 +4661,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         responses: buildOpenApiResponses(ActorsListNamesResponseSchema)
       });
       router.openapi(route, async (c) => {
-        const names = buildActorNames(config6);
+        const names = buildActorNames(config8);
         return c.json({
           names
         });
@@ -4134,8 +4685,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         const existingActor = await managerDriver.getWithKey({
           c,
           name: body.name,
-          key: [body.key]
-          // Convert string to ActorKey array
+          key: deserializeActorKey(body.key)
         });
         if (existingActor) {
           return c.json({
@@ -4146,8 +4696,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         const newActor = await managerDriver.getOrCreateWithKey({
           c,
           name: body.name,
-          key: [body.key],
-          // Convert string to ActorKey array
+          key: deserializeActorKey(body.key),
           input: body.input ? cbor6.decode(Buffer.from(body.input, "base64")) : void 0,
           region: void 0
           // Not provided in the request schema
@@ -4172,8 +4721,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         const actorOutput = await managerDriver.createActor({
           c,
           name: body.name,
-          key: [body.key || crypto.randomUUID()],
-          // Generate key if not provided, convert to ActorKey array
+          key: deserializeActorKey(body.key || crypto.randomUUID()),
           input: body.input ? cbor6.decode(Buffer.from(body.input, "base64")) : void 0,
           region: void 0
           // Not provided in the request schema
@@ -4195,17 +4743,17 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         responses: buildOpenApiResponses(ActorsKvGetResponseSchema)
       });
       router.openapi(route, async (c) => {
-        if (getNodeEnv() === "development" && !config6.token) {
+        if (getNodeEnv() === "development" && !config8.token) {
           logger3().warn({
             msg: "RIVET_TOKEN is not set, skipping KV store access checks in development mode. This endpoint will be disabled in production, unless you set the token."
           });
         }
         if (getNodeEnv() !== "development") {
-          if (!config6.token) {
+          if (!config8.token) {
             throw new RestrictedFeature("KV store access");
           }
           if (timingSafeEqual(
-            config6.token,
+            config8.token,
             c.req.header(HEADER_RIVET_TOKEN) || ""
           ) === false) {
             throw new Forbidden();
@@ -4221,7 +4769,7 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         });
       });
     }
-    if (config6.test.enabled) {
+    if (config8.test.enabled) {
       router.post(".test/inline-driver/call", async (c) => {
         const buffer = await c.req.arrayBuffer();
         const { encoding, method, args } = cbor6.decode(new Uint8Array(buffer));
@@ -4380,19 +4928,40 @@ function buildManagerRouter(config6, managerDriver, getUpgradeWebSocket) {
         }
       });
     }
+    if (config8.inspector.enabled) {
+      let inspectorRoot;
+      router.get("/ui/*", async (c, next) => {
+        if (!inspectorRoot) {
+          inspectorRoot = await getInspectorDir();
+        }
+        const root = inspectorRoot;
+        const rewrite = (path) => path.replace(/^\/ui/, "") || "/";
+        return serveStatic({
+          root,
+          rewriteRequestPath: rewrite,
+          onNotFound: async (_path, c2) => {
+            await serveStatic({ root, path: "index.html" })(
+              c2,
+              next
+            );
+          }
+        })(c, next);
+      });
+      router.get("/ui", (c) => c.redirect("/ui/"));
+    }
     router.get("/health", (c) => handleHealthRequest(c));
     router.get(
       "/metadata",
       (c) => handleMetadataRequest(
         c,
-        config6,
+        config8,
         { normal: {} },
-        config6.publicEndpoint,
-        config6.publicNamespace,
-        config6.publicToken
+        config8.publicEndpoint,
+        config8.publicNamespace,
+        config8.publicToken
       )
     );
-    (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(managerDriver, config6, router);
+    (_a = managerDriver.modifyManagerRouter) == null ? void 0 : _a.call(managerDriver, config8, router);
   });
 }
 function createApiActor(actor) {
@@ -4418,18 +4987,18 @@ import * as cbor7 from "cbor-x";
 import { createVersionedDataHandler as createVersionedDataHandler2 } from "vbare";
 
 // dist/schemas/actor-persist/v1.ts
-import * as bare3 from "@rivetkit/bare-ts";
-var config3 = /* @__PURE__ */ bare3.Config({});
+import * as bare4 from "@rivetkit/bare-ts";
+var config4 = /* @__PURE__ */ bare4.Config({});
 function readPersistedSubscription(bc) {
   return {
-    eventName: bare3.readString(bc)
+    eventName: bare4.readString(bc)
   };
 }
 function writePersistedSubscription(bc, x) {
-  bare3.writeString(bc, x.eventName);
+  bare4.writeString(bc, x.eventName);
 }
-function read03(bc) {
-  const len = bare3.readUintSafe(bc);
+function read04(bc) {
+  const len = bare4.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4439,65 +5008,65 @@ function read03(bc) {
   }
   return result;
 }
-function write03(bc, x) {
-  bare3.writeUintSafe(bc, x.length);
+function write04(bc, x) {
+  bare4.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedSubscription(bc, x[i]);
   }
 }
 function readPersistedConnection(bc) {
   return {
-    id: bare3.readString(bc),
-    token: bare3.readString(bc),
-    parameters: bare3.readData(bc),
-    state: bare3.readData(bc),
-    subscriptions: read03(bc),
-    lastSeen: bare3.readU64(bc)
+    id: bare4.readString(bc),
+    token: bare4.readString(bc),
+    parameters: bare4.readData(bc),
+    state: bare4.readData(bc),
+    subscriptions: read04(bc),
+    lastSeen: bare4.readU64(bc)
   };
 }
 function writePersistedConnection(bc, x) {
-  bare3.writeString(bc, x.id);
-  bare3.writeString(bc, x.token);
-  bare3.writeData(bc, x.parameters);
-  bare3.writeData(bc, x.state);
-  write03(bc, x.subscriptions);
-  bare3.writeU64(bc, x.lastSeen);
+  bare4.writeString(bc, x.id);
+  bare4.writeString(bc, x.token);
+  bare4.writeData(bc, x.parameters);
+  bare4.writeData(bc, x.state);
+  write04(bc, x.subscriptions);
+  bare4.writeU64(bc, x.lastSeen);
 }
-function read13(bc) {
-  return bare3.readBool(bc) ? bare3.readData(bc) : null;
+function read14(bc) {
+  return bare4.readBool(bc) ? bare4.readData(bc) : null;
 }
-function write13(bc, x) {
-  bare3.writeBool(bc, x !== null);
+function write14(bc, x) {
+  bare4.writeBool(bc, x !== null);
   if (x !== null) {
-    bare3.writeData(bc, x);
+    bare4.writeData(bc, x);
   }
 }
 function readGenericPersistedScheduleEvent(bc) {
   return {
-    action: bare3.readString(bc),
-    args: read13(bc)
+    action: bare4.readString(bc),
+    args: read14(bc)
   };
 }
 function writeGenericPersistedScheduleEvent(bc, x) {
-  bare3.writeString(bc, x.action);
-  write13(bc, x.args);
+  bare4.writeString(bc, x.action);
+  write14(bc, x.args);
 }
 function readPersistedScheduleEventKind(bc) {
   const offset = bc.offset;
-  const tag = bare3.readU8(bc);
+  const tag = bare4.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
     default: {
       bc.offset = offset;
-      throw new bare3.BareError(offset, "invalid tag");
+      throw new bare4.BareError(offset, "invalid tag");
     }
   }
 }
 function writePersistedScheduleEventKind(bc, x) {
   switch (x.tag) {
     case "GenericPersistedScheduleEvent": {
-      bare3.writeU8(bc, 0);
+      bare4.writeU8(bc, 0);
       writeGenericPersistedScheduleEvent(bc, x.val);
       break;
     }
@@ -4505,18 +5074,18 @@ function writePersistedScheduleEventKind(bc, x) {
 }
 function readPersistedScheduleEvent(bc) {
   return {
-    eventId: bare3.readString(bc),
-    timestamp: bare3.readU64(bc),
+    eventId: bare4.readString(bc),
+    timestamp: bare4.readU64(bc),
     kind: readPersistedScheduleEventKind(bc)
   };
 }
 function writePersistedScheduleEvent(bc, x) {
-  bare3.writeString(bc, x.eventId);
-  bare3.writeU64(bc, x.timestamp);
+  bare4.writeString(bc, x.eventId);
+  bare4.writeU64(bc, x.timestamp);
   writePersistedScheduleEventKind(bc, x.kind);
 }
-function read2(bc) {
-  const len = bare3.readUintSafe(bc);
+function read22(bc) {
+  const len = bare4.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4526,14 +5095,14 @@ function read2(bc) {
   }
   return result;
 }
-function write2(bc, x) {
-  bare3.writeUintSafe(bc, x.length);
+function write22(bc, x) {
+  bare4.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedConnection(bc, x[i]);
   }
 }
-function read3(bc) {
-  const len = bare3.readUintSafe(bc);
+function read32(bc) {
+  const len = bare4.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4543,58 +5112,58 @@ function read3(bc) {
   }
   return result;
 }
-function write3(bc, x) {
-  bare3.writeUintSafe(bc, x.length);
+function write32(bc, x) {
+  bare4.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedScheduleEvent(bc, x[i]);
   }
 }
 function readPersistedActor(bc) {
   return {
-    input: read13(bc),
-    hasInitialized: bare3.readBool(bc),
-    state: bare3.readData(bc),
-    connections: read2(bc),
-    scheduledEvents: read3(bc)
+    input: read14(bc),
+    hasInitialized: bare4.readBool(bc),
+    state: bare4.readData(bc),
+    connections: read22(bc),
+    scheduledEvents: read32(bc)
   };
 }
 function writePersistedActor(bc, x) {
-  write13(bc, x.input);
-  bare3.writeBool(bc, x.hasInitialized);
-  bare3.writeData(bc, x.state);
-  write2(bc, x.connections);
-  write3(bc, x.scheduledEvents);
+  write14(bc, x.input);
+  bare4.writeBool(bc, x.hasInitialized);
+  bare4.writeData(bc, x.state);
+  write22(bc, x.connections);
+  write32(bc, x.scheduledEvents);
 }
 function encodePersistedActor(x) {
-  const bc = new bare3.ByteCursor(
-    new Uint8Array(config3.initialBufferLength),
-    config3
+  const bc = new bare4.ByteCursor(
+    new Uint8Array(config4.initialBufferLength),
+    config4
   );
   writePersistedActor(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodePersistedActor(bytes) {
-  const bc = new bare3.ByteCursor(bytes, config3);
+  const bc = new bare4.ByteCursor(bytes, config4);
   const result = readPersistedActor(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare3.BareError(bc.offset, "remaining bytes");
+    throw new bare4.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
 
 // dist/schemas/actor-persist/v2.ts
-import * as bare4 from "@rivetkit/bare-ts";
-var config4 = /* @__PURE__ */ bare4.Config({});
+import * as bare5 from "@rivetkit/bare-ts";
+var config5 = /* @__PURE__ */ bare5.Config({});
 function readPersistedSubscription2(bc) {
   return {
-    eventName: bare4.readString(bc)
+    eventName: bare5.readString(bc)
   };
 }
 function writePersistedSubscription2(bc, x) {
-  bare4.writeString(bc, x.eventName);
+  bare5.writeString(bc, x.eventName);
 }
-function read04(bc) {
-  const len = bare4.readUintSafe(bc);
+function read05(bc) {
+  const len = bare5.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4604,67 +5173,67 @@ function read04(bc) {
   }
   return result;
 }
-function write04(bc, x) {
-  bare4.writeUintSafe(bc, x.length);
+function write05(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedSubscription2(bc, x[i]);
   }
 }
-function read14(bc) {
-  return bare4.readBool(bc) ? bare4.readData(bc) : null;
+function read15(bc) {
+  return bare5.readBool(bc) ? bare5.readData(bc) : null;
 }
-function write14(bc, x) {
-  bare4.writeBool(bc, x !== null);
+function write15(bc, x) {
+  bare5.writeBool(bc, x !== null);
   if (x !== null) {
-    bare4.writeData(bc, x);
+    bare5.writeData(bc, x);
   }
 }
 function readPersistedConnection2(bc) {
   return {
-    id: bare4.readString(bc),
-    token: bare4.readString(bc),
-    parameters: bare4.readData(bc),
-    state: bare4.readData(bc),
-    subscriptions: read04(bc),
-    lastSeen: bare4.readI64(bc),
-    hibernatableRequestId: read14(bc)
-  };
-}
-function writePersistedConnection2(bc, x) {
-  bare4.writeString(bc, x.id);
-  bare4.writeString(bc, x.token);
-  bare4.writeData(bc, x.parameters);
-  bare4.writeData(bc, x.state);
-  write04(bc, x.subscriptions);
-  bare4.writeI64(bc, x.lastSeen);
-  write14(bc, x.hibernatableRequestId);
+    id: bare5.readString(bc),
+    token: bare5.readString(bc),
+    parameters: bare5.readData(bc),
+    state: bare5.readData(bc),
+    subscriptions: read05(bc),
+    lastSeen: bare5.readI64(bc),
+    hibernatableRequestId: read15(bc)
+  };
+}
+function writePersistedConnection2(bc, x) {
+  bare5.writeString(bc, x.id);
+  bare5.writeString(bc, x.token);
+  bare5.writeData(bc, x.parameters);
+  bare5.writeData(bc, x.state);
+  write05(bc, x.subscriptions);
+  bare5.writeI64(bc, x.lastSeen);
+  write15(bc, x.hibernatableRequestId);
 }
 function readGenericPersistedScheduleEvent2(bc) {
   return {
-    action: bare4.readString(bc),
-    args: read14(bc)
+    action: bare5.readString(bc),
+    args: read15(bc)
   };
 }
 function writeGenericPersistedScheduleEvent2(bc, x) {
-  bare4.writeString(bc, x.action);
-  write14(bc, x.args);
+  bare5.writeString(bc, x.action);
+  write15(bc, x.args);
 }
 function readPersistedScheduleEventKind2(bc) {
   const offset = bc.offset;
-  const tag = bare4.readU8(bc);
+  const tag = bare5.readU8(bc);
   switch (tag) {
     case 0:
       return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent2(bc) };
     default: {
       bc.offset = offset;
-      throw new bare4.BareError(offset, "invalid tag");
+      throw new bare5.BareError(offset, "invalid tag");
     }
   }
 }
 function writePersistedScheduleEventKind2(bc, x) {
   switch (x.tag) {
     case "GenericPersistedScheduleEvent": {
-      bare4.writeU8(bc, 0);
+      bare5.writeU8(bc, 0);
       writeGenericPersistedScheduleEvent2(bc, x.val);
       break;
     }
@@ -4672,30 +5241,30 @@ function writePersistedScheduleEventKind2(bc, x) {
 }
 function readPersistedScheduleEvent2(bc) {
   return {
-    eventId: bare4.readString(bc),
-    timestamp: bare4.readI64(bc),
+    eventId: bare5.readString(bc),
+    timestamp: bare5.readI64(bc),
     kind: readPersistedScheduleEventKind2(bc)
   };
 }
 function writePersistedScheduleEvent2(bc, x) {
-  bare4.writeString(bc, x.eventId);
-  bare4.writeI64(bc, x.timestamp);
+  bare5.writeString(bc, x.eventId);
+  bare5.writeI64(bc, x.timestamp);
   writePersistedScheduleEventKind2(bc, x.kind);
 }
 function readPersistedHibernatableWebSocket(bc) {
   return {
-    requestId: bare4.readData(bc),
-    lastSeenTimestamp: bare4.readI64(bc),
-    msgIndex: bare4.readI64(bc)
+    requestId: bare5.readData(bc),
+    lastSeenTimestamp: bare5.readI64(bc),
+    msgIndex: bare5.readI64(bc)
   };
 }
 function writePersistedHibernatableWebSocket(bc, x) {
-  bare4.writeData(bc, x.requestId);
-  bare4.writeI64(bc, x.lastSeenTimestamp);
-  bare4.writeI64(bc, x.msgIndex);
+  bare5.writeData(bc, x.requestId);
+  bare5.writeI64(bc, x.lastSeenTimestamp);
+  bare5.writeI64(bc, x.msgIndex);
 }
-function read22(bc) {
-  const len = bare4.readUintSafe(bc);
+function read23(bc) {
+  const len = bare5.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4705,14 +5274,14 @@ function read22(bc) {
   }
   return result;
 }
-function write22(bc, x) {
-  bare4.writeUintSafe(bc, x.length);
+function write23(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedConnection2(bc, x[i]);
   }
 }
-function read32(bc) {
-  const len = bare4.readUintSafe(bc);
+function read33(bc) {
+  const len = bare5.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4722,14 +5291,14 @@ function read32(bc) {
   }
   return result;
 }
-function write32(bc, x) {
-  bare4.writeUintSafe(bc, x.length);
+function write33(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedScheduleEvent2(bc, x[i]);
   }
 }
-function read4(bc) {
-  const len = bare4.readUintSafe(bc);
+function read42(bc) {
+  const len = bare5.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4739,80 +5308,80 @@ function read4(bc) {
   }
   return result;
 }
-function write4(bc, x) {
-  bare4.writeUintSafe(bc, x.length);
+function write42(bc, x) {
+  bare5.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writePersistedHibernatableWebSocket(bc, x[i]);
   }
 }
 function readPersistedActor2(bc) {
   return {
-    input: read14(bc),
-    hasInitialized: bare4.readBool(bc),
-    state: bare4.readData(bc),
-    connections: read22(bc),
-    scheduledEvents: read32(bc),
-    hibernatableWebSockets: read4(bc)
+    input: read15(bc),
+    hasInitialized: bare5.readBool(bc),
+    state: bare5.readData(bc),
+    connections: read23(bc),
+    scheduledEvents: read33(bc),
+    hibernatableWebSockets: read42(bc)
   };
 }
 function writePersistedActor2(bc, x) {
-  write14(bc, x.input);
-  bare4.writeBool(bc, x.hasInitialized);
-  bare4.writeData(bc, x.state);
-  write22(bc, x.connections);
-  write32(bc, x.scheduledEvents);
-  write4(bc, x.hibernatableWebSockets);
+  write15(bc, x.input);
+  bare5.writeBool(bc, x.hasInitialized);
+  bare5.writeData(bc, x.state);
+  write23(bc, x.connections);
+  write33(bc, x.scheduledEvents);
+  write42(bc, x.hibernatableWebSockets);
 }
 function encodePersistedActor2(x) {
-  const bc = new bare4.ByteCursor(
-    new Uint8Array(config4.initialBufferLength),
-    config4
+  const bc = new bare5.ByteCursor(
+    new Uint8Array(config5.initialBufferLength),
+    config5
   );
   writePersistedActor2(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodePersistedActor2(bytes) {
-  const bc = new bare4.ByteCursor(bytes, config4);
+  const bc = new bare5.ByteCursor(bytes, config5);
   const result = readPersistedActor2(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare4.BareError(bc.offset, "remaining bytes");
+    throw new bare5.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
 
 // dist/schemas/actor-persist/v3.ts
-import * as bare5 from "@rivetkit/bare-ts";
-var config5 = /* @__PURE__ */ bare5.Config({});
+import * as bare6 from "@rivetkit/bare-ts";
+var config6 = /* @__PURE__ */ bare6.Config({});
 function readGatewayId(bc) {
-  return bare5.readFixedData(bc, 4);
+  return bare6.readFixedData(bc, 4);
 }
 function writeGatewayId(bc, x) {
   assert(x.byteLength === 4);
-  bare5.writeFixedData(bc, x);
+  bare6.writeFixedData(bc, x);
 }
 function readRequestId(bc) {
-  return bare5.readFixedData(bc, 4);
+  return bare6.readFixedData(bc, 4);
 }
 function writeRequestId(bc, x) {
   assert(x.byteLength === 4);
-  bare5.writeFixedData(bc, x);
+  bare6.writeFixedData(bc, x);
 }
 function readCbor(bc) {
-  return bare5.readData(bc);
+  return bare6.readData(bc);
 }
 function writeCbor(bc, x) {
-  bare5.writeData(bc, x);
+  bare6.writeData(bc, x);
 }
 function readSubscription(bc) {
   return {
-    eventName: bare5.readString(bc)
+    eventName: bare6.readString(bc)
   };
 }
 function writeSubscription(bc, x) {
-  bare5.writeString(bc, x.eventName);
+  bare6.writeString(bc, x.eventName);
 }
-function read05(bc) {
-  const len = bare5.readUintSafe(bc);
+function read06(bc) {
+  const len = bare6.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4822,100 +5391,100 @@ function read05(bc) {
   }
   return result;
 }
-function write05(bc, x) {
-  bare5.writeUintSafe(bc, x.length);
+function write06(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeSubscription(bc, x[i]);
   }
 }
-function read15(bc) {
-  const len = bare5.readUintSafe(bc);
+function read16(bc) {
+  const len = bare6.readUintSafe(bc);
   const result = /* @__PURE__ */ new Map();
   for (let i = 0; i < len; i++) {
     const offset = bc.offset;
-    const key = bare5.readString(bc);
+    const key = bare6.readString(bc);
     if (result.has(key)) {
       bc.offset = offset;
-      throw new bare5.BareError(offset, "duplicated key");
+      throw new bare6.BareError(offset, "duplicated key");
     }
-    result.set(key, bare5.readString(bc));
+    result.set(key, bare6.readString(bc));
   }
   return result;
 }
-function write15(bc, x) {
-  bare5.writeUintSafe(bc, x.size);
+function write16(bc, x) {
+  bare6.writeUintSafe(bc, x.size);
   for (const kv of x) {
-    bare5.writeString(bc, kv[0]);
-    bare5.writeString(bc, kv[1]);
+    bare6.writeString(bc, kv[0]);
+    bare6.writeString(bc, kv[1]);
   }
 }
 function readConn(bc) {
   return {
-    id: bare5.readString(bc),
+    id: bare6.readString(bc),
     parameters: readCbor(bc),
     state: readCbor(bc),
-    subscriptions: read05(bc),
+    subscriptions: read06(bc),
     gatewayId: readGatewayId(bc),
     requestId: readRequestId(bc),
-    serverMessageIndex: bare5.readU16(bc),
-    clientMessageIndex: bare5.readU16(bc),
-    requestPath: bare5.readString(bc),
-    requestHeaders: read15(bc)
+    serverMessageIndex: bare6.readU16(bc),
+    clientMessageIndex: bare6.readU16(bc),
+    requestPath: bare6.readString(bc),
+    requestHeaders: read16(bc)
   };
 }
 function writeConn(bc, x) {
-  bare5.writeString(bc, x.id);
+  bare6.writeString(bc, x.id);
   writeCbor(bc, x.parameters);
   writeCbor(bc, x.state);
-  write05(bc, x.subscriptions);
+  write06(bc, x.subscriptions);
   writeGatewayId(bc, x.gatewayId);
   writeRequestId(bc, x.requestId);
-  bare5.writeU16(bc, x.serverMessageIndex);
-  bare5.writeU16(bc, x.clientMessageIndex);
-  bare5.writeString(bc, x.requestPath);
-  write15(bc, x.requestHeaders);
+  bare6.writeU16(bc, x.serverMessageIndex);
+  bare6.writeU16(bc, x.clientMessageIndex);
+  bare6.writeString(bc, x.requestPath);
+  write16(bc, x.requestHeaders);
 }
 function encodeConn(x) {
-  const bc = new bare5.ByteCursor(
-    new Uint8Array(config5.initialBufferLength),
-    config5
+  const bc = new bare6.ByteCursor(
+    new Uint8Array(config6.initialBufferLength),
+    config6
   );
   writeConn(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodeConn(bytes) {
-  const bc = new bare5.ByteCursor(bytes, config5);
+  const bc = new bare6.ByteCursor(bytes, config6);
   const result = readConn(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare5.BareError(bc.offset, "remaining bytes");
+    throw new bare6.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
-function read23(bc) {
-  return bare5.readBool(bc) ? readCbor(bc) : null;
+function read24(bc) {
+  return bare6.readBool(bc) ? readCbor(bc) : null;
 }
-function write23(bc, x) {
-  bare5.writeBool(bc, x !== null);
+function write24(bc, x) {
+  bare6.writeBool(bc, x !== null);
   if (x !== null) {
     writeCbor(bc, x);
   }
 }
 function readScheduleEvent(bc) {
   return {
-    eventId: bare5.readString(bc),
-    timestamp: bare5.readI64(bc),
-    action: bare5.readString(bc),
-    args: read23(bc)
+    eventId: bare6.readString(bc),
+    timestamp: bare6.readI64(bc),
+    action: bare6.readString(bc),
+    args: read24(bc)
   };
 }
 function writeScheduleEvent(bc, x) {
-  bare5.writeString(bc, x.eventId);
-  bare5.writeI64(bc, x.timestamp);
-  bare5.writeString(bc, x.action);
-  write23(bc, x.args);
+  bare6.writeString(bc, x.eventId);
+  bare6.writeI64(bc, x.timestamp);
+  bare6.writeString(bc, x.action);
+  write24(bc, x.args);
 }
-function read33(bc) {
-  const len = bare5.readUintSafe(bc);
+function read34(bc) {
+  const len = bare6.readUintSafe(bc);
   if (len === 0) {
     return [];
   }
@@ -4925,39 +5494,39 @@ function read33(bc) {
   }
   return result;
 }
-function write33(bc, x) {
-  bare5.writeUintSafe(bc, x.length);
+function write34(bc, x) {
+  bare6.writeUintSafe(bc, x.length);
   for (let i = 0; i < x.length; i++) {
     writeScheduleEvent(bc, x[i]);
   }
 }
 function readActor(bc) {
   return {
-    input: read23(bc),
-    hasInitialized: bare5.readBool(bc),
+    input: read24(bc),
+    hasInitialized: bare6.readBool(bc),
     state: readCbor(bc),
-    scheduledEvents: read33(bc)
+    scheduledEvents: read34(bc)
   };
 }
 function writeActor(bc, x) {
-  write23(bc, x.input);
-  bare5.writeBool(bc, x.hasInitialized);
+  write24(bc, x.input);
+  bare6.writeBool(bc, x.hasInitialized);
   writeCbor(bc, x.state);
-  write33(bc, x.scheduledEvents);
+  write34(bc, x.scheduledEvents);
 }
 function encodeActor(x) {
-  const bc = new bare5.ByteCursor(
-    new Uint8Array(config5.initialBufferLength),
-    config5
+  const bc = new bare6.ByteCursor(
+    new Uint8Array(config6.initialBufferLength),
+    config6
   );
   writeActor(bc, x);
   return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
 }
 function decodeActor(bytes) {
-  const bc = new bare5.ByteCursor(bytes, config5);
+  const bc = new bare6.ByteCursor(bytes, config6);
   const result = readActor(bc);
   if (bc.offset < bc.view.byteLength) {
-    throw new bare5.BareError(bc.offset, "remaining bytes");
+    throw new bare6.BareError(bc.offset, "remaining bytes");
   }
   return result;
 }
@@ -4965,8 +5534,282 @@ function assert(condition, message) {
   if (!condition) throw new Error(message ?? "Assertion failed");
 }
 
+// dist/schemas/actor-persist/v4.ts
+import * as bare7 from "@rivetkit/bare-ts";
+var config7 = /* @__PURE__ */ bare7.Config({});
+function readGatewayId2(bc) {
+  return bare7.readFixedData(bc, 4);
+}
+function writeGatewayId2(bc, x) {
+  assert2(x.byteLength === 4);
+  bare7.writeFixedData(bc, x);
+}
+function readRequestId2(bc) {
+  return bare7.readFixedData(bc, 4);
+}
+function writeRequestId2(bc, x) {
+  assert2(x.byteLength === 4);
+  bare7.writeFixedData(bc, x);
+}
+function readCbor2(bc) {
+  return bare7.readData(bc);
+}
+function writeCbor2(bc, x) {
+  bare7.writeData(bc, x);
+}
+function readSubscription2(bc) {
+  return {
+    eventName: bare7.readString(bc)
+  };
+}
+function writeSubscription2(bc, x) {
+  bare7.writeString(bc, x.eventName);
+}
+function read07(bc) {
+  const len = bare7.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSubscription2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSubscription2(bc);
+  }
+  return result;
+}
+function write07(bc, x) {
+  bare7.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSubscription2(bc, x[i]);
+  }
+}
+function read17(bc) {
+  const len = bare7.readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = bare7.readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new bare7.BareError(offset, "duplicated key");
+    }
+    result.set(key, bare7.readString(bc));
+  }
+  return result;
+}
+function write17(bc, x) {
+  bare7.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare7.writeString(bc, kv[0]);
+    bare7.writeString(bc, kv[1]);
+  }
+}
+function readConn2(bc) {
+  return {
+    id: bare7.readString(bc),
+    parameters: readCbor2(bc),
+    state: readCbor2(bc),
+    subscriptions: read07(bc),
+    gatewayId: readGatewayId2(bc),
+    requestId: readRequestId2(bc),
+    serverMessageIndex: bare7.readU16(bc),
+    clientMessageIndex: bare7.readU16(bc),
+    requestPath: bare7.readString(bc),
+    requestHeaders: read17(bc)
+  };
+}
+function writeConn2(bc, x) {
+  bare7.writeString(bc, x.id);
+  writeCbor2(bc, x.parameters);
+  writeCbor2(bc, x.state);
+  write07(bc, x.subscriptions);
+  writeGatewayId2(bc, x.gatewayId);
+  writeRequestId2(bc, x.requestId);
+  bare7.writeU16(bc, x.serverMessageIndex);
+  bare7.writeU16(bc, x.clientMessageIndex);
+  bare7.writeString(bc, x.requestPath);
+  write17(bc, x.requestHeaders);
+}
+function encodeConn2(x) {
+  const bc = new bare7.ByteCursor(
+    new Uint8Array(config7.initialBufferLength),
+    config7
+  );
+  writeConn2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeConn2(bytes) {
+  const bc = new bare7.ByteCursor(bytes, config7);
+  const result = readConn2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare7.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read25(bc) {
+  return bare7.readBool(bc) ? readCbor2(bc) : null;
+}
+function write25(bc, x) {
+  bare7.writeBool(bc, x !== null);
+  if (x !== null) {
+    writeCbor2(bc, x);
+  }
+}
+function readScheduleEvent2(bc) {
+  return {
+    eventId: bare7.readString(bc),
+    timestamp: bare7.readI64(bc),
+    action: bare7.readString(bc),
+    args: read25(bc)
+  };
+}
+function writeScheduleEvent2(bc, x) {
+  bare7.writeString(bc, x.eventId);
+  bare7.writeI64(bc, x.timestamp);
+  bare7.writeString(bc, x.action);
+  write25(bc, x.args);
+}
+function read35(bc) {
+  const len = bare7.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readScheduleEvent2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readScheduleEvent2(bc);
+  }
+  return result;
+}
+function write35(bc, x) {
+  bare7.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeScheduleEvent2(bc, x[i]);
+  }
+}
+function readActor2(bc) {
+  return {
+    input: read25(bc),
+    hasInitialized: bare7.readBool(bc),
+    state: readCbor2(bc),
+    scheduledEvents: read35(bc)
+  };
+}
+function writeActor2(bc, x) {
+  write25(bc, x.input);
+  bare7.writeBool(bc, x.hasInitialized);
+  writeCbor2(bc, x.state);
+  write35(bc, x.scheduledEvents);
+}
+function encodeActor2(x) {
+  const bc = new bare7.ByteCursor(
+    new Uint8Array(config7.initialBufferLength),
+    config7
+  );
+  writeActor2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActor2(bytes) {
+  const bc = new bare7.ByteCursor(bytes, config7);
+  const result = readActor2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare7.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readQueueMetadata(bc) {
+  return {
+    nextId: bare7.readU64(bc),
+    size: bare7.readU32(bc)
+  };
+}
+function writeQueueMetadata(bc, x) {
+  bare7.writeU64(bc, x.nextId);
+  bare7.writeU32(bc, x.size);
+}
+function encodeQueueMetadata(x) {
+  const bc = new bare7.ByteCursor(
+    new Uint8Array(config7.initialBufferLength),
+    config7
+  );
+  writeQueueMetadata(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeQueueMetadata(bytes) {
+  const bc = new bare7.ByteCursor(bytes, config7);
+  const result = readQueueMetadata(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare7.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read43(bc) {
+  return bare7.readBool(bc) ? bare7.readU32(bc) : null;
+}
+function write43(bc, x) {
+  bare7.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare7.writeU32(bc, x);
+  }
+}
+function read5(bc) {
+  return bare7.readBool(bc) ? bare7.readI64(bc) : null;
+}
+function write5(bc, x) {
+  bare7.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare7.writeI64(bc, x);
+  }
+}
+function read6(bc) {
+  return bare7.readBool(bc) ? bare7.readBool(bc) : null;
+}
+function write6(bc, x) {
+  bare7.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare7.writeBool(bc, x);
+  }
+}
+function readQueueMessage(bc) {
+  return {
+    name: bare7.readString(bc),
+    body: readCbor2(bc),
+    createdAt: bare7.readI64(bc),
+    failureCount: read43(bc),
+    availableAt: read5(bc),
+    inFlight: read6(bc),
+    inFlightAt: read5(bc)
+  };
+}
+function writeQueueMessage(bc, x) {
+  bare7.writeString(bc, x.name);
+  writeCbor2(bc, x.body);
+  bare7.writeI64(bc, x.createdAt);
+  write43(bc, x.failureCount);
+  write5(bc, x.availableAt);
+  write6(bc, x.inFlight);
+  write5(bc, x.inFlightAt);
+}
+function encodeQueueMessage(x) {
+  const bc = new bare7.ByteCursor(
+    new Uint8Array(config7.initialBufferLength),
+    config7
+  );
+  writeQueueMessage(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeQueueMessage(bytes) {
+  const bc = new bare7.ByteCursor(bytes, config7);
+  const result = readQueueMessage(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare7.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function assert2(condition, message) {
+  if (!condition) throw new Error(message ?? "Assertion failed");
+}
+
 // src/schemas/actor-persist/versioned.ts
-var CURRENT_VERSION2 = 3;
+var CURRENT_VERSION3 = 4;
 var v1ToV22 = (v1Data) => ({
   ...v1Data,
   connections: v1Data.connections.map((conn) => ({
@@ -4975,7 +5818,7 @@ var v1ToV22 = (v1Data) => ({
   })),
   hibernatableWebSockets: []
 });
-var v2ToV3 = (v2Data) => {
+var v2ToV32 = (v2Data) => {
   const scheduledEvents = v2Data.scheduledEvents.map(
     (event) => {
       if (event.kind.tag === "GenericPersistedScheduleEvent") {
@@ -4996,7 +5839,13 @@ var v2ToV3 = (v2Data) => {
     scheduledEvents
   };
 };
-var v3ToV2 = (v3Data) => {
+var v3ToV4 = (v3Data) => {
+  return v3Data;
+};
+var v4ToV3 = (v4Data) => {
+  return v4Data;
+};
+var v3ToV22 = (v3Data) => {
   const scheduledEvents = v3Data.scheduledEvents.map((event) => ({
     eventId: event.eventId,
     timestamp: event.timestamp,
@@ -5038,6 +5887,8 @@ var ACTOR_VERSIONED = createVersionedDataHandler2({
         return decodePersistedActor2(bytes);
       case 3:
         return decodeActor(bytes);
+      case 4:
+        return decodeActor2(bytes);
       default:
         throw new Error(`Unknown version ${version}`);
     }
@@ -5050,18 +5901,28 @@ var ACTOR_VERSIONED = createVersionedDataHandler2({
         return encodePersistedActor2(data);
       case 3:
         return encodeActor(data);
+      case 4:
+        return encodeActor2(data);
       default:
         throw new Error(`Unknown version ${version}`);
     }
   },
-  deserializeConverters: () => [v1ToV22, v2ToV3],
-  serializeConverters: () => [v3ToV2, v2ToV12]
+  deserializeConverters: () => [v1ToV22, v2ToV32, v3ToV4],
+  serializeConverters: () => [v4ToV3, v3ToV22, v2ToV12]
 });
+var v3ConnToV4 = (v3Data) => {
+  return v3Data;
+};
+var v4ConnToV3 = (v4Data) => {
+  return v4Data;
+};
 var CONN_VERSIONED = createVersionedDataHandler2({
   deserializeVersion: (bytes, version) => {
     switch (version) {
       case 3:
         return decodeConn(bytes);
+      case 4:
+        return decodeConn2(bytes);
       default:
         throw new Error(
           `Conn type only exists in version 3+, got version ${version}`
@@ -5072,12 +5933,62 @@ var CONN_VERSIONED = createVersionedDataHandler2({
     switch (version) {
       case 3:
         return encodeConn(data);
+      case 4:
+        return encodeConn2(data);
       default:
         throw new Error(
           `Conn type only exists in version 3+, got version ${version}`
         );
     }
   },
+  deserializeConverters: () => [v3ConnToV4],
+  serializeConverters: () => [v4ConnToV3]
+});
+var QUEUE_METADATA_VERSIONED = createVersionedDataHandler2({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 4:
+        return decodeQueueMetadata(bytes);
+      default:
+        throw new Error(
+          `QueueMetadata type only exists in version 4+, got version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 4:
+        return encodeQueueMetadata(data);
+      default:
+        throw new Error(
+          `QueueMetadata type only exists in version 4+, got version ${version}`
+        );
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+var QUEUE_MESSAGE_VERSIONED = createVersionedDataHandler2({
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 4:
+        return decodeQueueMessage(bytes);
+      default:
+        throw new Error(
+          `QueueMessage type only exists in version 4+, got version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 4:
+        return encodeQueueMessage(data);
+      default:
+        throw new Error(
+          `QueueMessage type only exists in version 4+, got version ${version}`
+        );
+    }
+  },
   deserializeConverters: () => [],
   serializeConverters: () => []
 });
@@ -5092,7 +6003,7 @@ function serializeEmptyPersistData(input) {
   };
   return ACTOR_VERSIONED.serializeWithEmbeddedVersion(
     persistData,
-    CURRENT_VERSION2
+    CURRENT_VERSION3
   );
 }
 function getInitialActorKvState(input) {
@@ -5102,28 +6013,25 @@ function getInitialActorKvState(input) {
 
 export {
   createHttpDriver,
-  CURRENT_VERSION,
+  CURRENT_VERSION2 as CURRENT_VERSION,
   TO_SERVER_VERSIONED2 as TO_SERVER_VERSIONED,
   TO_CLIENT_VERSIONED2 as TO_CLIENT_VERSIONED,
   HTTP_ACTION_REQUEST_VERSIONED,
   HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_QUEUE_SEND_REQUEST_VERSIONED,
+  HTTP_QUEUE_SEND_RESPONSE_VERSIONED,
   HTTP_RESPONSE_ERROR_VERSIONED,
   ToClientSchema,
   ToServerSchema,
   HttpActionRequestSchema,
   HttpActionResponseSchema,
+  HttpQueueSendRequestSchema,
+  HttpQueueSendResponseSchema,
   HttpResponseErrorSchema,
   uint8ArrayToBase64,
   contentTypeForEncoding,
   serializeWithEncoding,
   deserializeWithEncoding,
-  loggerWithoutContext,
-  assertUnreachable2 as assertUnreachable,
-  DeadlineError,
-  deadline,
-  generateSecureToken,
-  isStatePath,
-  isConnStatePath,
   EncodingSchema,
   CachedSerializer,
   jsonStringifyCompat,
@@ -5133,14 +6041,12 @@ export {
   CONN_STATE_MANAGER_SYMBOL,
   CONN_SEND_MESSAGE_SYMBOL,
   Conn,
-  KEYS,
-  makeConnKey,
-  ActorKv,
-  ActorContext,
   ActionContext,
-  CURRENT_VERSION2,
+  CURRENT_VERSION3 as CURRENT_VERSION2,
   ACTOR_VERSIONED,
   CONN_VERSIONED,
+  QUEUE_METADATA_VERSIONED,
+  QUEUE_MESSAGE_VERSIONED,
   BeforeConnectContext,
   ConnectContext,
   CreateConnStateContext,
@@ -5170,6 +6076,7 @@ export {
   WS_TEST_PROTOCOL_PATH,
   ALLOWED_PUBLIC_HEADERS,
   handleAction,
+  handleQueueSend,
   handleRawRequest,
   ENGINE_PORT,
   ENGINE_ENDPOINT,
@@ -5190,11 +6097,22 @@ export {
   handleRouteError,
   handleMetadataRequest,
   handleHealthRequest,
+  inspectorLogger,
+  timingSafeEqual,
   routeWebSocket,
   parseWebSocketProtocols,
   truncateRawWebSocketPathPrefix,
+  getRequireFn,
+  importNodeDependencies,
+  getNodeCrypto,
+  getNodeFsSync,
+  getNodeFs,
+  getNodePath,
+  getNodeOs,
+  getNodeChildProcess,
+  getNodeStream,
   createRouter,
   buildManagerRouter,
   getInitialActorKvState
 };
-//# sourceMappingURL=chunk-GMAVRZSF.js.map
+//# sourceMappingURL=chunk-M2T62AZQ.js.map