rivetkit 2.0.1 → 2.0.3

package/dist/tsup/chunk-4NSUQZ2H.js

@@ -0,0 +1,1790 @@
+import {
+  getLogger
+} from "./chunk-XFSS33EQ.js";
+import {
+  assertUnreachable,
+  bufferToArrayBuffer,
+  deconstructError,
+  stringifyError
+} from "./chunk-3H7O2A7I.js";
+import {
+  ConnNotFound,
+  ConnStateNotEnabled,
+  IncorrectConnToken,
+  InvalidEncoding,
+  InvalidParams,
+  InvalidQueryJSON,
+  InvalidRequest,
+  MalformedMessage,
+  MessageTooLong,
+  Unreachable,
+  Unsupported
+} from "./chunk-INGJP237.js";
+
+// src/actor/connection.ts
+import * as cbor2 from "cbor-x";
+
+// src/common/versioned-data.ts
+var VersionedDataHandler = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  serializeWithEmbeddedVersion(data) {
+    const versioned = {
+      version: this.config.currentVersion,
+      data: this.config.serializeVersion(data)
+    };
+    return this.embedVersion(versioned);
+  }
+  deserializeWithEmbeddedVersion(bytes) {
+    const versioned = this.extractVersion(bytes);
+    return this.deserialize(versioned.data, versioned.version);
+  }
+  serialize(data, version) {
+    return this.config.serializeVersion(data);
+  }
+  deserialize(bytes, version) {
+    if (version === this.config.currentVersion) {
+      return this.config.deserializeVersion(bytes);
+    }
+    if (version > this.config.currentVersion) {
+      throw new Error(
+        `Cannot decode data from version ${version}, current version is ${this.config.currentVersion}`
+      );
+    }
+    let currentData = this.config.deserializeVersion(bytes);
+    let currentVersion = version;
+    while (currentVersion < this.config.currentVersion) {
+      const migration = this.config.migrations.get(currentVersion);
+      if (!migration) {
+        throw new Error(
+          `No migration found from version ${currentVersion} to ${currentVersion + 1}`
+        );
+      }
+      currentData = migration(currentData);
+      currentVersion++;
+    }
+    return currentData;
+  }
+  embedVersion(data) {
+    const versionBytes = new Uint8Array(4);
+    new DataView(versionBytes.buffer).setUint32(0, data.version, true);
+    const result = new Uint8Array(versionBytes.length + data.data.length);
+    result.set(versionBytes);
+    result.set(data.data, versionBytes.length);
+    return result;
+  }
+  extractVersion(bytes) {
+    if (bytes.length < 4) {
+      throw new Error("Invalid versioned data: too short");
+    }
+    const version = new DataView(bytes.buffer, bytes.byteOffset).getUint32(
+      0,
+      true
+    );
+    const data = bytes.slice(4);
+    return { version, data };
+  }
+};
+function createVersionedDataHandler(config2) {
+  return new VersionedDataHandler(config2);
+}
+
+// dist/schemas/client-protocol/v1.ts
+import * as bare from "@bare-ts/lib";
+var config = /* @__PURE__ */ bare.Config({});
+function readInit(bc) {
+  return {
+    actorId: bare.readString(bc),
+    connectionId: bare.readString(bc),
+    connectionToken: bare.readString(bc)
+  };
+}
+function writeInit(bc, x) {
+  bare.writeString(bc, x.actorId);
+  bare.writeString(bc, x.connectionId);
+  bare.writeString(bc, x.connectionToken);
+}
+function read0(bc) {
+  return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write0(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare.writeData(bc, x);
+  }
+}
+function read1(bc) {
+  return bare.readBool(bc) ? bare.readUint(bc) : null;
+}
+function write1(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare.writeUint(bc, x);
+  }
+}
+function readError(bc) {
+  return {
+    code: bare.readString(bc),
+    message: bare.readString(bc),
+    metadata: read0(bc),
+    actionId: read1(bc)
+  };
+}
+function writeError(bc, x) {
+  bare.writeString(bc, x.code);
+  bare.writeString(bc, x.message);
+  write0(bc, x.metadata);
+  write1(bc, x.actionId);
+}
+function readActionResponse(bc) {
+  return {
+    id: bare.readUint(bc),
+    output: bare.readData(bc)
+  };
+}
+function writeActionResponse(bc, x) {
+  bare.writeUint(bc, x.id);
+  bare.writeData(bc, x.output);
+}
+function readEvent(bc) {
+  return {
+    name: bare.readString(bc),
+    args: bare.readData(bc)
+  };
+}
+function writeEvent(bc, x) {
+  bare.writeString(bc, x.name);
+  bare.writeData(bc, x.args);
+}
+function readToClientBody(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "Init", val: readInit(bc) };
+    case 1:
+      return { tag: "Error", val: readError(bc) };
+    case 2:
+      return { tag: "ActionResponse", val: readActionResponse(bc) };
+    case 3:
+      return { tag: "Event", val: readEvent(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToClientBody(bc, x) {
+  switch (x.tag) {
+    case "Init": {
+      bare.writeU8(bc, 0);
+      writeInit(bc, x.val);
+      break;
+    }
+    case "Error": {
+      bare.writeU8(bc, 1);
+      writeError(bc, x.val);
+      break;
+    }
+    case "ActionResponse": {
+      bare.writeU8(bc, 2);
+      writeActionResponse(bc, x.val);
+      break;
+    }
+    case "Event": {
+      bare.writeU8(bc, 3);
+      writeEvent(bc, x.val);
+      break;
+    }
+  }
+}
+function readToClient(bc) {
+  return {
+    body: readToClientBody(bc)
+  };
+}
+function writeToClient(bc, x) {
+  writeToClientBody(bc, x.body);
+}
+function encodeToClient(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeToClient(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToClient(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readToClient(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActionRequest(bc) {
+  return {
+    id: bare.readUint(bc),
+    name: bare.readString(bc),
+    args: bare.readData(bc)
+  };
+}
+function writeActionRequest(bc, x) {
+  bare.writeUint(bc, x.id);
+  bare.writeString(bc, x.name);
+  bare.writeData(bc, x.args);
+}
+function readSubscriptionRequest(bc) {
+  return {
+    eventName: bare.readString(bc),
+    subscribe: bare.readBool(bc)
+  };
+}
+function writeSubscriptionRequest(bc, x) {
+  bare.writeString(bc, x.eventName);
+  bare.writeBool(bc, x.subscribe);
+}
+function readToServerBody(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "ActionRequest", val: readActionRequest(bc) };
+    case 1:
+      return { tag: "SubscriptionRequest", val: readSubscriptionRequest(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writeToServerBody(bc, x) {
+  switch (x.tag) {
+    case "ActionRequest": {
+      bare.writeU8(bc, 0);
+      writeActionRequest(bc, x.val);
+      break;
+    }
+    case "SubscriptionRequest": {
+      bare.writeU8(bc, 1);
+      writeSubscriptionRequest(bc, x.val);
+      break;
+    }
+  }
+}
+function readToServer(bc) {
+  return {
+    body: readToServerBody(bc)
+  };
+}
+function writeToServer(bc, x) {
+  writeToServerBody(bc, x.body);
+}
+function encodeToServer(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeToServer(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeToServer(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readToServer(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionRequest(bc) {
+  return {
+    args: bare.readData(bc)
+  };
+}
+function writeHttpActionRequest(bc, x) {
+  bare.writeData(bc, x.args);
+}
+function encodeHttpActionRequest(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeHttpActionRequest(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionRequest(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readHttpActionRequest(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpActionResponse(bc) {
+  return {
+    output: bare.readData(bc)
+  };
+}
+function writeHttpActionResponse(bc, x) {
+  bare.writeData(bc, x.output);
+}
+function encodeHttpActionResponse(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeHttpActionResponse(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpActionResponse(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readHttpActionResponse(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResponseError(bc) {
+  return {
+    code: bare.readString(bc),
+    message: bare.readString(bc),
+    metadata: read0(bc)
+  };
+}
+function writeHttpResponseError(bc, x) {
+  bare.writeString(bc, x.code);
+  bare.writeString(bc, x.message);
+  write0(bc, x.metadata);
+}
+function encodeHttpResponseError(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeHttpResponseError(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResponseError(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readHttpResponseError(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readHttpResolveResponse(bc) {
+  return {
+    actorId: bare.readString(bc)
+  };
+}
+function writeHttpResolveResponse(bc, x) {
+  bare.writeString(bc, x.actorId);
+}
+function encodeHttpResolveResponse(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writeHttpResolveResponse(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeHttpResolveResponse(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readHttpResolveResponse(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/schemas/client-protocol/versioned.ts
+var CURRENT_VERSION = 1;
+var migrations = /* @__PURE__ */ new Map();
+var TO_SERVER_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeToServer(data),
+  deserializeVersion: (bytes) => decodeToServer(bytes)
+});
+var TO_CLIENT_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeToClient(data),
+  deserializeVersion: (bytes) => decodeToClient(bytes)
+});
+var HTTP_ACTION_REQUEST_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeHttpActionRequest(data),
+  deserializeVersion: (bytes) => decodeHttpActionRequest(bytes)
+});
+var HTTP_ACTION_RESPONSE_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeHttpActionResponse(data),
+  deserializeVersion: (bytes) => decodeHttpActionResponse(bytes)
+});
+var HTTP_RESPONSE_ERROR_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeHttpResponseError(data),
+  deserializeVersion: (bytes) => decodeHttpResponseError(bytes)
+});
+var HTTP_RESOLVE_REQUEST_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (_) => new Uint8Array(),
+  deserializeVersion: (bytes) => null
+});
+var HTTP_RESOLVE_RESPONSE_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION,
+  migrations,
+  serializeVersion: (data) => encodeHttpResolveResponse(data),
+  deserializeVersion: (bytes) => decodeHttpResolveResponse(bytes)
+});
+
+// src/actor/log.ts
+var RUNTIME_LOGGER_NAME = "actor-runtime";
+var ACTOR_LOGGER_NAME = "actor";
+function logger() {
+  return getLogger(RUNTIME_LOGGER_NAME);
+}
+function instanceLogger() {
+  return getLogger(ACTOR_LOGGER_NAME);
+}
+
+// src/actor/protocol/serde.ts
+import { z } from "zod";
+
+// src/serde.ts
+import * as cbor from "cbor-x";
+import invariant from "invariant";
+function encodingIsBinary(encoding) {
+  if (encoding === "json") {
+    return false;
+  } else if (encoding === "cbor" || encoding === "bare") {
+    return true;
+  } else {
+    assertUnreachable(encoding);
+  }
+}
+function contentTypeForEncoding(encoding) {
+  if (encoding === "json") {
+    return "application/json";
+  } else if (encoding === "cbor" || encoding === "bare") {
+    return "application/octet-stream";
+  } else {
+    assertUnreachable(encoding);
+  }
+}
+function wsBinaryTypeForEncoding(encoding) {
+  if (encoding === "json") {
+    return "blob";
+  } else if (encoding === "cbor" || encoding === "bare") {
+    return "arraybuffer";
+  } else {
+    assertUnreachable(encoding);
+  }
+}
+function serializeWithEncoding(encoding, value, versionedDataHandler) {
+  if (encoding === "json") {
+    return jsonStringifyCompat(value);
+  } else if (encoding === "cbor") {
+    return cbor.encode(value);
+  } else if (encoding === "bare") {
+    return versionedDataHandler.serializeWithEmbeddedVersion(value);
+  } else {
+    assertUnreachable(encoding);
+  }
+}
+function deserializeWithEncoding(encoding, buffer, versionedDataHandler) {
+  if (encoding === "json") {
+    if (typeof buffer === "string") {
+      return JSON.parse(buffer);
+    } else {
+      const decoder = new TextDecoder("utf-8");
+      const jsonString = decoder.decode(buffer);
+      return JSON.parse(jsonString);
+    }
+  } else if (encoding === "cbor") {
+    invariant(
+      typeof buffer !== "string",
+      "buffer cannot be string for cbor encoding"
+    );
+    return cbor.decode(buffer);
+  } else if (encoding === "bare") {
+    invariant(
+      typeof buffer !== "string",
+      "buffer cannot be string for bare encoding"
+    );
+    return versionedDataHandler.deserializeWithEmbeddedVersion(buffer);
+  } else {
+    assertUnreachable(encoding);
+  }
+}
+
+// src/actor/utils.ts
+function assertUnreachable2(x) {
+  logger().error("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));
+}
+function generateRandomString(length = 32) {
+  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < length; i++) {
+    const randomIndex = Math.floor(Math.random() * characters.length);
+    result += characters[randomIndex];
+  }
+  return result;
+}
+
+// src/actor/protocol/serde.ts
+var EncodingSchema = z.enum(["json", "cbor", "bare"]);
+var CachedSerializer = class {
+  #data;
+  #cache = /* @__PURE__ */ new Map();
+  #versionedDataHandler;
+  constructor(data, versionedDataHandler) {
+    this.#data = data;
+    this.#versionedDataHandler = versionedDataHandler;
+  }
+  get rawData() {
+    return this.#data;
+  }
+  serialize(encoding) {
+    const cached = this.#cache.get(encoding);
+    if (cached) {
+      return cached;
+    } else {
+      const serialized = serializeWithEncoding(
+        encoding,
+        this.#data,
+        this.#versionedDataHandler
+      );
+      this.#cache.set(encoding, serialized);
+      return serialized;
+    }
+  }
+};
+function base64EncodeUint8Array(uint8Array) {
+  let binary = "";
+  const len = uint8Array.byteLength;
+  for (let i = 0; i < len; i++) {
+    binary += String.fromCharCode(uint8Array[i]);
+  }
+  return btoa(binary);
+}
+function base64EncodeArrayBuffer(arrayBuffer) {
+  const uint8Array = new Uint8Array(arrayBuffer);
+  return base64EncodeUint8Array(uint8Array);
+}
+function encodeDataToString(message) {
+  if (typeof message === "string") {
+    return message;
+  } else if (message instanceof ArrayBuffer) {
+    return base64EncodeArrayBuffer(message);
+  } else if (message instanceof Uint8Array) {
+    return base64EncodeUint8Array(message);
+  } else {
+    assertUnreachable2(message);
+  }
+}
+function jsonStringifyCompat(input) {
+  return JSON.stringify(
+    input,
+    (_key, value) => typeof value === "bigint" ? value.toString() : value
+  );
+}
+
+// src/actor/connection.ts
+function generateConnId() {
+  return crypto.randomUUID();
+}
+function generateConnToken() {
+  return generateSecureToken(32);
+}
+var CONNECTION_DRIVER_WEBSOCKET = "webSocket";
+var CONNECTION_DRIVER_SSE = "sse";
+var CONNECTION_DRIVER_HTTP = "http";
+var CONNECTION_CHECK_LIVENESS_SYMBOL = Symbol("checkLiveness");
+var Conn = class {
+  subscriptions = /* @__PURE__ */ new Set();
+  #stateEnabled;
+  // TODO: Remove this cyclical reference
+  #actor;
+  #status = "connected";
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  __persist;
+  /**
+   * Driver used to manage realtime connection communication.
+   *
+   * @protected
+   */
+  #driver;
+  get params() {
+    return this.__persist.params;
+  }
+  get auth() {
+    return this.__persist.authData;
+  }
+  get driver() {
+    return this.__persist.connDriver;
+  }
+  get _stateEnabled() {
+    return this.#stateEnabled;
+  }
+  /**
+   * Gets the current state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    if (!this.__persist.state) throw new Error("state should exists");
+    return this.__persist.state;
+  }
+  /**
+   * Sets the state of the connection.
+   *
+   * Throws an error if the state is not enabled.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.__persist.state = value;
+  }
+  /**
+   * Unique identifier for the connection.
+   */
+  get id() {
+    return this.__persist.connId;
+  }
+  /**
+   * Token used to authenticate this request.
+   */
+  get _token() {
+    return this.__persist.token;
+  }
+  /**
+   * Status of the connection.
+   */
+  get status() {
+    return this.#status;
+  }
+  /**
+   * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.
+   */
+  get lastSeen() {
+    return this.__persist.lastSeen;
+  }
+  /**
+   * Initializes a new instance of the Connection class.
+   *
+   * This should only be constructed by {@link Actor}.
+   *
+   * @protected
+   */
+  constructor(actor, persist, driver, stateEnabled) {
+    this.#actor = actor;
+    this.__persist = persist;
+    this.#driver = driver;
+    this.#stateEnabled = stateEnabled;
+  }
+  #validateStateEnabled() {
+    if (!this.#stateEnabled) {
+      throw new ConnStateNotEnabled();
+    }
+  }
+  /**
+   * Sends a WebSocket message to the client.
+   *
+   * @param message - The message to send.
+   *
+   * @protected
+   */
+  _sendMessage(message) {
+    var _a, _b;
+    (_b = (_a = this.#driver).sendMessage) == null ? void 0 : _b.call(
+      _a,
+      this.#actor,
+      this,
+      this.__persist.connDriverState,
+      message
+    );
+  }
+  /**
+   * 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.gg/docs/events|Events Documentation}
+   */
+  send(eventName, ...args) {
+    this.#actor.inspector.emitter.emit("eventFired", {
+      type: "event",
+      eventName,
+      args,
+      connId: this.id
+    });
+    this._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Event",
+            val: {
+              name: eventName,
+              args: bufferToArrayBuffer(cbor2.encode(args))
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+  }
+  /**
+   * Disconnects the client with an optional reason.
+   *
+   * @param reason - The reason for disconnection.
+   */
+  async disconnect(reason) {
+    this.#status = "reconnecting";
+    await this.#driver.disconnect(
+      this.#actor,
+      this,
+      this.__persist.connDriverState,
+      reason
+    );
+  }
+  /**
+   * This method checks the connection's liveness by querying the driver for its ready state.
+   * If the connection is not closed, it updates the last liveness timestamp and returns `true`.
+   * Otherwise, it returns `false`.
+   * @internal
+   */
+  [CONNECTION_CHECK_LIVENESS_SYMBOL]() {
+    const readyState = this.#driver.getConnectionReadyState(this.#actor, this);
+    const isConnectionClosed = readyState === 3 /* CLOSED */ || readyState === 2 /* CLOSING */ || readyState === void 0;
+    const newLastSeen = Date.now();
+    const newStatus = isConnectionClosed ? "reconnecting" : "connected";
+    logger().debug("liveness probe for connection", {
+      connId: this.id,
+      actorId: this.#actor.id,
+      readyState,
+      status: this.#status,
+      newStatus,
+      lastSeen: this.__persist.lastSeen,
+      currentTs: newLastSeen
+    });
+    if (!isConnectionClosed) {
+      this.__persist.lastSeen = newLastSeen;
+    }
+    this.#status = newStatus;
+    return {
+      status: this.#status,
+      lastSeen: this.__persist.lastSeen
+    };
+  }
+};
+
+// src/actor/router-endpoints.ts
+import * as cbor4 from "cbor-x";
+import { streamSSE } from "hono/streaming";
+
+// src/actor/action.ts
+var ActionContext = class {
+  /**
+   * Should not be called directly.
+   *
+   * @param actorContext - The actor context
+   * @param conn - The connection associated with the action
+   */
+  constructor(actorContext, conn) {
+    this.conn = conn;
+    this.#actorContext = actorContext;
+  }
+  #actorContext;
+  /**
+   * Get the actor state
+   */
+  get state() {
+    return this.#actorContext.state;
+  }
+  /**
+   * Get the actor variables
+   */
+  get vars() {
+    return this.#actorContext.vars;
+  }
+  /**
+   * Broadcasts an event to all connected clients.
+   */
+  broadcast(name, ...args) {
+    this.#actorContext.broadcast(name, ...args);
+  }
+  /**
+   * Gets the logger instance.
+   */
+  get log() {
+    return this.#actorContext.log;
+  }
+  /**
+   * Gets actor ID.
+   */
+  get actorId() {
+    return this.#actorContext.actorId;
+  }
+  /**
+   * Gets the actor name.
+   */
+  get name() {
+    return this.#actorContext.name;
+  }
+  /**
+   * Gets the actor key.
+   */
+  get key() {
+    return this.#actorContext.key;
+  }
+  /**
+   * Gets the region.
+   */
+  get region() {
+    return this.#actorContext.region;
+  }
+  /**
+   * Gets the scheduler.
+   */
+  get schedule() {
+    return this.#actorContext.schedule;
+  }
+  /**
+   * Gets the map of connections.
+   */
+  get conns() {
+    return this.#actorContext.conns;
+  }
+  /**
+   * Returns the client for the given registry.
+   */
+  client() {
+    return this.#actorContext.client();
+  }
+  /**
+   * @experimental
+   */
+  get db() {
+    return this.#actorContext.db;
+  }
+  /**
+   * Forces the state to get saved.
+   */
+  async saveState(opts) {
+    return this.#actorContext.saveState(opts);
+  }
+  /**
+   * Prevents the actor from sleeping until promise is complete.
+   */
+  waitUntil(promise) {
+    this.#actorContext.waitUntil(promise);
+  }
+  /**
+   * AbortSignal that fires when the actor is stopping.
+   */
+  get abortSignal() {
+    return this.#actorContext.abortSignal;
+  }
+  /**
+   * Forces the actor to sleep.
+   *
+   * Not supported on all drivers.
+   *
+   * @experimental
+   */
+  sleep() {
+    this.#actorContext.sleep();
+  }
+};
+
+// src/manager/log.ts
+var LOGGER_NAME = "actor-manager";
+function logger2() {
+  return getLogger(LOGGER_NAME);
+}
+
+// src/manager/hono-websocket-adapter.ts
+var HonoWebSocketAdapter = class {
+  // WebSocket readyState values
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  #ws;
+  #readyState = 1;
+  // Start as OPEN since WSContext is already connected
+  #eventListeners = /* @__PURE__ */ new Map();
+  #closeCode;
+  #closeReason;
+  constructor(ws) {
+    this.#ws = ws;
+    this.#readyState = this.OPEN;
+    setTimeout(() => {
+      this.#fireEvent("open", { type: "open", target: this });
+    }, 0);
+  }
+  get readyState() {
+    return this.#readyState;
+  }
+  get binaryType() {
+    return "arraybuffer";
+  }
+  set binaryType(value) {
+  }
+  get bufferedAmount() {
+    return 0;
+  }
+  get extensions() {
+    return "";
+  }
+  get protocol() {
+    return "";
+  }
+  get url() {
+    return "";
+  }
+  send(data) {
+    if (this.readyState !== this.OPEN) {
+      throw new Error("WebSocket is not open");
+    }
+    try {
+      logger2().debug("bridge sending data", {
+        dataType: typeof data,
+        isString: typeof data === "string",
+        isArrayBuffer: data instanceof ArrayBuffer,
+        dataStr: typeof data === "string" ? data.substring(0, 100) : "<non-string>"
+      });
+      if (typeof data === "string") {
+        this.#ws.send(data);
+      } else if (data instanceof ArrayBuffer) {
+        this.#ws.send(data);
+      } else if (ArrayBuffer.isView(data)) {
+        const buffer = data.buffer.slice(
+          data.byteOffset,
+          data.byteOffset + data.byteLength
+        );
+        if (buffer instanceof SharedArrayBuffer) {
+          const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+          new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+          this.#ws.send(arrayBuffer);
+        } else {
+          this.#ws.send(buffer);
+        }
+      } else if (data instanceof Blob) {
+        data.arrayBuffer().then((buffer) => {
+          this.#ws.send(buffer);
+        }).catch((error) => {
+          logger2().error("failed to convert blob to arraybuffer", { error });
+          this.#fireEvent("error", { type: "error", target: this, error });
+        });
+      } else {
+        logger2().warn("unsupported data type, converting to string", {
+          dataType: typeof data,
+          data
+        });
+        this.#ws.send(String(data));
+      }
+    } catch (error) {
+      logger2().error("error sending websocket data", { error });
+      this.#fireEvent("error", { type: "error", target: this, error });
+      throw error;
+    }
+  }
+  close(code = 1e3, reason = "") {
+    if (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {
+      return;
+    }
+    this.#readyState = this.CLOSING;
+    this.#closeCode = code;
+    this.#closeReason = reason;
+    try {
+      this.#ws.close(code, reason);
+      this.#readyState = this.CLOSED;
+      this.#fireEvent("close", {
+        type: "close",
+        target: this,
+        code,
+        reason,
+        wasClean: code === 1e3
+      });
+    } catch (error) {
+      logger2().error("error closing websocket", { error });
+      this.#readyState = this.CLOSED;
+      this.#fireEvent("close", {
+        type: "close",
+        target: this,
+        code: 1006,
+        reason: "Abnormal closure",
+        wasClean: false
+      });
+    }
+  }
+  addEventListener(type, listener) {
+    if (!this.#eventListeners.has(type)) {
+      this.#eventListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    this.#eventListeners.get(type).add(listener);
+  }
+  removeEventListener(type, listener) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners) {
+      listeners.delete(listener);
+    }
+  }
+  dispatchEvent(event) {
+    const listeners = this.#eventListeners.get(event.type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          logger2().error(`error in ${event.type} event listener`, { error });
+        }
+      }
+    }
+    return true;
+  }
+  // Internal method to handle incoming messages from WSContext
+  _handleMessage(data) {
+    let messageData;
+    if (typeof data === "string") {
+      messageData = data;
+    } else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {
+      messageData = data;
+    } else if (data && typeof data === "object" && "data" in data) {
+      messageData = data.data;
+    } else {
+      messageData = String(data);
+    }
+    logger2().debug("bridge handling message", {
+      dataType: typeof messageData,
+      isArrayBuffer: messageData instanceof ArrayBuffer,
+      dataStr: typeof messageData === "string" ? messageData : "<binary>"
+    });
+    this.#fireEvent("message", {
+      type: "message",
+      target: this,
+      data: messageData
+    });
+  }
+  // Internal method to handle close from WSContext
+  _handleClose(code, reason) {
+    this.#ws.close(1e3, "hack_force_close");
+    if (this.readyState === this.CLOSED) return;
+    this.#readyState = this.CLOSED;
+    this.#closeCode = code;
+    this.#closeReason = reason;
+    this.#fireEvent("close", {
+      type: "close",
+      target: this,
+      code,
+      reason,
+      wasClean: code === 1e3
+    });
+  }
+  // Internal method to handle errors from WSContext
+  _handleError(error) {
+    this.#fireEvent("error", {
+      type: "error",
+      target: this,
+      error
+    });
+  }
+  #fireEvent(type, event) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners) {
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (error) {
+          logger2().error(`error in ${type} event listener`, { error });
+        }
+      }
+    }
+    switch (type) {
+      case "open":
+        if (this.#onopen) {
+          try {
+            this.#onopen(event);
+          } catch (error) {
+            logger2().error("error in onopen handler", { error });
+          }
+        }
+        break;
+      case "close":
+        if (this.#onclose) {
+          try {
+            this.#onclose(event);
+          } catch (error) {
+            logger2().error("error in onclose handler", { error });
+          }
+        }
+        break;
+      case "error":
+        if (this.#onerror) {
+          try {
+            this.#onerror(event);
+          } catch (error) {
+            logger2().error("error in onerror handler", { error });
+          }
+        }
+        break;
+      case "message":
+        if (this.#onmessage) {
+          try {
+            this.#onmessage(event);
+          } catch (error) {
+            logger2().error("error in onmessage handler", { error });
+          }
+        }
+        break;
+    }
+  }
+  // Event handler properties with getters/setters
+  #onopen = null;
+  #onclose = null;
+  #onerror = null;
+  #onmessage = null;
+  get onopen() {
+    return this.#onopen;
+  }
+  set onopen(handler) {
+    this.#onopen = handler;
+  }
+  get onclose() {
+    return this.#onclose;
+  }
+  set onclose(handler) {
+    this.#onclose = handler;
+  }
+  get onerror() {
+    return this.#onerror;
+  }
+  set onerror(handler) {
+    this.#onerror = handler;
+  }
+  get onmessage() {
+    return this.#onmessage;
+  }
+  set onmessage(handler) {
+    this.#onmessage = handler;
+  }
+};
+
+// src/actor/protocol/old.ts
+import * as cbor3 from "cbor-x";
+import { z as z2 } from "zod";
+var TransportSchema = z2.enum(["websocket", "sse"]);
+function getValueLength(value) {
+  if (typeof value === "string") {
+    return value.length;
+  } else if (value instanceof Blob) {
+    return value.size;
+  } else if (value instanceof ArrayBuffer || value instanceof SharedArrayBuffer || value instanceof Uint8Array) {
+    return value.byteLength;
+  } else {
+    assertUnreachable(value);
+  }
+}
+async function inputDataToBuffer(data) {
+  if (typeof data === "string") {
+    return data;
+  } else if (data instanceof Blob) {
+    const arrayBuffer = await data.arrayBuffer();
+    return new Uint8Array(arrayBuffer);
+  } else if (data instanceof Uint8Array) {
+    return data;
+  } else if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {
+    return new Uint8Array(data);
+  } else {
+    throw new MalformedMessage();
+  }
+}
+async function parseMessage(value, opts) {
+  const length = getValueLength(value);
+  if (length > opts.maxIncomingMessageSize) {
+    throw new MessageTooLong();
+  }
+  const buffer = await inputDataToBuffer(value);
+  return deserializeWithEncoding(opts.encoding, buffer, TO_SERVER_VERSIONED);
+}
+async function processMessage(message, actor, conn, handler) {
+  let actionId;
+  let actionName;
+  try {
+    if (message.body.tag === "ActionRequest") {
+      if (handler.onExecuteAction === void 0) {
+        throw new Unsupported("Action");
+      }
+      const { id, name, args: argsRaw } = message.body.val;
+      actionId = id;
+      actionName = name;
+      const args = cbor3.decode(new Uint8Array(argsRaw));
+      logger().debug("processing action request", {
+        actionId: id,
+        actionName: name
+      });
+      const ctx = new ActionContext(
+        actor.actorContext,
+        conn
+      );
+      const output = await handler.onExecuteAction(ctx, name, args);
+      logger().debug("sending action response", {
+        actionId: id,
+        actionName: name,
+        outputType: typeof output,
+        isPromise: output instanceof Promise
+      });
+      conn._sendMessage(
+        new CachedSerializer(
+          {
+            body: {
+              tag: "ActionResponse",
+              val: {
+                id,
+                output: bufferToArrayBuffer(cbor3.encode(output))
+              }
+            }
+          },
+          TO_CLIENT_VERSIONED
+        )
+      );
+      logger().debug("action response sent", { id, name });
+    } else if (message.body.tag === "SubscriptionRequest") {
+      if (handler.onSubscribe === void 0 || handler.onUnsubscribe === void 0) {
+        throw new Unsupported("Subscriptions");
+      }
+      const { eventName, subscribe } = message.body.val;
+      logger().debug("processing subscription request", {
+        eventName,
+        subscribe
+      });
+      if (subscribe) {
+        await handler.onSubscribe(eventName, conn);
+      } else {
+        await handler.onUnsubscribe(eventName, conn);
+      }
+      logger().debug("subscription request completed", {
+        eventName,
+        subscribe
+      });
+    } else {
+      assertUnreachable(message.body);
+    }
+  } catch (error) {
+    const { code, message: message2, metadata } = deconstructError(error, logger(), {
+      connectionId: conn.id,
+      actionId,
+      actionName
+    });
+    logger().debug("sending error response", {
+      actionId,
+      actionName,
+      code,
+      message: message2
+    });
+    conn._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Error",
+            val: {
+              code,
+              message: message2,
+              metadata: bufferToArrayBuffer(cbor3.encode(metadata)),
+              actionId: actionId ?? null
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+    logger().debug("error response sent", { actionId, actionName });
+  }
+}
+
+// src/actor/router-endpoints.ts
+async function handleWebSocketConnect(req, runConfig, actorDriver, actorId, encoding, parameters, authData) {
+  const exposeInternalError = req ? getRequestExposeInternalError(req) : false;
+  const {
+    promise: handlersPromise,
+    resolve: handlersResolve,
+    reject: handlersReject
+  } = Promise.withResolvers();
+  let actor;
+  try {
+    actor = await actorDriver.loadActor(actorId);
+  } catch (error) {
+    return {
+      onOpen: (_evt, ws) => {
+        const { code } = deconstructError(
+          error,
+          logger(),
+          {
+            wsEvent: "open"
+          },
+          exposeInternalError
+        );
+        ws.close(1011, code);
+      },
+      onMessage: (_evt, ws) => {
+        ws.close(1011, "Actor not loaded");
+      },
+      onClose: (_event, _ws) => {
+      },
+      onError: (_error) => {
+      }
+    };
+  }
+  return {
+    onOpen: (_evt, ws) => {
+      logger().debug("websocket open");
+      (async () => {
+        try {
+          const connId = generateConnId();
+          const connToken = generateConnToken();
+          const connState = await actor.prepareConn(parameters, req);
+          const connGlobalState = actorDriver.getGenericConnGlobalState(actorId);
+          connGlobalState.websockets.set(connId, ws);
+          logger().debug("registered websocket for conn", {
+            actorId,
+            totalCount: connGlobalState.websockets.size
+          });
+          const conn = await actor.createConn(
+            connId,
+            connToken,
+            parameters,
+            connState,
+            CONNECTION_DRIVER_WEBSOCKET,
+            { encoding },
+            authData
+          );
+          handlersResolve({ conn, actor, connId });
+        } catch (error) {
+          handlersReject(error);
+          const { code } = deconstructError(
+            error,
+            logger(),
+            {
+              wsEvent: "open"
+            },
+            exposeInternalError
+          );
+          ws.close(1011, code);
+        }
+      })();
+    },
+    onMessage: (evt, ws) => {
+      handlersPromise.then(({ conn, actor: actor2 }) => {
+        logger().debug("received message");
+        const value = evt.data.valueOf();
+        parseMessage(value, {
+          encoding,
+          maxIncomingMessageSize: runConfig.maxIncomingMessageSize
+        }).then((message) => {
+          actor2.processMessage(message, conn).catch((error) => {
+            const { code } = deconstructError(
+              error,
+              logger(),
+              {
+                wsEvent: "message"
+              },
+              exposeInternalError
+            );
+            ws.close(1011, code);
+          });
+        }).catch((error) => {
+          const { code } = deconstructError(
+            error,
+            logger(),
+            {
+              wsEvent: "message"
+            },
+            exposeInternalError
+          );
+          ws.close(1011, code);
+        });
+      }).catch((error) => {
+        const { code } = deconstructError(
+          error,
+          logger(),
+          {
+            wsEvent: "message"
+          },
+          exposeInternalError
+        );
+        ws.close(1011, code);
+      });
+    },
+    onClose: (event, ws) => {
+      if (event.wasClean) {
+        logger().info("websocket closed", {
+          code: event.code,
+          reason: event.reason,
+          wasClean: event.wasClean
+        });
+      } else {
+        logger().warn("websocket closed", {
+          code: event.code,
+          reason: event.reason,
+          wasClean: event.wasClean
+        });
+      }
+      ws.close(1e3, "hack_force_close");
+      handlersPromise.then(({ conn, actor: actor2, connId }) => {
+        const connGlobalState = actorDriver.getGenericConnGlobalState(actorId);
+        const didDelete = connGlobalState.websockets.delete(connId);
+        if (didDelete) {
+          logger().info("removing websocket for conn", {
+            totalCount: connGlobalState.websockets.size
+          });
+        } else {
+          logger().warn("websocket does not exist for conn", {
+            actorId,
+            totalCount: connGlobalState.websockets.size
+          });
+        }
+        actor2.__removeConn(conn);
+      }).catch((error) => {
+        deconstructError(
+          error,
+          logger(),
+          { wsEvent: "close" },
+          exposeInternalError
+        );
+      });
+    },
+    onError: (_error) => {
+      try {
+        logger().warn("websocket error");
+      } catch (error) {
+        deconstructError(
+          error,
+          logger(),
+          { wsEvent: "error" },
+          exposeInternalError
+        );
+      }
+    }
+  };
+}
+async function handleSseConnect(c, _runConfig, actorDriver, actorId, authData) {
+  const encoding = getRequestEncoding(c.req);
+  const parameters = getRequestConnParams(c.req);
+  return streamSSE(c, async (stream) => {
+    let actor;
+    let connId;
+    let connToken;
+    let connState;
+    let conn;
+    try {
+      actor = await actorDriver.loadActor(actorId);
+      connId = generateConnId();
+      connToken = generateConnToken();
+      connState = await actor.prepareConn(parameters, c.req.raw);
+      logger().debug("sse open");
+      actorDriver.getGenericConnGlobalState(actorId).sseStreams.set(connId, stream);
+      conn = await actor.createConn(
+        connId,
+        connToken,
+        parameters,
+        connState,
+        CONNECTION_DRIVER_SSE,
+        { encoding },
+        authData
+      );
+      const abortResolver = Promise.withResolvers();
+      stream.onAbort(async () => {
+        try {
+          logger().debug("sse stream aborted");
+          if (connId) {
+            actorDriver.getGenericConnGlobalState(actorId).sseStreams.delete(connId);
+          }
+          if (conn && actor) {
+            actor.__removeConn(conn);
+          }
+          abortResolver.resolve(void 0);
+        } catch (error) {
+          logger().error("error closing sse connection", { error });
+          abortResolver.resolve(void 0);
+        }
+      });
+      try {
+        c.executionCtx.waitUntil(abortResolver.promise);
+      } catch {
+      }
+      await abortResolver.promise;
+    } catch (error) {
+      logger().error("error in sse connection", { error });
+      if (connId !== void 0) {
+        actorDriver.getGenericConnGlobalState(actorId).sseStreams.delete(connId);
+      }
+      if (conn && actor !== void 0) {
+        actor.__removeConn(conn);
+      }
+      stream.close();
+    }
+  });
+}
+async function handleAction(c, _runConfig, actorDriver, actionName, actorId, authData) {
+  const encoding = getRequestEncoding(c.req);
+  const parameters = getRequestConnParams(c.req);
+  logger().debug("handling action", { actionName, encoding });
+  const arrayBuffer = await c.req.arrayBuffer();
+  const request = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    HTTP_ACTION_REQUEST_VERSIONED
+  );
+  const actionArgs = cbor4.decode(new Uint8Array(request.args));
+  let actor;
+  let conn;
+  let output;
+  try {
+    actor = await actorDriver.loadActor(actorId);
+    const connState = await actor.prepareConn(parameters, c.req.raw);
+    conn = await actor.createConn(
+      generateConnId(),
+      generateConnToken(),
+      parameters,
+      connState,
+      CONNECTION_DRIVER_HTTP,
+      {},
+      authData
+    );
+    const ctx = new ActionContext(actor.actorContext, conn);
+    output = await actor.executeAction(ctx, actionName, actionArgs);
+  } finally {
+    if (conn) {
+      actor == null ? void 0 : actor.__removeConn(conn);
+    }
+  }
+  const responseData = {
+    output: bufferToArrayBuffer(cbor4.encode(output))
+  };
+  const serialized = serializeWithEncoding(
+    encoding,
+    responseData,
+    HTTP_ACTION_RESPONSE_VERSIONED
+  );
+  return c.body(serialized, 200, {
+    "Content-Type": contentTypeForEncoding(encoding)
+  });
+}
+async function handleConnectionMessage(c, _runConfig, actorDriver, connId, connToken, actorId) {
+  const encoding = getRequestEncoding(c.req);
+  const arrayBuffer = await c.req.arrayBuffer();
+  const message = deserializeWithEncoding(
+    encoding,
+    new Uint8Array(arrayBuffer),
+    TO_SERVER_VERSIONED
+  );
+  const actor = await actorDriver.loadActor(actorId);
+  const conn = actor.conns.get(connId);
+  if (!conn) {
+    throw new ConnNotFound(connId);
+  }
+  if (conn._token !== connToken) {
+    throw new IncorrectConnToken();
+  }
+  await actor.processMessage(message, conn);
+  return c.json({});
+}
+async function handleRawWebSocketHandler(req, path, actorDriver, actorId, authData) {
+  const actor = await actorDriver.loadActor(actorId);
+  return {
+    onOpen: (_evt, ws) => {
+      const adapter = new HonoWebSocketAdapter(ws);
+      ws.__adapter = adapter;
+      const url = new URL(path, "http://actor");
+      const pathname = url.pathname.replace(/^\/raw\/websocket/, "") || "/";
+      const normalizedPath = pathname + url.search;
+      let newRequest;
+      if (req) {
+        newRequest = new Request(`http://actor${normalizedPath}`, req);
+      } else {
+        newRequest = new Request(`http://actor${normalizedPath}`, {
+          method: "GET"
+        });
+      }
+      logger().debug("rewriting websocket url", {
+        from: path,
+        to: newRequest.url
+      });
+      actor.handleWebSocket(adapter, {
+        request: newRequest,
+        auth: authData
+      });
+    },
+    onMessage: (event, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleMessage(event);
+      }
+    },
+    onClose: (evt, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleClose((evt == null ? void 0 : evt.code) || 1006, (evt == null ? void 0 : evt.reason) || "");
+      }
+    },
+    onError: (error, ws) => {
+      const adapter = ws.__adapter;
+      if (adapter) {
+        adapter._handleError(error);
+      }
+    }
+  };
+}
+function getRequestEncoding(req) {
+  const encodingParam = req.header(HEADER_ENCODING);
+  if (!encodingParam) {
+    throw new InvalidEncoding("undefined");
+  }
+  const result = EncodingSchema.safeParse(encodingParam);
+  if (!result.success) {
+    throw new InvalidEncoding(encodingParam);
+  }
+  return result.data;
+}
+function getRequestExposeInternalError(req) {
+  const param = req.headers.get(HEADER_EXPOSE_INTERNAL_ERROR);
+  if (!param) {
+    return false;
+  }
+  return param === "true";
+}
+function getRequestQuery(c) {
+  const queryParam = c.req.header(HEADER_ACTOR_QUERY);
+  if (!queryParam) {
+    logger().error("missing query parameter");
+    throw new InvalidRequest("missing query");
+  }
+  try {
+    const parsed = JSON.parse(queryParam);
+    return parsed;
+  } catch (error) {
+    logger().error("invalid query json", { error });
+    throw new InvalidQueryJSON(error);
+  }
+}
+var HEADER_ACTOR_QUERY = "X-RivetKit-Query";
+var HEADER_ENCODING = "X-RivetKit-Encoding";
+var HEADER_EXPOSE_INTERNAL_ERROR = "X-RivetKit-Expose-Internal-Error";
+var HEADER_CONN_PARAMS = "X-RivetKit-Conn-Params";
+var HEADER_AUTH_DATA = "X-RivetKit-Auth-Data";
+var HEADER_ACTOR_ID = "X-RivetKit-Actor";
+var HEADER_CONN_ID = "X-RivetKit-Conn";
+var HEADER_CONN_TOKEN = "X-RivetKit-Conn-Token";
+var ALLOWED_PUBLIC_HEADERS = [
+  "Content-Type",
+  "User-Agent",
+  HEADER_ACTOR_QUERY,
+  HEADER_ENCODING,
+  HEADER_CONN_PARAMS,
+  HEADER_ACTOR_ID,
+  HEADER_CONN_ID,
+  HEADER_CONN_TOKEN
+];
+function getRequestConnParams(req) {
+  const paramsParam = req.header(HEADER_CONN_PARAMS);
+  if (!paramsParam) {
+    return null;
+  }
+  try {
+    return JSON.parse(paramsParam);
+  } catch (err) {
+    throw new InvalidParams(
+      `Invalid params JSON: ${stringifyError(err)}`
+    );
+  }
+}
+
+export {
+  createVersionedDataHandler,
+  TO_SERVER_VERSIONED,
+  TO_CLIENT_VERSIONED,
+  HTTP_ACTION_REQUEST_VERSIONED,
+  HTTP_ACTION_RESPONSE_VERSIONED,
+  HTTP_RESPONSE_ERROR_VERSIONED,
+  HTTP_RESOLVE_REQUEST_VERSIONED,
+  HTTP_RESOLVE_RESPONSE_VERSIONED,
+  logger,
+  instanceLogger,
+  encodingIsBinary,
+  contentTypeForEncoding,
+  wsBinaryTypeForEncoding,
+  serializeWithEncoding,
+  deserializeWithEncoding,
+  assertUnreachable2 as assertUnreachable,
+  DeadlineError,
+  deadline,
+  generateRandomString,
+  EncodingSchema,
+  CachedSerializer,
+  encodeDataToString,
+  jsonStringifyCompat,
+  generateConnId,
+  generateConnToken,
+  CONNECTION_DRIVER_WEBSOCKET,
+  CONNECTION_DRIVER_SSE,
+  CONNECTION_DRIVER_HTTP,
+  CONNECTION_CHECK_LIVENESS_SYMBOL,
+  Conn,
+  logger2,
+  inputDataToBuffer,
+  processMessage,
+  handleWebSocketConnect,
+  handleSseConnect,
+  handleAction,
+  handleConnectionMessage,
+  handleRawWebSocketHandler,
+  getRequestEncoding,
+  getRequestExposeInternalError,
+  getRequestQuery,
+  HEADER_ACTOR_QUERY,
+  HEADER_ENCODING,
+  HEADER_EXPOSE_INTERNAL_ERROR,
+  HEADER_CONN_PARAMS,
+  HEADER_AUTH_DATA,
+  HEADER_ACTOR_ID,
+  HEADER_CONN_ID,
+  HEADER_CONN_TOKEN,
+  ALLOWED_PUBLIC_HEADERS
+};
+//# sourceMappingURL=chunk-4NSUQZ2H.js.map