diff --git a/packages/rivetkit/fixtures/driver-test-suite/actor-onstatechange.ts b/packages/rivetkit/fixtures/driver-test-suite/actor-onstatechange.ts
new file mode 100644
index 000000000..f953270f3
--- /dev/null
+++ b/packages/rivetkit/fixtures/driver-test-suite/actor-onstatechange.ts
@@ -0,0 +1,44 @@
+import { actor } from "rivetkit";
+
+export const onStateChangeActor = actor({
+	onAuth: () => {},
+	state: {
+		value: 0,
+		changeCount: 0,
+	},
+	actions: {
+		// Action that modifies state - should trigger onStateChange
+		setValue: (c, newValue: number) => {
+			c.state.value = newValue;
+			return c.state.value;
+		},
+		// Action that modifies state multiple times - should trigger onStateChange for each change
+		incrementMultiple: (c, times: number) => {
+			for (let i = 0; i < times; i++) {
+				c.state.value++;
+			}
+			return c.state.value;
+		},
+		// Action that doesn't modify state - should NOT trigger onStateChange
+		getValue: (c) => {
+			return c.state.value;
+		},
+		// Action that reads and returns without modifying - should NOT trigger onStateChange
+		getDoubled: (c) => {
+			const doubled = c.state.value * 2;
+			return doubled;
+		},
+		// Get the count of how many times onStateChange was called
+		getChangeCount: (c) => {
+			return c.state.changeCount;
+		},
+		// Reset change counter for testing
+		resetChangeCount: (c) => {
+			c.state.changeCount = 0;
+		},
+	},
+	// Track onStateChange calls
+	onStateChange: (c) => {
+		c.state.changeCount++;
+	},
+});
diff --git a/packages/rivetkit/fixtures/driver-test-suite/registry.bundled_wseq4k79db.mjs b/packages/rivetkit/fixtures/driver-test-suite/registry.bundled_wseq4k79db.mjs
new file mode 100644
index 000000000..94cc923df
--- /dev/null
+++ b/packages/rivetkit/fixtures/driver-test-suite/registry.bundled_wseq4k79db.mjs
@@ -0,0 +1,12036 @@
+// src/actor/connection.ts
+import * as cbor2 from "cbor-x";
+
+// src/common/versioned-data.ts
+var VersionedDataHandler = class {
+  constructor(config4) {
+    this.config = config4;
+  }
+  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(config4) {
+  return new VersionedDataHandler(config4);
+}
+
+// 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/errors.ts
+var INTERNAL_ERROR_CODE = "internal_error";
+var INTERNAL_ERROR_DESCRIPTION = "Internal error. Read the server logs for more details.";
+var USER_ERROR_CODE = "user_error";
+var ActorError = class extends Error {
+  constructor(code, message, opts) {
+    super(message, { cause: opts?.cause });
+    this.code = code;
+    this.public = opts?.public ?? false;
+    this.metadata = opts?.metadata;
+    if (opts?.public) {
+      this.statusCode = 400;
+    }
+  }
+  __type = "ActorError";
+  public;
+  metadata;
+  statusCode = 500;
+  static isActorError(error) {
+    return typeof error === "object" && error.__type === "ActorError";
+  }
+  toString() {
+    return this.message;
+  }
+  /**
+   * Serialize error for HTTP response
+   */
+  serializeForHttp() {
+    return {
+      type: this.code,
+      message: this.message,
+      metadata: this.metadata
+    };
+  }
+};
+var InternalError = class extends ActorError {
+  constructor(message) {
+    super(INTERNAL_ERROR_CODE, message);
+  }
+};
+var Unreachable = class extends InternalError {
+  constructor(x) {
+    super(`Unreachable case: ${x}`);
+  }
+};
+var StateNotEnabled = class extends ActorError {
+  constructor() {
+    super(
+      "state_not_enabled",
+      "State not enabled. Must implement `createState` or `state` to use state. (https://www.rivet.gg/docs/actors/state/#initializing-state)"
+    );
+  }
+};
+var ConnStateNotEnabled = class extends ActorError {
+  constructor() {
+    super(
+      "conn_state_not_enabled",
+      "Connection state not enabled. Must implement `createConnectionState` or `connectionState` to use connection state. (https://www.rivet.gg/docs/actors/connections/#connection-state)"
+    );
+  }
+};
+var VarsNotEnabled = class extends ActorError {
+  constructor() {
+    super(
+      "vars_not_enabled",
+      "Variables not enabled. Must implement `createVars` or `vars` to use state. (https://www.rivet.gg/docs/actors/ephemeral-variables/#initializing-variables)"
+    );
+  }
+};
+var ActionTimedOut = class extends ActorError {
+  constructor() {
+    super(
+      "action_timed_out",
+      "Action timed out. This can be increased with: `actor({ options: { action: { timeout: ... } } })`",
+      { public: true }
+    );
+  }
+};
+var ActionNotFound = class extends ActorError {
+  constructor(name) {
+    super(
+      "action_not_found",
+      `Action '${name}' not found. Validate the action exists on your actor.`,
+      { public: true }
+    );
+  }
+};
+var InvalidEncoding = class extends ActorError {
+  constructor(format) {
+    super(
+      "invalid_encoding",
+      `Invalid encoding \`${format}\`. (https://www.rivet.gg/docs/actors/clients/#actor-client)`,
+      {
+        public: true
+      }
+    );
+  }
+};
+var ConnNotFound = class extends ActorError {
+  constructor(id) {
+    super("conn_not_found", `Connection not found for ID: ${id}`, {
+      public: true
+    });
+  }
+};
+var IncorrectConnToken = class extends ActorError {
+  constructor() {
+    super("incorrect_conn_token", "Incorrect connection token.", {
+      public: true
+    });
+  }
+};
+var MessageTooLong = class extends ActorError {
+  constructor() {
+    super(
+      "message_too_long",
+      "Message too long. This can be configured with: `registry.runServer({ maxIncomingMessageSize: ... })`",
+      { public: true }
+    );
+  }
+};
+var MalformedMessage = class extends ActorError {
+  constructor(cause) {
+    super("malformed_message", `Malformed message: ${cause}`, {
+      public: true,
+      cause
+    });
+  }
+};
+var InvalidStateType = class extends ActorError {
+  constructor(opts) {
+    let msg = "";
+    if (opts?.path) {
+      msg += `Attempted to set invalid state at path \`${opts.path}\`.`;
+    } else {
+      msg += "Attempted to set invalid state.";
+    }
+    msg += " Valid types include: null, undefined, boolean, string, number, BigInt, Date, RegExp, Error, typed arrays (Uint8Array, Int8Array, Float32Array, etc.), Map, Set, Array, and plain objects. (https://www.rivet.gg/docs/actors/state/#limitations)";
+    super("invalid_state_type", msg);
+  }
+};
+var Unsupported = class extends ActorError {
+  constructor(feature) {
+    super("unsupported", `Unsupported feature: ${feature}`);
+  }
+};
+var UserError = class extends ActorError {
+  /**
+   * Constructs a new UserError instance.
+   *
+   * @param message - The error message to be displayed.
+   * @param opts - Optional parameters for the error, including a machine-readable code and additional metadata.
+   */
+  constructor(message, opts) {
+    super(opts?.code ?? USER_ERROR_CODE, message, {
+      public: true,
+      metadata: opts?.metadata
+    });
+  }
+};
+var InvalidQueryJSON = class extends ActorError {
+  constructor(error) {
+    super("invalid_query_json", `Invalid query JSON: ${error}`, {
+      public: true,
+      cause: error
+    });
+  }
+};
+var InvalidRequest = class extends ActorError {
+  constructor(error) {
+    super("invalid_request", `Invalid request: ${error}`, {
+      public: true,
+      cause: error
+    });
+  }
+};
+var ActorNotFound = class extends ActorError {
+  constructor(identifier) {
+    super(
+      "actor_not_found",
+      identifier ? `Actor not found: ${identifier} (https://www.rivet.gg/docs/actors/clients/#actor-client)` : "Actor not found (https://www.rivet.gg/docs/actors/clients/#actor-client)",
+      { public: true }
+    );
+  }
+};
+var ActorAlreadyExists = class extends ActorError {
+  constructor(name, key) {
+    super(
+      "actor_already_exists",
+      `Actor already exists with name '${name}' and key '${JSON.stringify(key)}' (https://www.rivet.gg/docs/actors/clients/#actor-client)`,
+      { public: true }
+    );
+  }
+};
+var ProxyError = class extends ActorError {
+  constructor(operation, error) {
+    super(
+      "proxy_error",
+      `Error proxying ${operation}, this is likely an internal error: ${error}`,
+      {
+        public: true,
+        cause: error
+      }
+    );
+  }
+};
+var InvalidParams = class extends ActorError {
+  constructor(message) {
+    super("invalid_params", message, { public: true });
+  }
+};
+var Forbidden = class extends ActorError {
+  constructor(message, opts) {
+    super(
+      "forbidden",
+      message ?? "Forbidden. Access denied. (https://www.rivet.gg/docs/actors/authentication/)",
+      {
+        public: true,
+        metadata: opts?.metadata
+      }
+    );
+    this.statusCode = 403;
+  }
+};
+var DatabaseNotEnabled = class extends ActorError {
+  constructor() {
+    super(
+      "database_not_enabled",
+      "Database not enabled. Must implement `database` to use database."
+    );
+  }
+};
+var FetchHandlerNotDefined = class extends ActorError {
+  constructor() {
+    super(
+      "fetch_handler_not_defined",
+      "Raw HTTP handler not defined. Actor must implement `onFetch` to handle raw HTTP requests. (https://www.rivet.gg/docs/actors/fetch-and-websocket-handler/)",
+      { public: true }
+    );
+    this.statusCode = 404;
+  }
+};
+var InvalidFetchResponse = class extends ActorError {
+  constructor() {
+    super(
+      "invalid_fetch_response",
+      "Actor's onFetch handler must return a Response object. Returning void/undefined is not allowed. (https://www.rivet.gg/docs/actors/fetch-and-websocket-handler/)",
+      { public: true }
+    );
+    this.statusCode = 500;
+  }
+};
+
+// src/common/utils.ts
+function assertUnreachable(x) {
+  throw new Error(`Unreachable case: ${x}`);
+}
+function isCborSerializable(value, onInvalid, currentPath = "") {
+  if (value === null || value === void 0) {
+    return true;
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      onInvalid?.(currentPath);
+      return false;
+    }
+    return true;
+  }
+  if (typeof value === "boolean" || typeof value === "string") {
+    return true;
+  }
+  if (typeof value === "bigint") {
+    return true;
+  }
+  if (value instanceof Date) {
+    return true;
+  }
+  if (value instanceof Uint8Array || value instanceof Uint8ClampedArray || value instanceof Uint16Array || value instanceof Uint32Array || value instanceof BigUint64Array || value instanceof Int8Array || value instanceof Int16Array || value instanceof Int32Array || value instanceof BigInt64Array || value instanceof Float32Array || value instanceof Float64Array) {
+    return true;
+  }
+  if (value instanceof Map) {
+    for (const [key, val] of value.entries()) {
+      const keyPath = currentPath ? `${currentPath}.key(${String(key)})` : `key(${String(key)})`;
+      const valPath = currentPath ? `${currentPath}.value(${String(key)})` : `value(${String(key)})`;
+      if (!isCborSerializable(key, onInvalid, keyPath) || !isCborSerializable(val, onInvalid, valPath)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (value instanceof Set) {
+    let index = 0;
+    for (const item of value.values()) {
+      const itemPath = currentPath ? `${currentPath}.set[${index}]` : `set[${index}]`;
+      if (!isCborSerializable(item, onInvalid, itemPath)) {
+        return false;
+      }
+      index++;
+    }
+    return true;
+  }
+  if (value instanceof RegExp) {
+    return true;
+  }
+  if (value instanceof Error) {
+    return true;
+  }
+  if (Array.isArray(value)) {
+    for (let i = 0; i < value.length; i++) {
+      const itemPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;
+      if (!isCborSerializable(value[i], onInvalid, itemPath)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (typeof value === "object") {
+    const proto = Object.getPrototypeOf(value);
+    if (proto !== null && proto !== Object.prototype) {
+      const protoConstructor = value.constructor;
+      if (protoConstructor && typeof protoConstructor.name === "string") {
+      }
+    }
+    for (const key in value) {
+      const propPath = currentPath ? `${currentPath}.${key}` : key;
+      if (!isCborSerializable(
+        value[key],
+        onInvalid,
+        propPath
+      )) {
+        return false;
+      }
+    }
+    return true;
+  }
+  onInvalid?.(currentPath);
+  return false;
+}
+function deconstructError(error, logger10, extraLog, exposeInternalError = false) {
+  let statusCode;
+  let public_;
+  let code;
+  let message;
+  let metadata;
+  if (ActorError.isActorError(error) && error.public) {
+    statusCode = "statusCode" in error && error.statusCode ? error.statusCode : 400;
+    public_ = true;
+    code = error.code;
+    message = getErrorMessage(error);
+    metadata = error.metadata;
+    logger10.info("public error", {
+      code,
+      message,
+      issues: "https://github.com/rivet-gg/rivetkit/issues",
+      support: "https://rivet.gg/discord",
+      ...extraLog
+    });
+  } else if (exposeInternalError) {
+    if (ActorError.isActorError(error)) {
+      statusCode = 500;
+      public_ = false;
+      code = error.code;
+      message = getErrorMessage(error);
+      metadata = error.metadata;
+      logger10.info("internal error", {
+        code,
+        message,
+        issues: "https://github.com/rivet-gg/rivetkit/issues",
+        support: "https://rivet.gg/discord",
+        ...extraLog
+      });
+    } else {
+      statusCode = 500;
+      public_ = false;
+      code = INTERNAL_ERROR_CODE;
+      message = getErrorMessage(error);
+      logger10.info("internal error", {
+        code,
+        message,
+        issues: "https://github.com/rivet-gg/rivetkit/issues",
+        support: "https://rivet.gg/discord",
+        ...extraLog
+      });
+    }
+  } else {
+    statusCode = 500;
+    public_ = false;
+    code = INTERNAL_ERROR_CODE;
+    message = INTERNAL_ERROR_DESCRIPTION;
+    metadata = {
+      //url: `https://hub.rivet.gg/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,
+    };
+    logger10.warn("internal error", {
+      error: getErrorMessage(error),
+      stack: error?.stack,
+      issues: "https://github.com/rivet-gg/rivetkit/issues",
+      support: "https://rivet.gg/discord",
+      ...extraLog
+    });
+  }
+  return {
+    __type: "ActorError",
+    statusCode,
+    public: public_,
+    code,
+    message,
+    metadata
+  };
+}
+function stringifyError(error) {
+  if (error instanceof Error) {
+    if (typeof process !== "undefined" && getEnvUniversal("_RIVETKIT_ERROR_STACK") === "1") {
+      return `${error.name}: ${error.message}${error.stack ? `
+${error.stack}` : ""}`;
+    } else {
+      return `${error.name}: ${error.message}`;
+    }
+  } else if (typeof error === "string") {
+    return error;
+  } else if (typeof error === "object" && error !== null) {
+    try {
+      return `${JSON.stringify(error)}`;
+    } catch {
+      return "[cannot stringify error]";
+    }
+  } else {
+    return `Unknown error: ${getErrorMessage(error)}`;
+  }
+}
+function getErrorMessage(err) {
+  if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+    return err.message;
+  } else {
+    return String(err);
+  }
+}
+function noopNext() {
+  return async () => {
+  };
+}
+
+// package.json
+var package_default = {
+  name: "rivetkit",
+  version: "2.0.2",
+  license: "Apache-2.0",
+  keywords: [
+    "rivetkit",
+    "stateful",
+    "serverless",
+    "actors",
+    "agents",
+    "realtime",
+    "websocket",
+    "actors",
+    "framework"
+  ],
+  files: [
+    "dist",
+    "src",
+    "deno.json",
+    "bun.json",
+    "package.json"
+  ],
+  type: "module",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/tsup/mod.d.ts",
+        default: "./dist/tsup/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/mod.d.cts",
+        default: "./dist/tsup/mod.cjs"
+      }
+    },
+    "./client": {
+      import: {
+        types: "./dist/tsup/client/mod.d.ts",
+        default: "./dist/tsup/client/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/client/mod.d.cts",
+        default: "./dist/tsup/client/mod.cjs"
+      }
+    },
+    "./log": {
+      import: {
+        types: "./dist/tsup/common/log.d.ts",
+        default: "./dist/tsup/common/log.js"
+      },
+      require: {
+        types: "./dist/tsup/common/log.d.cts",
+        default: "./dist/tsup/common/log.cjs"
+      }
+    },
+    "./errors": {
+      import: {
+        types: "./dist/tsup/actor/errors.d.ts",
+        default: "./dist/tsup/actor/errors.js"
+      },
+      require: {
+        types: "./dist/tsup/actor/errors.d.cts",
+        default: "./dist/tsup/actor/errors.cjs"
+      }
+    },
+    "./utils": {
+      import: {
+        types: "./dist/tsup/utils.d.ts",
+        default: "./dist/tsup/utils.js"
+      },
+      require: {
+        types: "./dist/tsup/utils.d.cts",
+        default: "./dist/tsup/utils.cjs"
+      }
+    },
+    "./driver-helpers": {
+      import: {
+        types: "./dist/tsup/driver-helpers/mod.d.ts",
+        default: "./dist/tsup/driver-helpers/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/driver-helpers/mod.d.cts",
+        default: "./dist/tsup/driver-helpers/mod.cjs"
+      }
+    },
+    "./driver-helpers/websocket": {
+      import: {
+        types: "./dist/tsup/common/websocket.d.ts",
+        default: "./dist/tsup/common/websocket.js"
+      },
+      require: {
+        types: "./dist/tsup/common/websocket.d.cts",
+        default: "./dist/tsup/common/websocket.cjs"
+      }
+    },
+    "./driver-test-suite": {
+      import: {
+        types: "./dist/tsup/driver-test-suite/mod.d.ts",
+        default: "./dist/tsup/driver-test-suite/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/driver-test-suite/mod.d.cts",
+        default: "./dist/tsup/driver-test-suite/mod.cjs"
+      }
+    },
+    "./topologies/coordinate": {
+      import: {
+        types: "./dist/tsup/topologies/coordinate/mod.d.ts",
+        default: "./dist/tsup/topologies/coordinate/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/topologies/coordinate/mod.d.cts",
+        default: "./dist/tsup/topologies/coordinate/mod.cjs"
+      }
+    },
+    "./topologies/partition": {
+      import: {
+        types: "./dist/tsup/topologies/partition/mod.d.ts",
+        default: "./dist/tsup/topologies/partition/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/topologies/partition/mod.d.cts",
+        default: "./dist/tsup/topologies/partition/mod.cjs"
+      }
+    },
+    "./test": {
+      import: {
+        types: "./dist/tsup/test/mod.d.ts",
+        default: "./dist/tsup/test/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/test/mod.d.cts",
+        default: "./dist/tsup/test/mod.cjs"
+      }
+    },
+    "./inspector": {
+      import: {
+        types: "./dist/tsup/inspector/mod.d.ts",
+        default: "./dist/tsup/inspector/mod.js"
+      },
+      require: {
+        types: "./dist/tsup/inspector/mod.d.cts",
+        default: "./dist/tsup/inspector/mod.cjs"
+      }
+    }
+  },
+  engines: {
+    node: ">=22.0.0"
+  },
+  sideEffects: false,
+  scripts: {
+    dev: "pnpm build --watch",
+    build: "tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/topologies/coordinate/mod.ts src/topologies/partition/mod.ts src/utils.ts src/driver-helpers/mod.ts src/driver-test-suite/mod.ts src/test/mod.ts src/inspector/mod.ts",
+    "build:schema": "./scripts/compile-bare.ts compile schemas/client-protocol/v1.bare -o dist/schemas/client-protocol/v1.ts && ./scripts/compile-bare.ts compile schemas/file-system-driver/v1.bare -o dist/schemas/file-system-driver/v1.ts && ./scripts/compile-bare.ts compile schemas/actor-persist/v1.bare -o dist/schemas/actor-persist/v1.ts",
+    "check-types": "tsc --noEmit",
+    test: "vitest run",
+    "test:watch": "vitest",
+    "dump-openapi": "tsx scripts/dump-openapi.ts"
+  },
+  dependencies: {
+    "@bare-ts/lib": "~0.3.0",
+    "@hono/standard-validator": "^0.1.3",
+    "@hono/zod-openapi": "^0.19.10",
+    "@rivetkit/engine-runner": "https://pkg.pr.new/rivet-gg/engine/@rivetkit/engine-runner@664a377",
+    "@rivetkit/fast-json-patch": "^3.1.2",
+    "cbor-x": "^1.6.0",
+    hono: "^4.7.0",
+    invariant: "^2.2.4",
+    nanoevents: "^9.1.0",
+    "on-change": "^5.0.1",
+    "p-retry": "^6.2.1",
+    zod: "^3.25.76"
+  },
+  devDependencies: {
+    "@bare-ts/tools": "^0.13.0",
+    "@hono/node-server": "^1.18.2",
+    "@hono/node-ws": "^1.1.1",
+    "@rivet-gg/actor-core": "^25.1.0",
+    "@types/invariant": "^2",
+    "@types/node": "^22.13.1",
+    "@types/ws": "^8",
+    "@vitest/ui": "3.1.1",
+    "bundle-require": "^5.1.0",
+    eventsource: "^3.0.5",
+    tsup: "^8.4.0",
+    tsx: "^4.19.4",
+    typescript: "^5.7.3",
+    vitest: "^3.1.1",
+    ws: "^8.18.1"
+  },
+  peerDependencies: {
+    "@hono/node-server": "^1.14.0",
+    "@hono/node-ws": "^1.1.1",
+    eventsource: "^3.0.5",
+    ws: "^8.0.0"
+  },
+  peerDependenciesMeta: {
+    "@hono/node-server": {
+      optional: true
+    },
+    "@hono/node-ws": {
+      optional: true
+    },
+    eventsource: {
+      optional: true
+    },
+    ws: {
+      optional: true
+    }
+  },
+  stableVersion: "0.8.0"
+};
+
+// src/utils.ts
+var VERSION = package_default.version;
+var _userAgent;
+function httpUserAgent() {
+  if (_userAgent !== void 0) {
+    return _userAgent;
+  }
+  let userAgent = `RivetKit/${VERSION}`;
+  const navigatorObj = typeof navigator !== "undefined" ? navigator : void 0;
+  if (navigatorObj?.userAgent) userAgent += ` ${navigatorObj.userAgent}`;
+  _userAgent = userAgent;
+  return userAgent;
+}
+function getEnvUniversal(key) {
+  if (typeof Deno !== "undefined") {
+    return Deno.env.get(key);
+  } else if (typeof process !== "undefined") {
+    return process.env[key];
+  }
+}
+var TIMEOUT_MAX = 2147483647;
+function setLongTimeout(listener, after) {
+  let timeout;
+  function start(remaining) {
+    if (remaining <= TIMEOUT_MAX) {
+      timeout = setTimeout(listener, remaining);
+    } else {
+      timeout = setTimeout(() => {
+        start(remaining - TIMEOUT_MAX);
+      }, TIMEOUT_MAX);
+    }
+  }
+  start(after);
+  return {
+    abort: () => {
+      if (timeout !== void 0) clearTimeout(timeout);
+    }
+  };
+}
+var SinglePromiseQueue = class {
+  /** Next operation to execute in the queue. If attempting to enqueue another op, it will override the existing op. */
+  #queuedOp;
+  /** The currently running promise of #drainLoop. Do not await this, instead await `pending` to await the current cycle. */
+  runningDrainLoop;
+  /** Pending resolver fro the currently queued entry. */
+  #pending;
+  /** Queue the next operation and return a promise that resolves when it flushes. */
+  enqueue(op) {
+    this.#queuedOp = op;
+    if (!this.#pending) {
+      this.#pending = Promise.withResolvers();
+    }
+    const waitForThisCycle = this.#pending.promise;
+    if (!this.runningDrainLoop) {
+      this.runningDrainLoop = this.#drainLoop();
+    }
+    return waitForThisCycle;
+  }
+  /** Drain queued operations sequentially until there is nothing left. */
+  async #drainLoop() {
+    try {
+      while (this.#queuedOp) {
+        const resolver = this.#pending;
+        this.#pending = void 0;
+        const op = this.#queuedOp;
+        this.#queuedOp = void 0;
+        try {
+          await op();
+        } catch {
+        }
+        resolver?.resolve();
+      }
+    } finally {
+      this.runningDrainLoop = void 0;
+    }
+  }
+};
+function bufferToArrayBuffer(buf) {
+  return buf.buffer.slice(
+    buf.byteOffset,
+    buf.byteOffset + buf.byteLength
+  );
+}
+
+// src/common/log-levels.ts
+var LogLevels = {
+  TRACE: 0,
+  DEBUG: 1,
+  INFO: 2,
+  WARN: 3,
+  ERROR: 4,
+  CRITICAL: 5
+};
+var LevelNameMap = {
+  0: "TRACE",
+  1: "DEBUG",
+  2: "INFO",
+  3: "WARN",
+  4: "ERROR",
+  5: "CRITICAL"
+};
+
+// src/common/logfmt.ts
+var LOG_LEVEL_COLORS = {
+  [LogLevels.CRITICAL]: "\x1B[31m",
+  // Red
+  [LogLevels.ERROR]: "\x1B[31m",
+  // Red
+  [LogLevels.WARN]: "\x1B[33m",
+  // Yellow
+  [LogLevels.INFO]: "\x1B[32m",
+  // Green
+  [LogLevels.DEBUG]: "\x1B[36m",
+  // Cyan
+  [LogLevels.TRACE]: "\x1B[36m"
+  // Cyan
+};
+var RESET_COLOR = "\x1B[0m";
+function stringify(...data) {
+  let line = "";
+  for (let i = 0; i < data.length; i++) {
+    const [key, valueRaw] = data[i];
+    let isNull = false;
+    let valueString;
+    if (valueRaw == null) {
+      isNull = true;
+      valueString = "";
+    } else {
+      valueString = valueRaw.toString();
+    }
+    if (valueString.length > 512 && key !== "msg" && key !== "error")
+      valueString = `${valueString.slice(0, 512)}...`;
+    const needsQuoting = valueString.indexOf(" ") > -1 || valueString.indexOf("=") > -1;
+    const needsEscaping = valueString.indexOf('"') > -1 || valueString.indexOf("\\") > -1;
+    valueString = valueString.replace(/\n/g, "\\n");
+    if (needsEscaping) valueString = valueString.replace(/["\\]/g, "\\$&");
+    if (needsQuoting || needsEscaping) valueString = `"${valueString}"`;
+    if (valueString === "" && !isNull) valueString = '""';
+    if (LOGGER_CONFIG.enableColor) {
+      let color = "\x1B[2m";
+      if (key === "level") {
+        const level = LogLevels[valueString];
+        const levelColor = LOG_LEVEL_COLORS[level];
+        if (levelColor) {
+          color = levelColor;
+        }
+      } else if (key === "msg") {
+        color = "\x1B[32m";
+      } else if (key === "trace") {
+        color = "\x1B[34m";
+      }
+      line += `\x1B[0m\x1B[1m${key}\x1B[0m\x1B[2m=\x1B[0m${color}${valueString}${RESET_COLOR}`;
+    } else {
+      line += `${key}=${valueString}`;
+    }
+    if (i !== data.length - 1) {
+      line += " ";
+    }
+  }
+  return line;
+}
+function formatTimestamp(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  const milliseconds = String(date.getUTCMilliseconds()).padStart(3, "0");
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;
+}
+function castToLogValue(v) {
+  if (typeof v === "string" || typeof v === "number" || typeof v === "bigint" || typeof v === "boolean" || v === null || v === void 0) {
+    return v;
+  }
+  if (v instanceof Error) {
+    return String(v);
+  }
+  try {
+    return JSON.stringify(v);
+  } catch {
+    return "[cannot stringify]";
+  }
+}
+var LOGGER_CONFIG = {
+  enableColor: false,
+  enableSpreadObject: false,
+  enableErrorStack: false
+};
+
+// src/common/log.ts
+var Logger = class {
+  name;
+  level;
+  constructor(name, level) {
+    this.name = name;
+    this.level = level;
+  }
+  log(level, message, ...args) {
+    const record = {
+      msg: message,
+      args,
+      level,
+      loggerName: this.name,
+      datetime: /* @__PURE__ */ new Date(),
+      levelName: LevelNameMap[level]
+    };
+    if (this.#shouldLog(level)) {
+      this.#logRecord(record);
+    }
+  }
+  #shouldLog(level) {
+    return level >= LogLevels[this.level];
+  }
+  #logRecord(record) {
+    console.log(formatter(record));
+  }
+  trace(message, ...args) {
+    this.log(LogLevels.TRACE, message, ...args);
+  }
+  debug(message, ...args) {
+    this.log(LogLevels.DEBUG, message, ...args);
+  }
+  info(message, ...args) {
+    this.log(LogLevels.INFO, message, ...args);
+  }
+  warn(message, ...args) {
+    this.log(LogLevels.WARN, message, ...args);
+  }
+  error(message, ...args) {
+    this.log(LogLevels.ERROR, message, ...args);
+  }
+  critical(message, ...args) {
+    this.log(LogLevels.CRITICAL, message, ...args);
+  }
+};
+var loggers = {};
+function getLogger(name = "default") {
+  const defaultLogLevelEnv = getEnvUniversal(
+    "_LOG_LEVEL"
+  );
+  const defaultLogLevel = defaultLogLevelEnv ?? "INFO";
+  if (!loggers[name]) {
+    loggers[name] = new Logger(name, defaultLogLevel);
+  }
+  return loggers[name];
+}
+function formatter(log) {
+  const args = [];
+  for (let i = 0; i < log.args.length; i++) {
+    const logArg = log.args[i];
+    if (logArg && typeof logArg === "object") {
+      for (const k in logArg) {
+        const v = logArg[k];
+        pushArg(k, v, args);
+      }
+    } else {
+      pushArg(`arg${i}`, logArg, args);
+    }
+  }
+  const logTs = getEnvUniversal("_LOG_TIMESTAMP") === "1";
+  const logTarget = getEnvUniversal("_LOG_TARGET") === "1";
+  return stringify(
+    ...logTs ? [["ts", formatTimestamp(/* @__PURE__ */ new Date())]] : [],
+    ["level", LevelNameMap[log.level]],
+    ...logTarget ? [["target", log.loggerName]] : [],
+    ["msg", log.msg],
+    ...args
+  );
+}
+function pushArg(k, v, args) {
+  args.push([k, castToLogValue(v)]);
+}
+
+// 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 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(actor2, persist, driver, stateEnabled) {
+    this.#actor = actor2;
+    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) {
+    this.#driver.sendMessage?.(
+      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/config.ts
+import { z as z2 } from "zod";
+var ActorConfigSchema = z2.object({
+  onAuth: z2.function().optional(),
+  onCreate: z2.function().optional(),
+  onStart: z2.function().optional(),
+  onStop: z2.function().optional(),
+  onStateChange: z2.function().optional(),
+  onBeforeConnect: z2.function().optional(),
+  onConnect: z2.function().optional(),
+  onDisconnect: z2.function().optional(),
+  onBeforeActionResponse: z2.function().optional(),
+  onFetch: z2.function().optional(),
+  onWebSocket: z2.function().optional(),
+  actions: z2.record(z2.function()).default({}),
+  state: z2.any().optional(),
+  createState: z2.function().optional(),
+  connState: z2.any().optional(),
+  createConnState: z2.function().optional(),
+  vars: z2.any().optional(),
+  db: z2.any().optional(),
+  createVars: z2.function().optional(),
+  options: z2.object({
+    createVarsTimeout: z2.number().positive().default(5e3),
+    createConnStateTimeout: z2.number().positive().default(5e3),
+    onConnectTimeout: z2.number().positive().default(5e3),
+    // This must be less than ACTOR_STOP_THRESHOLD_MS
+    onStopTimeout: z2.number().positive().default(5e3),
+    stateSaveInterval: z2.number().positive().default(1e4),
+    actionTimeout: z2.number().positive().default(6e4),
+    // Max time to wait for waitUntil background promises during shutdown
+    waitUntilTimeout: z2.number().positive().default(15e3),
+    connectionLivenessTimeout: z2.number().positive().default(2500),
+    connectionLivenessInterval: z2.number().positive().default(5e3),
+    noSleep: z2.boolean().default(false),
+    sleepTimeout: z2.number().positive().default(3e4)
+  }).strict().default({})
+}).strict().refine(
+  (data) => !(data.state !== void 0 && data.createState !== void 0),
+  {
+    message: "Cannot define both 'state' and 'createState'",
+    path: ["state"]
+  }
+).refine(
+  (data) => !(data.connState !== void 0 && data.createConnState !== void 0),
+  {
+    message: "Cannot define both 'connState' and 'createConnState'",
+    path: ["connState"]
+  }
+).refine(
+  (data) => !(data.vars !== void 0 && data.createVars !== void 0),
+  {
+    message: "Cannot define both 'vars' and 'createVars'",
+    path: ["vars"]
+  }
+);
+
+// src/actor/instance.ts
+import * as cbor5 from "cbor-x";
+import invariant2 from "invariant";
+import onChange from "on-change";
+
+// src/inspector/actor.ts
+import { sValidator } from "@hono/standard-validator";
+import jsonPatch from "@rivetkit/fast-json-patch";
+import { Hono } from "hono";
+import { streamSSE as streamSSE2 } from "hono/streaming";
+import { createNanoEvents } from "nanoevents";
+import z6 from "zod/v4";
+
+// src/inspector/protocol/common.ts
+import z5 from "zod/v4";
+
+// src/manager/protocol/query.ts
+import { z as z4 } from "zod";
+
+// 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 z3 } from "zod";
+var TransportSchema = z3.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, actor2, 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(
+        actor2.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 actor2;
+  try {
+    actor2 = 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 actor2.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 actor2.createConn(
+            connId,
+            connToken,
+            parameters,
+            connState,
+            CONNECTION_DRIVER_WEBSOCKET,
+            { encoding },
+            authData
+          );
+          handlersResolve({ conn, actor: actor2, connId });
+        } catch (error) {
+          handlersReject(error);
+          const { code } = deconstructError(
+            error,
+            logger(),
+            {
+              wsEvent: "open"
+            },
+            exposeInternalError
+          );
+          ws.close(1011, code);
+        }
+      })();
+    },
+    onMessage: (evt, ws) => {
+      handlersPromise.then(({ conn, actor: actor3 }) => {
+        logger().debug("received message");
+        const value = evt.data.valueOf();
+        parseMessage(value, {
+          encoding,
+          maxIncomingMessageSize: runConfig.maxIncomingMessageSize
+        }).then((message) => {
+          actor3.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: actor3, 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
+          });
+        }
+        actor3.__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 actor2;
+    let connId;
+    let connToken;
+    let connState;
+    let conn;
+    try {
+      actor2 = await actorDriver.loadActor(actorId);
+      connId = generateConnId();
+      connToken = generateConnToken();
+      connState = await actor2.prepareConn(parameters, c.req.raw);
+      logger().debug("sse open");
+      actorDriver.getGenericConnGlobalState(actorId).sseStreams.set(connId, stream);
+      conn = await actor2.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 && actor2) {
+            actor2.__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 && actor2 !== void 0) {
+        actor2.__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 actor2;
+  let conn;
+  let output;
+  try {
+    actor2 = await actorDriver.loadActor(actorId);
+    const connState = await actor2.prepareConn(parameters, c.req.raw);
+    conn = await actor2.createConn(
+      generateConnId(),
+      generateConnToken(),
+      parameters,
+      connState,
+      CONNECTION_DRIVER_HTTP,
+      {},
+      authData
+    );
+    const ctx = new ActionContext(actor2.actorContext, conn);
+    output = await actor2.executeAction(ctx, actionName, actionArgs);
+  } finally {
+    if (conn) {
+      actor2?.__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 actor2 = await actorDriver.loadActor(actorId);
+  const conn = actor2.conns.get(connId);
+  if (!conn) {
+    throw new ConnNotFound(connId);
+  }
+  if (conn._token !== connToken) {
+    throw new IncorrectConnToken();
+  }
+  await actor2.processMessage(message, conn);
+  return c.json({});
+}
+async function handleRawWebSocketHandler(req, path3, actorDriver, actorId, authData) {
+  const actor2 = await actorDriver.loadActor(actorId);
+  return {
+    onOpen: (_evt, ws) => {
+      const adapter = new HonoWebSocketAdapter(ws);
+      ws.__adapter = adapter;
+      const url = new URL(path3, "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: path3,
+        to: newRequest.url
+      });
+      actor2.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?.code || 1006, 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)}`
+    );
+  }
+}
+
+// src/manager/protocol/query.ts
+var MAX_ACTOR_KEY_SIZE = 128;
+var ActorKeySchema = z4.array(z4.string().max(MAX_ACTOR_KEY_SIZE));
+var CreateRequestSchema = z4.object({
+  name: z4.string(),
+  key: ActorKeySchema,
+  input: z4.unknown().optional(),
+  region: z4.string().optional()
+});
+var GetForKeyRequestSchema = z4.object({
+  name: z4.string(),
+  key: ActorKeySchema
+});
+var GetOrCreateRequestSchema = z4.object({
+  name: z4.string(),
+  key: ActorKeySchema,
+  input: z4.unknown().optional(),
+  region: z4.string().optional()
+});
+var ActorQuerySchema = z4.union([
+  z4.object({
+    getForId: z4.object({
+      name: z4.string(),
+      actorId: z4.string()
+    })
+  }),
+  z4.object({
+    getForKey: GetForKeyRequestSchema
+  }),
+  z4.object({
+    getOrCreateForKey: GetOrCreateRequestSchema
+  }),
+  z4.object({
+    create: CreateRequestSchema
+  })
+]);
+var ConnectRequestSchema = z4.object({
+  query: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),
+  encoding: EncodingSchema.describe(HEADER_ENCODING),
+  connParams: z4.string().optional().describe(HEADER_CONN_PARAMS)
+});
+var ConnectWebSocketRequestSchema = z4.object({
+  query: ActorQuerySchema.describe("query"),
+  encoding: EncodingSchema.describe("encoding"),
+  connParams: z4.unknown().optional().describe("conn_params")
+});
+var ConnMessageRequestSchema = z4.object({
+  actorId: z4.string().describe(HEADER_ACTOR_ID),
+  connId: z4.string().describe(HEADER_CONN_ID),
+  encoding: EncodingSchema.describe(HEADER_ENCODING),
+  connToken: z4.string().describe(HEADER_CONN_TOKEN)
+});
+var ResolveRequestSchema = z4.object({
+  query: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),
+  connParams: z4.string().optional().describe(HEADER_CONN_PARAMS)
+});
+
+// src/inspector/protocol/common.ts
+var ActorId = z5.string().brand("ActorId");
+var ActorFeature = /* @__PURE__ */ ((ActorFeature2) => {
+  ActorFeature2["Logs"] = "logs";
+  ActorFeature2["Config"] = "config";
+  ActorFeature2["Connections"] = "connections";
+  ActorFeature2["State"] = "state";
+  ActorFeature2["Console"] = "console";
+  ActorFeature2["Runtime"] = "runtime";
+  ActorFeature2["Metrics"] = "metrics";
+  ActorFeature2["EventsMonitoring"] = "events-monitoring";
+  ActorFeature2["Database"] = "database";
+  return ActorFeature2;
+})(ActorFeature || {});
+var ActorLogEntry = z5.object({
+  level: z5.string(),
+  message: z5.string(),
+  timestamp: z5.string(),
+  metadata: z5.record(z5.string(), z5.any()).optional()
+});
+var ActorSchema = z5.object({
+  id: ActorId,
+  name: z5.string(),
+  key: z5.array(z5.string()),
+  tags: z5.record(z5.string(), z5.string()).optional(),
+  region: z5.string().optional(),
+  createdAt: z5.string().optional(),
+  startedAt: z5.string().optional(),
+  destroyedAt: z5.string().optional(),
+  features: z5.array(z5.enum(ActorFeature)).optional()
+});
+var OperationSchema = z5.discriminatedUnion("op", [
+  z5.object({
+    op: z5.literal("remove"),
+    path: z5.string()
+  }),
+  z5.object({
+    op: z5.literal("add"),
+    path: z5.string(),
+    value: z5.unknown()
+  }),
+  z5.object({
+    op: z5.literal("replace"),
+    path: z5.string(),
+    value: z5.unknown()
+  }),
+  z5.object({
+    op: z5.literal("move"),
+    path: z5.string(),
+    from: z5.string()
+  }),
+  z5.object({
+    op: z5.literal("copy"),
+    path: z5.string(),
+    from: z5.string()
+  }),
+  z5.object({
+    op: z5.literal("test"),
+    path: z5.string(),
+    value: z5.unknown()
+  })
+]);
+var PatchSchema = z5.array(OperationSchema);
+var ConnectionSchema = z5.object({
+  params: z5.record(z5.string(), z5.any()).optional(),
+  id: z5.string(),
+  stateEnabled: z5.boolean().optional(),
+  state: z5.any().optional(),
+  auth: z5.record(z5.string(), z5.any()).optional()
+});
+var RealtimeEventSchema = z5.discriminatedUnion("type", [
+  z5.object({
+    type: z5.literal("action"),
+    name: z5.string(),
+    args: z5.array(z5.any()),
+    connId: z5.string()
+  }),
+  z5.object({
+    type: z5.literal("broadcast"),
+    eventName: z5.string(),
+    args: z5.array(z5.any())
+  }),
+  z5.object({
+    type: z5.literal("subscribe"),
+    eventName: z5.string(),
+    connId: z5.string()
+  }),
+  z5.object({
+    type: z5.literal("unsubscribe"),
+    eventName: z5.string(),
+    connId: z5.string()
+  }),
+  z5.object({
+    type: z5.literal("event"),
+    eventName: z5.string(),
+    args: z5.array(z5.any()),
+    connId: z5.string()
+  })
+]);
+var RecordedRealtimeEventSchema = RealtimeEventSchema.and(
+  z5.object({
+    id: z5.string(),
+    timestamp: z5.number()
+  })
+);
+var DatabaseQuerySchema = z5.object({
+  sql: z5.string(),
+  args: z5.array(z5.string().or(z5.number()))
+});
+var TableSchema = z5.object({
+  schema: z5.string(),
+  name: z5.string(),
+  type: z5.enum(["table", "view"])
+});
+var TablesSchema = z5.array(TableSchema);
+var ColumnSchema = z5.object({
+  cid: z5.number(),
+  name: z5.string(),
+  type: z5.string().toLowerCase().transform((val) => {
+    return z5.enum(["integer", "text", "real", "blob", "numeric", "serial"]).parse(val);
+  }),
+  notnull: z5.coerce.boolean(),
+  dflt_value: z5.string().nullable(),
+  pk: z5.coerce.boolean().nullable()
+});
+var ColumnsSchema = z5.array(ColumnSchema);
+var ForeignKeySchema = z5.object({
+  id: z5.number(),
+  table: z5.string(),
+  from: z5.string(),
+  to: z5.string()
+});
+var ForeignKeysSchema = z5.array(ForeignKeySchema);
+var BuildSchema = z5.object({
+  name: z5.string(),
+  createdAt: z5.string().optional(),
+  tags: z5.record(z5.string(), z5.string()).optional()
+});
+var BuildsSchema = z5.array(BuildSchema);
+var CreateActorSchema = z5.object({
+  name: z5.string(),
+  // FIXME: Replace with ActorKeySchema when ready
+  key: z5.array(z5.string().max(MAX_ACTOR_KEY_SIZE)),
+  input: z5.any()
+});
+
+// src/inspector/actor.ts
+function createActorInspectorRouter() {
+  return new Hono().get("/ping", (c) => {
+    return c.json({ message: "pong" }, 200);
+  }).get("/state", async (c) => {
+    if (await c.var.inspector.accessors.isStateEnabled()) {
+      return c.json(
+        {
+          enabled: true,
+          state: await c.var.inspector.accessors.getState()
+        },
+        200
+      );
+    }
+    return c.json({ enabled: false, state: null }, 200);
+  }).patch(
+    "/state",
+    sValidator(
+      "json",
+      z6.object({ patch: PatchSchema }).or(z6.object({ replace: z6.any() }))
+    ),
+    async (c) => {
+      if (!await c.var.inspector.accessors.isStateEnabled()) {
+        return c.json({ enabled: false }, 200);
+      }
+      const body = c.req.valid("json");
+      if ("replace" in body) {
+        await c.var.inspector.accessors.setState(body.replace);
+        return c.json(
+          {
+            enabled: true,
+            state: await c.var.inspector.accessors.getState()
+          },
+          200
+        );
+      }
+      const state = await c.var.inspector.accessors.getState();
+      const { newDocument: newState } = jsonPatch.applyPatch(
+        state,
+        body.patch
+      );
+      await c.var.inspector.accessors.setState(newState);
+      return c.json(
+        { enabled: true, state: await c.var.inspector.accessors.getState() },
+        200
+      );
+    }
+  ).get("/state/stream", async (c) => {
+    if (!await c.var.inspector.accessors.isStateEnabled()) {
+      return c.json({ enabled: false }, 200);
+    }
+    let id = 0;
+    let unsub;
+    return streamSSE2(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("stateUpdated", async (state) => {
+          stream.writeSSE({
+            data: JSON.stringify(state) || "",
+            event: "state-update",
+            id: String(id++)
+          });
+        });
+        const { promise } = Promise.withResolvers();
+        return promise;
+      },
+      async () => {
+        unsub?.();
+      }
+    );
+  }).get("/connections", async (c) => {
+    const connections = await c.var.inspector.accessors.getConnections();
+    return c.json({ connections }, 200);
+  }).get("/connections/stream", async (c) => {
+    let id = 0;
+    let unsub;
+    return streamSSE2(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("connectionUpdated", async () => {
+          stream.writeSSE({
+            data: JSON.stringify(
+              await c.var.inspector.accessors.getConnections()
+            ),
+            event: "connection-update",
+            id: String(id++)
+          });
+        });
+        const { promise } = Promise.withResolvers();
+        return promise;
+      },
+      async () => {
+        unsub?.();
+      }
+    );
+  }).get("/events", async (c) => {
+    const events = c.var.inspector.lastRealtimeEvents;
+    return c.json({ events }, 200);
+  }).post("/events/clear", async (c) => {
+    c.var.inspector.lastRealtimeEvents.length = 0;
+    return c.json({ message: "Events cleared" }, 200);
+  }).get("/events/stream", async (c) => {
+    let id = 0;
+    let unsub;
+    return streamSSE2(
+      c,
+      async (stream) => {
+        unsub = c.var.inspector.emitter.on("eventFired", () => {
+          stream.writeSSE({
+            data: JSON.stringify(c.var.inspector.lastRealtimeEvents),
+            event: "realtime-event",
+            id: String(id++)
+          });
+        });
+        const { promise } = Promise.withResolvers();
+        return promise;
+      },
+      async () => {
+        unsub?.();
+      }
+    );
+  }).get("/rpcs", async (c) => {
+    const rpcs = await c.var.inspector.accessors.getRpcs();
+    return c.json({ rpcs }, 200);
+  }).get("/db", async (c) => {
+    if (!await c.var.inspector.accessors.isDbEnabled()) {
+      return c.json({ enabled: false, db: null }, 200);
+    }
+    const db = await c.var.inspector.accessors.getDb();
+    const rows = await db.execute(`PRAGMA table_list`);
+    const tables = TablesSchema.parse(rows).filter(
+      (table) => table.schema !== "temp" && !table.name.startsWith("sqlite_")
+    );
+    const tablesInfo = await Promise.all(
+      tables.map((table) => db.execute(`PRAGMA table_info(${table.name})`))
+    );
+    const columns = tablesInfo.map((def) => ColumnsSchema.parse(def));
+    const foreignKeysList = await Promise.all(
+      tables.map(
+        (table) => db.execute(`PRAGMA foreign_key_list(${table.name})`)
+      )
+    );
+    const foreignKeys = foreignKeysList.map(
+      (def) => ForeignKeysSchema.parse(def)
+    );
+    const countInfo = await Promise.all(
+      tables.map(
+        (table) => db.execute(`SELECT COUNT(*) as count FROM ${table.name}`)
+      )
+    );
+    const counts = countInfo.map((def) => {
+      return def[0].count || 0;
+    });
+    return c.json(
+      {
+        enabled: true,
+        db: tablesInfo.map((_, index) => {
+          return {
+            table: tables[index],
+            columns: columns[index],
+            foreignKeys: foreignKeys[index],
+            records: counts[index]
+          };
+        })
+      },
+      200
+    );
+  }).post(
+    "/db",
+    sValidator(
+      "json",
+      z6.object({ query: z6.string(), params: z6.array(z6.any()).optional() })
+    ),
+    async (c) => {
+      if (!await c.var.inspector.accessors.isDbEnabled()) {
+        return c.json({ enabled: false }, 200);
+      }
+      const db = await c.var.inspector.accessors.getDb();
+      try {
+        const result = await db.execute(
+          c.req.valid("json").query,
+          ...c.req.valid("json").params || []
+        );
+        return c.json({ result }, 200);
+      } catch (error) {
+        c;
+        return c.json({ error: error.message }, 500);
+      }
+    }
+  );
+}
+var ActorInspector = class {
+  accessors;
+  emitter = createNanoEvents();
+  #lastRealtimeEvents = [];
+  get lastRealtimeEvents() {
+    return this.#lastRealtimeEvents;
+  }
+  constructor(accessors) {
+    this.accessors = accessors();
+    this.emitter.on("eventFired", (event) => {
+      this.#lastRealtimeEvents.push({
+        id: crypto.randomUUID(),
+        timestamp: Date.now(),
+        ...event
+      });
+      if (this.#lastRealtimeEvents.length > 100) {
+        this.#lastRealtimeEvents = this.#lastRealtimeEvents.slice(-100);
+      }
+    });
+  }
+};
+
+// dist/schemas/actor-persist/v1.ts
+import * as bare2 from "@bare-ts/lib";
+var config2 = /* @__PURE__ */ bare2.Config({});
+function readPersistedSubscription(bc) {
+  return {
+    eventName: bare2.readString(bc)
+  };
+}
+function writePersistedSubscription(bc, x) {
+  bare2.writeString(bc, x.eventName);
+}
+function read02(bc) {
+  return bare2.readBool(bc) ? bare2.readData(bc) : null;
+}
+function write02(bc, x) {
+  bare2.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare2.writeData(bc, x);
+  }
+}
+function read12(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedSubscription(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedSubscription(bc);
+  }
+  return result;
+}
+function write12(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedSubscription(bc, x[i]);
+  }
+}
+function readPersistedConnection(bc) {
+  return {
+    id: bare2.readString(bc),
+    token: bare2.readString(bc),
+    driver: bare2.readString(bc),
+    driverState: bare2.readData(bc),
+    parameters: bare2.readData(bc),
+    state: bare2.readData(bc),
+    auth: read02(bc),
+    subscriptions: read12(bc),
+    lastSeen: bare2.readU64(bc)
+  };
+}
+function writePersistedConnection(bc, x) {
+  bare2.writeString(bc, x.id);
+  bare2.writeString(bc, x.token);
+  bare2.writeString(bc, x.driver);
+  bare2.writeData(bc, x.driverState);
+  bare2.writeData(bc, x.parameters);
+  bare2.writeData(bc, x.state);
+  write02(bc, x.auth);
+  write12(bc, x.subscriptions);
+  bare2.writeU64(bc, x.lastSeen);
+}
+function readGenericPersistedScheduleEvent(bc) {
+  return {
+    action: bare2.readString(bc),
+    args: read02(bc)
+  };
+}
+function writeGenericPersistedScheduleEvent(bc, x) {
+  bare2.writeString(bc, x.action);
+  write02(bc, x.args);
+}
+function readPersistedScheduleEventKind(bc) {
+  const offset = bc.offset;
+  const tag = bare2.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare2.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writePersistedScheduleEventKind(bc, x) {
+  switch (x.tag) {
+    case "GenericPersistedScheduleEvent": {
+      bare2.writeU8(bc, 0);
+      writeGenericPersistedScheduleEvent(bc, x.val);
+      break;
+    }
+  }
+}
+function readPersistedScheduleEvent(bc) {
+  return {
+    eventId: bare2.readString(bc),
+    timestamp: bare2.readU64(bc),
+    kind: readPersistedScheduleEventKind(bc)
+  };
+}
+function writePersistedScheduleEvent(bc, x) {
+  bare2.writeString(bc, x.eventId);
+  bare2.writeU64(bc, x.timestamp);
+  writePersistedScheduleEventKind(bc, x.kind);
+}
+function read2(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedConnection(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedConnection(bc);
+  }
+  return result;
+}
+function write2(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedConnection(bc, x[i]);
+  }
+}
+function read3(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedScheduleEvent(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedScheduleEvent(bc);
+  }
+  return result;
+}
+function write3(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedScheduleEvent(bc, x[i]);
+  }
+}
+function readPersistedActor(bc) {
+  return {
+    input: read02(bc),
+    hasInitialized: bare2.readBool(bc),
+    state: bare2.readData(bc),
+    connections: read2(bc),
+    scheduledEvents: read3(bc)
+  };
+}
+function writePersistedActor(bc, x) {
+  write02(bc, x.input);
+  bare2.writeBool(bc, x.hasInitialized);
+  bare2.writeData(bc, x.state);
+  write2(bc, x.connections);
+  write3(bc, x.scheduledEvents);
+}
+function encodePersistedActor(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writePersistedActor(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodePersistedActor(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readPersistedActor(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/schemas/actor-persist/versioned.ts
+var CURRENT_VERSION2 = 1;
+var migrations2 = /* @__PURE__ */ new Map();
+var PERSISTED_ACTOR_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION2,
+  migrations: migrations2,
+  serializeVersion: (data) => encodePersistedActor(data),
+  deserializeVersion: (bytes) => decodePersistedActor(bytes)
+});
+
+// src/actor/context.ts
+var ActorContext = class {
+  #actor;
+  constructor(actor2) {
+    this.#actor = actor2;
+  }
+  /**
+   * Get the actor state
+   */
+  get state() {
+    return this.#actor.state;
+  }
+  /**
+   * Get the actor variables
+   */
+  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._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
+   * @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.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._sleep();
+  }
+};
+
+// src/actor/schedule.ts
+var Schedule = class {
+  #actor;
+  constructor(actor2) {
+    this.#actor = actor2;
+  }
+  async after(duration, fn, ...args) {
+    await this.#actor.scheduleEvent(Date.now() + duration, fn, args);
+  }
+  async at(timestamp, fn, ...args) {
+    await this.#actor.scheduleEvent(timestamp, fn, args);
+  }
+};
+
+// src/actor/instance.ts
+var ActorInstance = class {
+  // Shared actor context for this instance
+  actorContext;
+  #sleepCalled = false;
+  #stopCalled = false;
+  get isStopping() {
+    return this.#stopCalled || this.#sleepCalled;
+  }
+  #persistChanged = false;
+  #isInOnStateChange = false;
+  /**
+   * The proxied state that notifies of changes automatically.
+   *
+   * Any data that should be stored indefinitely should be held within this object.
+   */
+  #persist;
+  /** Raw state without the proxy wrapper */
+  #persistRaw;
+  #persistWriteQueue = new SinglePromiseQueue();
+  #alarmWriteQueue = new SinglePromiseQueue();
+  #lastSaveTime = 0;
+  #pendingSaveTimeout;
+  #vars;
+  #backgroundPromises = [];
+  #abortController = new AbortController();
+  #config;
+  #connectionDrivers;
+  #actorDriver;
+  #inlineClient;
+  #actorId;
+  #name;
+  #key;
+  #region;
+  #ready = false;
+  #connections = /* @__PURE__ */ new Map();
+  #subscriptionIndex = /* @__PURE__ */ new Map();
+  #checkConnLivenessInterval;
+  #sleepTimeout;
+  // Track active raw requests so sleep logic can account for them
+  #activeRawFetchCount = 0;
+  #activeRawWebSockets = /* @__PURE__ */ new Set();
+  #schedule;
+  #db;
+  #inspector = new ActorInspector(() => {
+    return {
+      isDbEnabled: async () => {
+        return this.#db !== void 0;
+      },
+      getDb: async () => {
+        return this.db;
+      },
+      isStateEnabled: async () => {
+        return this.stateEnabled;
+      },
+      getState: async () => {
+        this.#validateStateEnabled();
+        return this.#persistRaw.state;
+      },
+      getRpcs: async () => {
+        return Object.keys(this.#config.actions);
+      },
+      getConnections: async () => {
+        return Array.from(this.#connections.entries()).map(([id, conn]) => ({
+          id,
+          stateEnabled: conn._stateEnabled,
+          params: conn.params,
+          state: conn._stateEnabled ? conn.state : void 0,
+          auth: conn.auth
+        }));
+      },
+      setState: async (state) => {
+        this.#validateStateEnabled();
+        this.#persist.state = { ...state };
+        await this.saveState({ immediate: true });
+      }
+    };
+  });
+  get id() {
+    return this.#actorId;
+  }
+  get inlineClient() {
+    return this.#inlineClient;
+  }
+  get inspector() {
+    return this.#inspector;
+  }
+  get #sleepingSupported() {
+    return this.#actorDriver.sleep !== void 0;
+  }
+  /**
+   * This constructor should never be used directly.
+   *
+   * Constructed in {@link ActorInstance.start}.
+   *
+   * @private
+   */
+  constructor(config4) {
+    this.#config = config4;
+    this.actorContext = new ActorContext(this);
+  }
+  async start(connectionDrivers, actorDriver, inlineClient, actorId, name, key, region) {
+    this.#connectionDrivers = connectionDrivers;
+    this.#actorDriver = actorDriver;
+    this.#inlineClient = inlineClient;
+    this.#actorId = actorId;
+    this.#name = name;
+    this.#key = key;
+    this.#region = region;
+    this.#schedule = new Schedule(this);
+    await this.#initialize();
+    if (this.#varsEnabled) {
+      let vars;
+      if ("createVars" in this.#config) {
+        const dataOrPromise = this.#config.createVars(
+          this.actorContext,
+          this.#actorDriver.getContext(this.#actorId)
+        );
+        if (dataOrPromise instanceof Promise) {
+          vars = await deadline(
+            dataOrPromise,
+            this.#config.options.createVarsTimeout
+          );
+        } else {
+          vars = dataOrPromise;
+        }
+      } else if ("vars" in this.#config) {
+        vars = structuredClone(this.#config.vars);
+      } else {
+        throw new Error("Could not variables from 'createVars' or 'vars'");
+      }
+      this.#vars = vars;
+    }
+    logger().info("actor starting");
+    if (this.#config.onStart) {
+      const result = this.#config.onStart(this.actorContext);
+      if (result instanceof Promise) {
+        await result;
+      }
+    }
+    if ("db" in this.#config && this.#config.db) {
+      const client = await this.#config.db.createClient({
+        getDatabase: () => actorDriver.getDatabase(this.#actorId)
+      });
+      logger().info("database migration starting");
+      await this.#config.db.onMigrate?.(client);
+      logger().info("database migration complete");
+      this.#db = client;
+    }
+    if (this.#persist.scheduledEvents.length > 0) {
+      await this.#queueSetAlarm(this.#persist.scheduledEvents[0].timestamp);
+    }
+    logger().info("actor ready");
+    this.#ready = true;
+    this.#resetSleepTimer();
+    this.#checkConnLivenessInterval = setInterval(
+      this.#checkConnectionsLiveness.bind(this),
+      this.#config.options.connectionLivenessInterval
+    );
+    this.#checkConnectionsLiveness();
+  }
+  async #scheduleEventInner(newEvent) {
+    this.actorContext.log.info("scheduling event", newEvent);
+    const insertIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp > newEvent.timestamp
+    );
+    if (insertIndex === -1) {
+      this.#persist.scheduledEvents.push(newEvent);
+    } else {
+      this.#persist.scheduledEvents.splice(insertIndex, 0, newEvent);
+    }
+    if (insertIndex === 0 || this.#persist.scheduledEvents.length === 1) {
+      this.actorContext.log.info("setting alarm", {
+        timestamp: newEvent.timestamp,
+        eventCount: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(newEvent.timestamp);
+    }
+  }
+  async _onAlarm() {
+    const now = Date.now();
+    this.actorContext.log.debug("alarm triggered", {
+      now,
+      events: this.#persist.scheduledEvents.length
+    });
+    this.#resetSleepTimer();
+    const runIndex = this.#persist.scheduledEvents.findIndex(
+      (x) => x.timestamp <= now
+    );
+    if (runIndex === -1) {
+      logger().warn("no events are due yet, time may have broken");
+      if (this.#persist.scheduledEvents.length > 0) {
+        const nextTs = this.#persist.scheduledEvents[0].timestamp;
+        this.actorContext.log.warn(
+          "alarm fired early, rescheduling for next event",
+          {
+            now,
+            nextTs,
+            delta: nextTs - now
+          }
+        );
+        await this.#queueSetAlarm(nextTs);
+      }
+      this.actorContext.log.debug("no events to run", { now });
+      return;
+    }
+    const scheduleEvents = this.#persist.scheduledEvents.splice(
+      0,
+      runIndex + 1
+    );
+    this.actorContext.log.debug("running events", {
+      count: scheduleEvents.length
+    });
+    if (this.#persist.scheduledEvents.length > 0) {
+      const nextTs = this.#persist.scheduledEvents[0].timestamp;
+      this.actorContext.log.info("setting next alarm", {
+        nextTs,
+        remainingEvents: this.#persist.scheduledEvents.length
+      });
+      await this.#queueSetAlarm(nextTs);
+    }
+    for (const event of scheduleEvents) {
+      try {
+        this.actorContext.log.info("running action for event", {
+          event: event.eventId,
+          timestamp: event.timestamp,
+          action: event.kind.generic.actionName
+        });
+        const fn = this.#config.actions[event.kind.generic.actionName];
+        if (!fn)
+          throw new Error(
+            `Missing action for alarm ${event.kind.generic.actionName}`
+          );
+        if (typeof fn !== "function")
+          throw new Error(
+            `Alarm function lookup for ${event.kind.generic.actionName} returned ${typeof fn}`
+          );
+        try {
+          const args = event.kind.generic.args ? cbor5.decode(new Uint8Array(event.kind.generic.args)) : [];
+          await fn.call(void 0, this.actorContext, ...args);
+        } catch (error) {
+          this.actorContext.log.error("error while running event", {
+            error: stringifyError(error),
+            event: event.eventId,
+            timestamp: event.timestamp,
+            action: event.kind.generic.actionName
+          });
+        }
+      } catch (error) {
+        this.actorContext.log.error("internal error while running event", {
+          error: stringifyError(error),
+          ...event
+        });
+      }
+    }
+  }
+  async scheduleEvent(timestamp, action, args) {
+    return this.#scheduleEventInner({
+      eventId: crypto.randomUUID(),
+      timestamp,
+      kind: {
+        generic: {
+          actionName: action,
+          args: bufferToArrayBuffer(cbor5.encode(args))
+        }
+      }
+    });
+  }
+  get stateEnabled() {
+    return "createState" in this.#config || "state" in this.#config;
+  }
+  #validateStateEnabled() {
+    if (!this.stateEnabled) {
+      throw new StateNotEnabled();
+    }
+  }
+  get #connStateEnabled() {
+    return "createConnState" in this.#config || "connState" in this.#config;
+  }
+  get #varsEnabled() {
+    return "createVars" in this.#config || "vars" in this.#config;
+  }
+  #validateVarsEnabled() {
+    if (!this.#varsEnabled) {
+      throw new VarsNotEnabled();
+    }
+  }
+  /** Promise used to wait for a save to complete. This is required since you cannot await `#saveStateThrottled`. */
+  #onPersistSavedPromise;
+  /** Throttled save state method. Used to write to KV at a reasonable cadence. */
+  #savePersistThrottled() {
+    const now = Date.now();
+    const timeSinceLastSave = now - this.#lastSaveTime;
+    const saveInterval = this.#config.options.stateSaveInterval;
+    if (timeSinceLastSave < saveInterval) {
+      if (this.#pendingSaveTimeout === void 0) {
+        this.#pendingSaveTimeout = setTimeout(() => {
+          this.#pendingSaveTimeout = void 0;
+          this.#savePersistInner();
+        }, saveInterval - timeSinceLastSave);
+      }
+    } else {
+      this.#savePersistInner();
+    }
+  }
+  /** Saves the state to KV. You probably want to use #saveStateThrottled instead except for a few edge cases. */
+  async #savePersistInner() {
+    try {
+      this.#lastSaveTime = Date.now();
+      if (this.#persistChanged) {
+        const finished = this.#persistWriteQueue.enqueue(async () => {
+          logger().debug("saving persist");
+          this.#persistChanged = false;
+          const bareData = this.#convertToBarePersisted(this.#persistRaw);
+          await this.#actorDriver.writePersistedData(
+            this.#actorId,
+            PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData)
+          );
+          logger().debug("persist saved");
+        });
+        await finished;
+      }
+      this.#onPersistSavedPromise?.resolve();
+    } catch (error) {
+      this.#onPersistSavedPromise?.reject(error);
+      throw error;
+    }
+  }
+  async #queueSetAlarm(timestamp) {
+    await this.#alarmWriteQueue.enqueue(async () => {
+      await this.#actorDriver.setAlarm(this, timestamp);
+    });
+  }
+  /**
+   * Creates proxy for `#persist` that handles automatically flagging when state needs to be updated.
+   */
+  #setPersist(target) {
+    this.#persistRaw = target;
+    if (target === null || typeof target !== "object") {
+      let invalidPath = "";
+      if (!isCborSerializable(
+        target,
+        (path3) => {
+          invalidPath = path3;
+        },
+        ""
+      )) {
+        throw new InvalidStateType({ path: invalidPath });
+      }
+      return target;
+    }
+    if (this.#persist) {
+      onChange.unsubscribe(this.#persist);
+    }
+    this.#persist = onChange(
+      target,
+      // biome-ignore lint/suspicious/noExplicitAny: Don't know types in proxy
+      (path3, value, _previousValue, _applyData) => {
+        if (path3 !== "state" && !path3.startsWith("state.")) {
+          return;
+        }
+        let invalidPath = "";
+        if (!isCborSerializable(
+          value,
+          (invalidPathPart) => {
+            invalidPath = invalidPathPart;
+          },
+          ""
+        )) {
+          throw new InvalidStateType({
+            path: path3 + (invalidPath ? `.${invalidPath}` : "")
+          });
+        }
+        this.#persistChanged = true;
+        this.inspector.emitter.emit("stateUpdated", this.#persist.state);
+        if (this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {
+          try {
+            this.#isInOnStateChange = true;
+            this.#config.onStateChange(
+              this.actorContext,
+              this.#persistRaw.state
+            );
+          } catch (error) {
+            logger().error("error in `_onStateChange`", {
+              error: stringifyError(error)
+            });
+          } finally {
+            this.#isInOnStateChange = false;
+          }
+        }
+      },
+      { ignoreDetached: true }
+    );
+  }
+  async #initialize() {
+    const persistDataBuffer = await this.#actorDriver.readPersistedData(
+      this.#actorId
+    );
+    invariant2(
+      persistDataBuffer !== void 0,
+      "persist data has not been set, it should be set when initialized"
+    );
+    const bareData = PERSISTED_ACTOR_VERSIONED.deserializeWithEmbeddedVersion(
+      persistDataBuffer
+    );
+    const persistData = this.#convertFromBarePersisted(bareData);
+    if (persistData.hasInitiated) {
+      logger().info("actor restoring", {
+        connections: persistData.connections.length
+      });
+      this.#setPersist(persistData);
+      for (const connPersist of this.#persist.connections) {
+        const driver = this.__getConnDriver(connPersist.connDriver);
+        const conn = new Conn(
+          this,
+          connPersist,
+          driver,
+          this.#connStateEnabled
+        );
+        this.#connections.set(conn.id, conn);
+        for (const sub of connPersist.subscriptions) {
+          this.#addSubscription(sub.eventName, conn, true);
+        }
+      }
+    } else {
+      logger().info("actor creating");
+      let stateData;
+      if (this.stateEnabled) {
+        logger().info("actor state initializing");
+        if ("createState" in this.#config) {
+          this.#config.createState;
+          stateData = await this.#config.createState(
+            this.actorContext,
+            persistData.input
+          );
+        } else if ("state" in this.#config) {
+          stateData = structuredClone(this.#config.state);
+        } else {
+          throw new Error("Both 'createState' or 'state' were not defined");
+        }
+      } else {
+        logger().debug("state not enabled");
+      }
+      persistData.state = stateData;
+      persistData.hasInitiated = true;
+      logger().debug("writing state");
+      const bareData2 = this.#convertToBarePersisted(persistData);
+      await this.#actorDriver.writePersistedData(
+        this.#actorId,
+        PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData2)
+      );
+      this.#setPersist(persistData);
+      if (this.#config.onCreate) {
+        await this.#config.onCreate(this.actorContext, persistData.input);
+      }
+    }
+  }
+  __getConnForId(id) {
+    return this.#connections.get(id);
+  }
+  /**
+   * Removes a connection and cleans up its resources.
+   */
+  __removeConn(conn) {
+    if (!conn) {
+      logger().warn("`conn` does not exist");
+      return;
+    }
+    const connIdx = this.#persist.connections.findIndex(
+      (c) => c.connId === conn.id
+    );
+    if (connIdx !== -1) {
+      this.#persist.connections.splice(connIdx, 1);
+      this.saveState({ immediate: true, allowStoppingState: true });
+    } else {
+      logger().warn("could not find persisted connection to remove", {
+        connId: conn.id
+      });
+    }
+    this.#connections.delete(conn.id);
+    for (const eventName of [...conn.subscriptions.values()]) {
+      this.#removeSubscription(eventName, conn, true);
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    if (this.#config.onDisconnect) {
+      try {
+        const result = this.#config.onDisconnect(this.actorContext, conn);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            logger().error("error in `onDisconnect`", {
+              error: stringifyError(error)
+            });
+          });
+        }
+      } catch (error) {
+        logger().error("error in `onDisconnect`", {
+          error: stringifyError(error)
+        });
+      }
+    }
+    this.#resetSleepTimer();
+  }
+  async prepareConn(params, request) {
+    let connState;
+    const onBeforeConnectOpts = {
+      request
+    };
+    if (this.#config.onBeforeConnect) {
+      await this.#config.onBeforeConnect(
+        this.actorContext,
+        onBeforeConnectOpts,
+        params
+      );
+    }
+    if (this.#connStateEnabled) {
+      if ("createConnState" in this.#config) {
+        const dataOrPromise = this.#config.createConnState(
+          this.actorContext,
+          onBeforeConnectOpts,
+          params
+        );
+        if (dataOrPromise instanceof Promise) {
+          connState = await deadline(
+            dataOrPromise,
+            this.#config.options.createConnStateTimeout
+          );
+        } else {
+          connState = dataOrPromise;
+        }
+      } else if ("connState" in this.#config) {
+        connState = structuredClone(this.#config.connState);
+      } else {
+        throw new Error(
+          "Could not create connection state from 'createConnState' or 'connState'"
+        );
+      }
+    }
+    return connState;
+  }
+  __getConnDriver(driverId) {
+    const driver = this.#connectionDrivers[driverId];
+    if (!driver) throw new Error(`No connection driver: ${driverId}`);
+    return driver;
+  }
+  /**
+   * Called after establishing a connection handshake.
+   */
+  async createConn(connectionId, connectionToken, params, state, driverId, driverState, authData) {
+    this.#assertReady();
+    if (this.#connections.has(connectionId)) {
+      throw new Error(`Connection already exists: ${connectionId}`);
+    }
+    const driver = this.__getConnDriver(driverId);
+    const persist = {
+      connId: connectionId,
+      token: connectionToken,
+      connDriver: driverId,
+      connDriverState: driverState,
+      params,
+      state,
+      authData,
+      lastSeen: Date.now(),
+      subscriptions: []
+    };
+    const conn = new Conn(
+      this,
+      persist,
+      driver,
+      this.#connStateEnabled
+    );
+    this.#connections.set(conn.id, conn);
+    this.#resetSleepTimer();
+    this.#persist.connections.push(persist);
+    this.saveState({ immediate: true });
+    if (this.#config.onConnect) {
+      try {
+        const result = this.#config.onConnect(this.actorContext, conn);
+        if (result instanceof Promise) {
+          deadline(result, this.#config.options.onConnectTimeout).catch(
+            (error) => {
+              logger().error("error in `onConnect`, closing socket", {
+                error
+              });
+              conn?.disconnect("`onConnect` failed");
+            }
+          );
+        }
+      } catch (error) {
+        logger().error("error in `onConnect`", {
+          error: stringifyError(error)
+        });
+        conn?.disconnect("`onConnect` failed");
+      }
+    }
+    this.inspector.emitter.emit("connectionUpdated");
+    conn._sendMessage(
+      new CachedSerializer(
+        {
+          body: {
+            tag: "Init",
+            val: {
+              actorId: this.id,
+              connectionId: conn.id,
+              connectionToken: conn._token
+            }
+          }
+        },
+        TO_CLIENT_VERSIONED
+      )
+    );
+    return conn;
+  }
+  // MARK: Messages
+  async processMessage(message, conn) {
+    await processMessage(message, this, conn, {
+      onExecuteAction: async (ctx, name, args) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "action",
+          name,
+          args,
+          connId: conn.id
+        });
+        return await this.executeAction(ctx, name, args);
+      },
+      onSubscribe: async (eventName, conn2) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "subscribe",
+          eventName,
+          connId: conn2.id
+        });
+        this.#addSubscription(eventName, conn2, false);
+      },
+      onUnsubscribe: async (eventName, conn2) => {
+        this.inspector.emitter.emit("eventFired", {
+          type: "unsubscribe",
+          eventName,
+          connId: conn2.id
+        });
+        this.#removeSubscription(eventName, conn2, false);
+      }
+    });
+  }
+  // MARK: Events
+  #addSubscription(eventName, connection, fromPersist) {
+    if (connection.subscriptions.has(eventName)) {
+      logger().debug("connection already has subscription", { eventName });
+      return;
+    }
+    if (!fromPersist) {
+      connection.__persist.subscriptions.push({ eventName });
+      this.saveState({ immediate: true });
+    }
+    connection.subscriptions.add(eventName);
+    let subscribers = this.#subscriptionIndex.get(eventName);
+    if (!subscribers) {
+      subscribers = /* @__PURE__ */ new Set();
+      this.#subscriptionIndex.set(eventName, subscribers);
+    }
+    subscribers.add(connection);
+  }
+  #removeSubscription(eventName, connection, fromRemoveConn) {
+    if (!connection.subscriptions.has(eventName)) {
+      logger().warn("connection does not have subscription", { eventName });
+      return;
+    }
+    if (!fromRemoveConn) {
+      connection.subscriptions.delete(eventName);
+      const subIdx = connection.__persist.subscriptions.findIndex(
+        (s) => s.eventName === eventName
+      );
+      if (subIdx !== -1) {
+        connection.__persist.subscriptions.splice(subIdx, 1);
+      } else {
+        logger().warn("subscription does not exist with name", { eventName });
+      }
+      this.saveState({ immediate: true });
+    }
+    const subscribers = this.#subscriptionIndex.get(eventName);
+    if (subscribers) {
+      subscribers.delete(connection);
+      if (subscribers.size === 0) {
+        this.#subscriptionIndex.delete(eventName);
+      }
+    }
+  }
+  #assertReady(allowStoppingState = false) {
+    if (!this.#ready) throw new InternalError("Actor not ready");
+    if (!allowStoppingState && this.#sleepCalled)
+      throw new InternalError("Actor is going to sleep");
+    if (!allowStoppingState && this.#stopCalled)
+      throw new InternalError("Actor is stopping");
+  }
+  /**
+   * Check the liveness of all connections.
+   * Sets up a recurring check based on the configured interval.
+   */
+  #checkConnectionsLiveness() {
+    logger().debug("checking connections liveness");
+    for (const conn of this.#connections.values()) {
+      const liveness = conn[CONNECTION_CHECK_LIVENESS_SYMBOL]();
+      if (liveness.status === "connected") {
+        logger().debug("connection is alive", { connId: conn.id });
+      } else {
+        const lastSeen = liveness.lastSeen;
+        const sinceLastSeen = Date.now() - lastSeen;
+        if (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {
+          logger().debug("connection might be alive, will check later", {
+            connId: conn.id,
+            lastSeen,
+            sinceLastSeen
+          });
+          continue;
+        }
+        logger().warn("connection is dead, removing", {
+          connId: conn.id,
+          lastSeen
+        });
+        this.__removeConn(conn);
+      }
+    }
+  }
+  /**
+   * Check if the actor is ready to handle requests.
+   */
+  isReady() {
+    return this.#ready;
+  }
+  /**
+   * Execute an action call from a client.
+   *
+   * This method handles:
+   * 1. Validating the action name
+   * 2. Executing the action function
+   * 3. Processing the result through onBeforeActionResponse (if configured)
+   * 4. Handling timeouts and errors
+   * 5. Saving state changes
+   *
+   * @param ctx The action context
+   * @param actionName The name of the action being called
+   * @param args The arguments passed to the action
+   * @returns The result of the action call
+   * @throws {ActionNotFound} If the action doesn't exist
+   * @throws {ActionTimedOut} If the action times out
+   * @internal
+   */
+  async executeAction(ctx, actionName, args) {
+    invariant2(this.#ready, "executing action before ready");
+    if (!(actionName in this.#config.actions)) {
+      logger().warn("action does not exist", { actionName });
+      throw new ActionNotFound(actionName);
+    }
+    const actionFunction = this.#config.actions[actionName];
+    if (typeof actionFunction !== "function") {
+      logger().warn("action is not a function", {
+        actionName,
+        type: typeof actionFunction
+      });
+      throw new ActionNotFound(actionName);
+    }
+    try {
+      logger().debug("executing action", { actionName, args });
+      const outputOrPromise = actionFunction.call(void 0, ctx, ...args);
+      let output;
+      if (outputOrPromise instanceof Promise) {
+        logger().debug("awaiting async action", { actionName });
+        output = await deadline(
+          outputOrPromise,
+          this.#config.options.actionTimeout
+        );
+        logger().debug("async action completed", { actionName });
+      } else {
+        output = outputOrPromise;
+      }
+      if (this.#config.onBeforeActionResponse) {
+        try {
+          const processedOutput = this.#config.onBeforeActionResponse(
+            this.actorContext,
+            actionName,
+            args,
+            output
+          );
+          if (processedOutput instanceof Promise) {
+            logger().debug("awaiting onBeforeActionResponse", {
+              actionName
+            });
+            output = await processedOutput;
+            logger().debug("onBeforeActionResponse completed", {
+              actionName
+            });
+          } else {
+            output = processedOutput;
+          }
+        } catch (error) {
+          logger().error("error in `onBeforeActionResponse`", {
+            error: stringifyError(error)
+          });
+        }
+      }
+      logger().debug("action completed", {
+        actionName,
+        outputType: typeof output,
+        isPromise: output instanceof Promise
+      });
+      return output;
+    } catch (error) {
+      if (error instanceof DeadlineError) {
+        throw new ActionTimedOut();
+      }
+      logger().error("action error", {
+        actionName,
+        error: stringifyError(error)
+      });
+      throw error;
+    } finally {
+      this.#savePersistThrottled();
+    }
+  }
+  /**
+   * Returns a list of action methods available on this actor.
+   */
+  get actions() {
+    return Object.keys(this.#config.actions);
+  }
+  /**
+   * Handles raw HTTP requests to the actor.
+   */
+  async handleFetch(request, opts) {
+    this.#assertReady();
+    if (!this.#config.onFetch) {
+      throw new FetchHandlerNotDefined();
+    }
+    this.#activeRawFetchCount++;
+    this.#resetSleepTimer();
+    try {
+      const response = await this.#config.onFetch(
+        this.actorContext,
+        request,
+        opts
+      );
+      if (!response) {
+        throw new InvalidFetchResponse();
+      }
+      return response;
+    } catch (error) {
+      logger().error("onFetch error", {
+        error: stringifyError(error)
+      });
+      throw error;
+    } finally {
+      this.#activeRawFetchCount = Math.max(0, this.#activeRawFetchCount - 1);
+      this.#resetSleepTimer();
+      this.#savePersistThrottled();
+    }
+  }
+  /**
+   * Handles raw WebSocket connections to the actor.
+   */
+  async handleWebSocket(websocket, opts) {
+    this.#assertReady();
+    if (!this.#config.onWebSocket) {
+      throw new InternalError("onWebSocket handler not defined");
+    }
+    try {
+      const stateBeforeHandler = this.#persistChanged;
+      this.#activeRawWebSockets.add(websocket);
+      this.#resetSleepTimer();
+      const onSocketClosed = () => {
+        try {
+          websocket.removeEventListener("close", onSocketClosed);
+          websocket.removeEventListener("error", onSocketClosed);
+        } catch {
+        }
+        this.#activeRawWebSockets.delete(websocket);
+        this.#resetSleepTimer();
+      };
+      try {
+        websocket.addEventListener("close", onSocketClosed);
+        websocket.addEventListener("error", onSocketClosed);
+      } catch {
+      }
+      await this.#config.onWebSocket(this.actorContext, websocket, opts);
+      if (this.#persistChanged && !stateBeforeHandler) {
+        await this.saveState({ immediate: true });
+      }
+    } catch (error) {
+      logger().error("onWebSocket error", {
+        error: stringifyError(error)
+      });
+      throw error;
+    } finally {
+      this.#savePersistThrottled();
+    }
+  }
+  // MARK: Lifecycle hooks
+  // MARK: Exposed methods
+  /**
+   * Gets the logger instance.
+   */
+  get log() {
+    return instanceLogger();
+  }
+  /**
+   * Gets the name.
+   */
+  get name() {
+    return this.#name;
+  }
+  /**
+   * Gets the key.
+   */
+  get key() {
+    return this.#key;
+  }
+  /**
+   * Gets the region.
+   */
+  get region() {
+    return this.#region;
+  }
+  /**
+   * Gets the scheduler.
+   */
+  get schedule() {
+    return this.#schedule;
+  }
+  /**
+   * Gets the map of connections.
+   */
+  get conns() {
+    return this.#connections;
+  }
+  /**
+   * Gets the current state.
+   *
+   * Changing properties of this value will automatically be persisted.
+   */
+  get state() {
+    this.#validateStateEnabled();
+    return this.#persist.state;
+  }
+  /**
+   * Gets the database.
+   * @experimental
+   * @throws {DatabaseNotEnabled} If the database is not enabled.
+   */
+  get db() {
+    if (!this.#db) {
+      throw new DatabaseNotEnabled();
+    }
+    return this.#db;
+  }
+  /**
+   * Sets the current state.
+   *
+   * This property will automatically be persisted.
+   */
+  set state(value) {
+    this.#validateStateEnabled();
+    this.#persist.state = value;
+  }
+  get vars() {
+    this.#validateVarsEnabled();
+    invariant2(this.#vars !== void 0, "vars not enabled");
+    return this.#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.#assertReady();
+    this.inspector.emitter.emit("eventFired", {
+      type: "broadcast",
+      eventName: name,
+      args
+    });
+    const subscriptions = this.#subscriptionIndex.get(name);
+    if (!subscriptions) return;
+    const toClientSerializer = new CachedSerializer(
+      {
+        body: {
+          tag: "Event",
+          val: {
+            name,
+            args: bufferToArrayBuffer(cbor5.encode(args))
+          }
+        }
+      },
+      TO_CLIENT_VERSIONED
+    );
+    for (const connection of subscriptions) {
+      connection._sendMessage(toClientSerializer);
+    }
+  }
+  /**
+   * Prevents the actor from sleeping until promise is complete.
+   *
+   * This allows the actor runtime to ensure that a promise completes while
+   * returning from an action request early.
+   *
+   * @param promise - The promise to run in the background.
+   */
+  _waitUntil(promise) {
+    this.#assertReady();
+    const nonfailablePromise = promise.then(() => {
+      logger().debug("wait until promise complete");
+    }).catch((error) => {
+      logger().error("wait until promise failed", {
+        error: stringifyError(error)
+      });
+    });
+    this.#backgroundPromises.push(nonfailablePromise);
+  }
+  /**
+   * Forces the state to get saved.
+   *
+   * This is helpful if running a long task that may fail later or when
+   * running a background job that updates the state.
+   *
+   * @param opts - Options for saving the state.
+   */
+  async saveState(opts) {
+    this.#assertReady(opts.allowStoppingState);
+    if (this.#persistChanged) {
+      if (opts.immediate) {
+        await this.#savePersistInner();
+      } else {
+        if (!this.#onPersistSavedPromise) {
+          this.#onPersistSavedPromise = Promise.withResolvers();
+        }
+        this.#savePersistThrottled();
+        await this.#onPersistSavedPromise.promise;
+      }
+    }
+  }
+  // MARK: Sleep
+  /**
+   * Reset timer from the last actor interaction that allows it to be put to sleep.
+   *
+   * This should be called any time a sleep-related event happens:
+   * - Connection opens (will clear timer)
+   * - Connection closes (will schedule timer if there are no open connections)
+   * - Alarm triggers (will reset timer)
+   *
+   * We don't need to call this on events like individual action calls, since there will always be a connection open for these.
+   **/
+  #resetSleepTimer() {
+    if (this.#config.options.noSleep || !this.#sleepingSupported) return;
+    const canSleep = this.#canSleep();
+    logger().debug("resetting sleep timer", {
+      canSleep,
+      existingTimeout: !!this.#sleepTimeout
+    });
+    if (this.#sleepTimeout) {
+      clearTimeout(this.#sleepTimeout);
+      this.#sleepTimeout = void 0;
+    }
+    if (this.#sleepCalled) return;
+    if (canSleep) {
+      this.#sleepTimeout = setTimeout(() => {
+        this._sleep().catch((error) => {
+          logger().error("error during sleep", {
+            error: stringifyError(error)
+          });
+        });
+      }, this.#config.options.sleepTimeout);
+    }
+  }
+  /** If this actor can be put in a sleeping state. */
+  #canSleep() {
+    if (!this.#ready) return false;
+    for (const conn of this.#connections.values()) {
+      if (conn.status === "connected") return false;
+    }
+    if (this.#activeRawFetchCount > 0) return false;
+    if (this.#activeRawWebSockets.size > 0) return false;
+    return true;
+  }
+  /** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */
+  async _sleep() {
+    const sleep2 = this.#actorDriver.sleep?.bind(
+      this.#actorDriver,
+      this.#actorId
+    );
+    invariant2(this.#sleepingSupported, "sleeping not supported");
+    invariant2(sleep2, "no sleep on driver");
+    if (this.#sleepCalled) {
+      logger().warn("already sleeping actor");
+      return;
+    }
+    this.#sleepCalled = true;
+    logger().info("actor sleeping");
+    setImmediate(async () => {
+      await sleep2();
+    });
+  }
+  // MARK: Stop
+  async _stop() {
+    if (this.#stopCalled) {
+      logger().warn("already stopping actor");
+      return;
+    }
+    this.#stopCalled = true;
+    logger().info("actor stopping");
+    try {
+      this.#abortController.abort();
+    } catch {
+    }
+    if (this.#config.onStop) {
+      try {
+        logger().debug("calling onStop");
+        const result = this.#config.onStop(this.actorContext);
+        if (result instanceof Promise) {
+          await deadline(result, this.#config.options.onStopTimeout);
+        }
+        logger().debug("onStop completed");
+      } catch (error) {
+        if (error instanceof DeadlineError) {
+          logger().error("onStop timed out");
+        } else {
+          logger().error("error in onStop", {
+            error: stringifyError(error)
+          });
+        }
+      }
+    }
+    const promises = [];
+    for (const connection of this.#connections.values()) {
+      promises.push(connection.disconnect());
+    }
+    await this.#waitBackgroundPromises(this.#config.options.waitUntilTimeout);
+    if (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);
+    if (this.#sleepTimeout) clearTimeout(this.#sleepTimeout);
+    if (this.#checkConnLivenessInterval)
+      clearInterval(this.#checkConnLivenessInterval);
+    await this.saveState({ immediate: true, allowStoppingState: true });
+    const res = Promise.race([
+      Promise.all(promises).then(() => false),
+      new Promise(
+        (res2) => globalThis.setTimeout(() => res2(true), 1500)
+      )
+    ]);
+    if (await res) {
+      logger().warn(
+        "timed out waiting for connections to close, shutting down anyway"
+      );
+    }
+    if (this.#persistWriteQueue.runningDrainLoop)
+      await this.#persistWriteQueue.runningDrainLoop;
+    if (this.#alarmWriteQueue.runningDrainLoop)
+      await this.#alarmWriteQueue.runningDrainLoop;
+  }
+  /** Abort signal that fires when the actor is stopping. */
+  get abortSignal() {
+    return this.#abortController.signal;
+  }
+  /** Wait for background waitUntil promises with a timeout. */
+  async #waitBackgroundPromises(timeoutMs) {
+    const pending = this.#backgroundPromises;
+    if (pending.length === 0) {
+      logger().debug("no background promises");
+      return;
+    }
+    const timedOut = await Promise.race([
+      Promise.allSettled(pending).then(() => false),
+      new Promise(
+        (resolve) => setTimeout(() => resolve(true), timeoutMs)
+      )
+    ]);
+    if (timedOut) {
+      logger().error(
+        "timed out waiting for background tasks, background promises may have leaked",
+        {
+          count: pending.length,
+          timeoutMs
+        }
+      );
+    } else {
+      logger().debug("background promises finished");
+    }
+  }
+  // MARK: BARE Conversion Helpers
+  #convertToBarePersisted(persist) {
+    return {
+      input: persist.input !== void 0 ? bufferToArrayBuffer(cbor5.encode(persist.input)) : null,
+      hasInitialized: persist.hasInitiated,
+      state: bufferToArrayBuffer(cbor5.encode(persist.state)),
+      connections: persist.connections.map((conn) => ({
+        id: conn.connId,
+        token: conn.token,
+        driver: conn.connDriver,
+        driverState: bufferToArrayBuffer(
+          cbor5.encode(conn.connDriverState || {})
+        ),
+        parameters: bufferToArrayBuffer(cbor5.encode(conn.params || {})),
+        state: bufferToArrayBuffer(cbor5.encode(conn.state || {})),
+        auth: conn.authData !== void 0 ? bufferToArrayBuffer(cbor5.encode(conn.authData)) : null,
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: BigInt(conn.lastSeen)
+      })),
+      scheduledEvents: persist.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: BigInt(event.timestamp),
+        kind: {
+          tag: "GenericPersistedScheduleEvent",
+          val: {
+            action: event.kind.generic.actionName,
+            args: event.kind.generic.args ?? null
+          }
+        }
+      }))
+    };
+  }
+  #convertFromBarePersisted(bareData) {
+    return {
+      input: bareData.input ? cbor5.decode(new Uint8Array(bareData.input)) : void 0,
+      hasInitiated: bareData.hasInitialized,
+      state: cbor5.decode(new Uint8Array(bareData.state)),
+      connections: bareData.connections.map((conn) => ({
+        connId: conn.id,
+        token: conn.token,
+        connDriver: conn.driver,
+        connDriverState: cbor5.decode(new Uint8Array(conn.driverState)),
+        params: cbor5.decode(new Uint8Array(conn.parameters)),
+        state: cbor5.decode(new Uint8Array(conn.state)),
+        authData: conn.auth ? cbor5.decode(new Uint8Array(conn.auth)) : void 0,
+        subscriptions: conn.subscriptions.map((sub) => ({
+          eventName: sub.eventName
+        })),
+        lastSeen: Number(conn.lastSeen)
+      })),
+      scheduledEvents: bareData.scheduledEvents.map((event) => ({
+        eventId: event.eventId,
+        timestamp: Number(event.timestamp),
+        kind: {
+          generic: {
+            actionName: event.kind.val.action,
+            args: event.kind.val.args
+          }
+        }
+      }))
+    };
+  }
+};
+
+// src/actor/definition.ts
+var ActorDefinition = class {
+  #config;
+  constructor(config4) {
+    this.#config = config4;
+  }
+  get config() {
+    return this.#config;
+  }
+  instantiate() {
+    return new ActorInstance(this.#config);
+  }
+};
+function lookupInRegistry(registryConfig, name) {
+  const definition = registryConfig.use[name];
+  if (!definition) throw new Error(`no actor in registry for name ${name}`);
+  return definition;
+}
+
+// src/actor/generic-conn-driver.ts
+var GenericConnGlobalState = class {
+  websockets = /* @__PURE__ */ new Map();
+  sseStreams = /* @__PURE__ */ new Map();
+};
+function createGenericConnDrivers(globalState) {
+  return {
+    [CONNECTION_DRIVER_WEBSOCKET]: createGenericWebSocketDriver(globalState),
+    [CONNECTION_DRIVER_SSE]: createGenericSseDriver(globalState),
+    [CONNECTION_DRIVER_HTTP]: createGenericHttpDriver()
+  };
+}
+function createGenericWebSocketDriver(globalState) {
+  return {
+    sendMessage: (actor2, conn, state, message) => {
+      const ws = globalState.websockets.get(conn.id);
+      if (!ws) {
+        logger().warn("missing ws for sendMessage", {
+          actorId: actor2.id,
+          connId: conn.id,
+          totalCount: globalState.websockets.size
+        });
+        return;
+      }
+      const serialized = message.serialize(state.encoding);
+      logger().debug("sending websocket message", {
+        encoding: state.encoding,
+        dataType: typeof serialized,
+        isUint8Array: serialized instanceof Uint8Array,
+        isArrayBuffer: serialized instanceof ArrayBuffer,
+        dataLength: serialized.byteLength || serialized.length
+      });
+      if (serialized instanceof Uint8Array) {
+        const buffer = serialized.buffer.slice(
+          serialized.byteOffset,
+          serialized.byteOffset + serialized.byteLength
+        );
+        if (buffer instanceof SharedArrayBuffer) {
+          const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+          new Uint8Array(arrayBuffer).set(new Uint8Array(buffer));
+          logger().debug("converted SharedArrayBuffer to ArrayBuffer", {
+            byteLength: arrayBuffer.byteLength
+          });
+          ws.send(arrayBuffer);
+        } else {
+          logger().debug("sending ArrayBuffer", {
+            byteLength: buffer.byteLength
+          });
+          ws.send(buffer);
+        }
+      } else {
+        logger().debug("sending string data", {
+          length: serialized.length
+        });
+        ws.send(serialized);
+      }
+    },
+    disconnect: async (actor2, conn, _state, reason) => {
+      const ws = globalState.websockets.get(conn.id);
+      if (!ws) {
+        logger().warn("missing ws for disconnect", {
+          actorId: actor2.id,
+          connId: conn.id,
+          totalCount: globalState.websockets.size
+        });
+        return;
+      }
+      const raw = ws.raw;
+      if (!raw) {
+        logger().warn("ws.raw does not exist");
+        return;
+      }
+      const { promise, resolve } = Promise.withResolvers();
+      raw.addEventListener("close", () => resolve());
+      ws.close(1e3, reason);
+      await promise;
+    },
+    getConnectionReadyState: (_actor, conn) => {
+      const ws = globalState.websockets.get(conn.id);
+      if (!ws) {
+        logger().warn("missing ws for getConnectionReadyState", {
+          connId: conn.id
+        });
+        return void 0;
+      }
+      const raw = ws.raw;
+      return raw.readyState;
+    }
+  };
+}
+function createGenericSseDriver(globalState) {
+  return {
+    sendMessage: (_actor, conn, state, message) => {
+      const stream = globalState.sseStreams.get(conn.id);
+      if (!stream) {
+        logger().warn("missing sse stream for sendMessage", {
+          connId: conn.id
+        });
+        return;
+      }
+      stream.writeSSE({
+        data: encodeDataToString(message.serialize(state.encoding))
+      });
+    },
+    disconnect: async (_actor, conn, _state, _reason) => {
+      const stream = globalState.sseStreams.get(conn.id);
+      if (!stream) {
+        logger().warn("missing sse stream for disconnect", { connId: conn.id });
+        return;
+      }
+      stream.close();
+    },
+    getConnectionReadyState: (_actor, conn) => {
+      const stream = globalState.sseStreams.get(conn.id);
+      if (!stream) {
+        logger().warn("missing sse stream for getConnectionReadyState", {
+          connId: conn.id
+        });
+        return void 0;
+      }
+      if (stream.aborted || stream.closed) {
+        return 3 /* CLOSED */;
+      }
+      return 1 /* OPEN */;
+    }
+  };
+}
+function createGenericHttpDriver() {
+  return {
+    getConnectionReadyState(_actor, _conn) {
+      return 1 /* OPEN */;
+    },
+    disconnect: async () => {
+    }
+  };
+}
+
+// src/actor/router.ts
+import { Hono as Hono2 } from "hono";
+import invariant3 from "invariant";
+
+// src/common/router.ts
+import * as cbor6 from "cbor-x";
+function logger3() {
+  return getLogger("router");
+}
+function loggerMiddleware(logger10) {
+  return async (c, next) => {
+    const method = c.req.method;
+    const path3 = c.req.path;
+    const startTime = Date.now();
+    await next();
+    const duration = Date.now() - startTime;
+    logger10.debug("http request", {
+      method,
+      path: path3,
+      status: c.res.status,
+      dt: `${duration}ms`,
+      reqSize: c.req.header("content-length"),
+      resSize: c.res.headers.get("content-length"),
+      userAgent: c.req.header("user-agent")
+    });
+  };
+}
+function handleRouteNotFound(c) {
+  return c.text("Not Found (RivetKit)", 404);
+}
+function handleRouteError(opts, error, c) {
+  const exposeInternalError = opts.enableExposeInternalError && getRequestExposeInternalError(c.req.raw);
+  const { statusCode, code, message, metadata } = deconstructError(
+    error,
+    logger3(),
+    {
+      method: c.req.method,
+      path: c.req.path
+    },
+    exposeInternalError
+  );
+  let encoding;
+  try {
+    encoding = getRequestEncoding(c.req);
+  } catch (err) {
+    logger3().debug("failed to extract encoding", {
+      error: stringifyError(err)
+    });
+    encoding = "json";
+  }
+  const output = serializeWithEncoding(
+    encoding,
+    {
+      code,
+      message,
+      metadata: bufferToArrayBuffer(cbor6.encode(metadata))
+    },
+    HTTP_RESPONSE_ERROR_VERSIONED
+  );
+  return c.body(output, { status: statusCode });
+}
+
+// src/inspector/utils.ts
+import crypto2 from "node:crypto";
+import { createMiddleware } from "hono/factory";
+
+// src/inspector/log.ts
+function inspectorLogger() {
+  return getLogger("inspector");
+}
+
+// src/inspector/utils.ts
+function compareSecrets(providedSecret, validSecret) {
+  if (providedSecret.length !== validSecret.length) {
+    return false;
+  }
+  const encoder = new TextEncoder();
+  const a = encoder.encode(providedSecret);
+  const b = encoder.encode(validSecret);
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  if (!crypto2.timingSafeEqual(a, b)) {
+    return false;
+  }
+  return true;
+}
+var secureInspector = (runConfig) => createMiddleware(async (c, next) => {
+  if (!runConfig.inspector.enabled) {
+    return c.text("Inspector is not enabled", 503);
+  }
+  const userToken = c.req.header("Authorization")?.replace("Bearer ", "");
+  if (!userToken) {
+    return c.text("Unauthorized", 401);
+  }
+  const inspectorToken = runConfig.inspector.token?.();
+  if (!inspectorToken) {
+    return c.text("Unauthorized", 401);
+  }
+  const isValid = compareSecrets(userToken, inspectorToken);
+  if (!isValid) {
+    return c.text("Unauthorized", 401);
+  }
+  await next();
+});
+function getInspectorUrl(runConfig) {
+  if (!runConfig?.inspector?.enabled) {
+    return "disabled";
+  }
+  const accessToken = runConfig?.inspector?.token?.();
+  if (!accessToken) {
+    inspectorLogger().warn(
+      "Inspector Token is not set, but Inspector is enabled. Please set it in the run configuration `inspector.token` or via `RIVETKIT_INSPECTOR_TOKEN` environment variable. Inspector will not be accessible."
+    );
+    return "disabled";
+  }
+  const url = new URL("https://studio.rivet.gg");
+  url.searchParams.set("t", accessToken);
+  if (runConfig?.inspector?.defaultEndpoint) {
+    url.searchParams.set("u", runConfig.inspector.defaultEndpoint);
+  }
+  return url.href;
+}
+
+// src/actor/router.ts
+var PATH_CONNECT_WEBSOCKET = "/connect/websocket";
+var PATH_RAW_WEBSOCKET_PREFIX = "/raw/websocket/";
+function createActorRouter(runConfig, actorDriver) {
+  const router = new Hono2({ strict: false });
+  router.use("*", loggerMiddleware(logger()));
+  router.get("/", (c) => {
+    return c.text(
+      "This is an RivetKit actor.\n\nLearn more at https://rivetkit.org"
+    );
+  });
+  router.get("/health", (c) => {
+    return c.text("ok");
+  });
+  router.get(PATH_CONNECT_WEBSOCKET, async (c) => {
+    const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+    if (upgradeWebSocket) {
+      return upgradeWebSocket(async (c2) => {
+        const encodingRaw = c2.req.header(HEADER_ENCODING);
+        const connParamsRaw = c2.req.header(HEADER_CONN_PARAMS);
+        const authDataRaw = c2.req.header(HEADER_AUTH_DATA);
+        const encoding = EncodingSchema.parse(encodingRaw);
+        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+        const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
+        return await handleWebSocketConnect(
+          c2.req.raw,
+          runConfig,
+          actorDriver,
+          c2.env.actorId,
+          encoding,
+          connParams,
+          authData
+        );
+      })(c, noopNext());
+    } else {
+      return c.text(
+        "WebSockets are not enabled for this driver. Use SSE instead.",
+        400
+      );
+    }
+  });
+  router.get("/connect/sse", async (c) => {
+    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+    let authData;
+    if (authDataRaw) {
+      authData = JSON.parse(authDataRaw);
+    }
+    return handleSseConnect(c, runConfig, actorDriver, c.env.actorId, authData);
+  });
+  router.post("/action/:action", async (c) => {
+    const actionName = c.req.param("action");
+    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+    let authData;
+    if (authDataRaw) {
+      authData = JSON.parse(authDataRaw);
+    }
+    return handleAction(
+      c,
+      runConfig,
+      actorDriver,
+      actionName,
+      c.env.actorId,
+      authData
+    );
+  });
+  router.post("/connections/message", async (c) => {
+    const connId = c.req.header(HEADER_CONN_ID);
+    const connToken = c.req.header(HEADER_CONN_TOKEN);
+    if (!connId || !connToken) {
+      throw new Error("Missing required parameters");
+    }
+    return handleConnectionMessage(
+      c,
+      runConfig,
+      actorDriver,
+      connId,
+      connToken,
+      c.env.actorId
+    );
+  });
+  router.all("/raw/http/*", async (c) => {
+    const authDataRaw = c.req.header(HEADER_AUTH_DATA);
+    let authData;
+    if (authDataRaw) {
+      authData = JSON.parse(authDataRaw);
+    }
+    const actor2 = await actorDriver.loadActor(c.env.actorId);
+    const url = new URL(c.req.url);
+    const originalPath = url.pathname.replace(/^\/raw\/http/, "") || "/";
+    const correctedUrl = new URL(originalPath + url.search, url.origin);
+    const correctedRequest = new Request(correctedUrl, {
+      method: c.req.method,
+      headers: c.req.raw.headers,
+      body: c.req.raw.body
+    });
+    logger().debug("rewriting http url", {
+      from: c.req.url,
+      to: correctedRequest.url
+    });
+    const response = await actor2.handleFetch(correctedRequest, {
+      auth: authData
+    });
+    if (!response) {
+      throw new InternalError("handleFetch returned void unexpectedly");
+    }
+    return response;
+  });
+  router.get(`${PATH_RAW_WEBSOCKET_PREFIX}*`, async (c) => {
+    const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+    if (upgradeWebSocket) {
+      return upgradeWebSocket(async (c2) => {
+        const encodingRaw = c2.req.header(HEADER_ENCODING);
+        const connParamsRaw = c2.req.header(HEADER_CONN_PARAMS);
+        const authDataRaw = c2.req.header(HEADER_AUTH_DATA);
+        const encoding = EncodingSchema.parse(encodingRaw);
+        const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+        const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
+        const url = new URL(c2.req.url);
+        const pathWithQuery = c2.req.path + url.search;
+        logger().debug("actor router raw websocket", {
+          path: c2.req.path,
+          url: c2.req.url,
+          search: url.search,
+          pathWithQuery
+        });
+        return await handleRawWebSocketHandler(
+          c2.req.raw,
+          pathWithQuery,
+          actorDriver,
+          c2.env.actorId,
+          authData
+        );
+      })(c, noopNext());
+    } else {
+      return c.text(
+        "WebSockets are not enabled for this driver. Use SSE instead.",
+        400
+      );
+    }
+  });
+  if (runConfig.inspector.enabled) {
+    router.route(
+      "/inspect",
+      new Hono2().use(secureInspector(runConfig), async (c, next) => {
+        const inspector = (await actorDriver.loadActor(c.env.actorId)).inspector;
+        invariant3(inspector, "inspector not supported on this platform");
+        c.set("inspector", inspector);
+        await next();
+      }).route("/", createActorInspectorRouter())
+    );
+  }
+  router.notFound(handleRouteNotFound);
+  router.onError(
+    handleRouteError.bind(void 0, {
+      // All headers to this endpoint are considered secure, so we can enable the expose internal error header for requests from the internal client
+      enableExposeInternalError: true
+    })
+  );
+  return router;
+}
+
+// src/actor/mod.ts
+function actor(input) {
+  const config4 = ActorConfigSchema.parse(input);
+  return new ActorDefinition(config4);
+}
+
+// src/client/actor-conn.ts
+import * as cbor8 from "cbor-x";
+import invariant5 from "invariant";
+import pRetry from "p-retry";
+
+// src/client/errors.ts
+var ActorClientError = class extends Error {
+};
+var InternalError2 = class extends ActorClientError {
+};
+var ActorError2 = class extends ActorClientError {
+  constructor(code, message, metadata) {
+    super(message);
+    this.code = code;
+    this.metadata = metadata;
+  }
+  __type = "ActorError";
+};
+var HttpRequestError = class extends ActorClientError {
+  constructor(message, opts) {
+    super(`HTTP request error: ${message}`, { cause: opts?.cause });
+  }
+};
+var ActorConnDisposed = class extends ActorClientError {
+  constructor() {
+    super("Attempting to interact with a disposed actor connection.");
+  }
+};
+
+// src/client/log.ts
+var LOGGER_NAME2 = "actor-client";
+function logger4() {
+  return getLogger(LOGGER_NAME2);
+}
+
+// src/client/utils.ts
+import * as cbor7 from "cbor-x";
+import invariant4 from "invariant";
+function messageLength(message) {
+  if (message instanceof Blob) {
+    return message.size;
+  }
+  if (message instanceof ArrayBuffer) {
+    return message.byteLength;
+  }
+  if (message instanceof Uint8Array) {
+    return message.byteLength;
+  }
+  if (typeof message === "string") {
+    return message.length;
+  }
+  assertUnreachable(message);
+}
+async function sendHttpRequest(opts) {
+  logger4().debug("sending http request", {
+    url: opts.url,
+    encoding: opts.encoding
+  });
+  let contentType;
+  let bodyData;
+  if (opts.method === "POST" || opts.method === "PUT") {
+    invariant4(opts.body !== void 0, "missing body");
+    contentType = contentTypeForEncoding(opts.encoding);
+    bodyData = serializeWithEncoding(
+      opts.encoding,
+      opts.body,
+      opts.requestVersionedDataHandler
+    );
+  }
+  let response;
+  try {
+    response = await (opts.customFetch ?? fetch)(
+      new Request(opts.url, {
+        method: opts.method,
+        headers: {
+          ...opts.headers,
+          ...contentType ? {
+            "Content-Type": contentType
+          } : {},
+          "User-Agent": httpUserAgent()
+        },
+        body: bodyData,
+        credentials: "include",
+        signal: opts.signal
+      })
+    );
+  } catch (error) {
+    throw new HttpRequestError(`Request failed: ${error}`, {
+      cause: error
+    });
+  }
+  if (!response.ok) {
+    const bufferResponse = await response.arrayBuffer();
+    let responseData;
+    try {
+      responseData = deserializeWithEncoding(
+        opts.encoding,
+        new Uint8Array(bufferResponse),
+        HTTP_RESPONSE_ERROR_VERSIONED
+      );
+    } catch (error) {
+      const textResponse = new TextDecoder("utf-8", { fatal: false }).decode(
+        bufferResponse
+      );
+      throw new HttpRequestError(
+        `${response.statusText} (${response.status}):
+${textResponse}`
+      );
+    }
+    throw new ActorError2(
+      responseData.code,
+      responseData.message,
+      responseData.metadata ? cbor7.decode(new Uint8Array(responseData.metadata)) : void 0
+    );
+  }
+  if (opts.skipParseResponse) {
+    return void 0;
+  }
+  try {
+    const buffer = new Uint8Array(await response.arrayBuffer());
+    return deserializeWithEncoding(
+      opts.encoding,
+      buffer,
+      opts.responseVersionedDataHandler
+    );
+  } catch (error) {
+    throw new HttpRequestError(`Failed to parse response: ${error}`, {
+      cause: error
+    });
+  }
+}
+
+// src/client/actor-conn.ts
+var CONNECT_SYMBOL = Symbol("connect");
+var ActorConnRaw = class {
+  #disposed = false;
+  /* Will be aborted on dispose. */
+  #abortController = new AbortController();
+  /** If attempting to connect. Helpful for knowing if in a retry loop when reconnecting. */
+  #connecting = false;
+  // These will only be set on SSE driver
+  #actorId;
+  #connectionId;
+  #connectionToken;
+  #transport;
+  #messageQueue = [];
+  #actionsInFlight = /* @__PURE__ */ new Map();
+  // biome-ignore lint/suspicious/noExplicitAny: Unknown subscription type
+  #eventSubscriptions = /* @__PURE__ */ new Map();
+  #errorHandlers = /* @__PURE__ */ new Set();
+  #actionIdCounter = 0;
+  /**
+   * Interval that keeps the NodeJS process alive if this is the only thing running.
+   *
+   * See ttps://github.com/nodejs/node/issues/22088
+   */
+  #keepNodeAliveInterval;
+  /** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */
+  #onOpenPromise;
+  #client;
+  #driver;
+  #params;
+  #encodingKind;
+  #actorQuery;
+  // TODO: ws message queue
+  /**
+   * Do not call this directly.
+   *
+   * Creates an instance of ActorConnRaw.
+   *
+   * @protected
+   */
+  constructor(client, driver, params, encodingKind, actorQuery) {
+    this.#client = client;
+    this.#driver = driver;
+    this.#params = params;
+    this.#encodingKind = encodingKind;
+    this.#actorQuery = actorQuery;
+    this.#keepNodeAliveInterval = setInterval(() => 6e4);
+  }
+  /**
+   * Call a raw action connection. See {@link ActorConn} for type-safe action calls.
+   *
+   * @see {@link ActorConn}
+   * @template Args - The type of arguments to pass to the action function.
+   * @template Response - The type of the response returned by the action function.
+   * @param {string} name - The name of the action function to call.
+   * @param {...Args} args - The arguments to pass to the action function.
+   * @returns {Promise<Response>} - A promise that resolves to the response of the action function.
+   */
+  async action(opts) {
+    logger4().debug("action", { name: opts.name, args: opts.args });
+    const actionId = this.#actionIdCounter;
+    this.#actionIdCounter += 1;
+    const { promise, resolve, reject } = Promise.withResolvers();
+    this.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });
+    this.#sendMessage({
+      body: {
+        tag: "ActionRequest",
+        val: {
+          id: BigInt(actionId),
+          name: opts.name,
+          args: bufferToArrayBuffer(cbor8.encode(opts.args))
+        }
+      }
+    });
+    const { id: responseId, output } = await promise;
+    if (responseId !== BigInt(actionId))
+      throw new Error(
+        `Request ID ${actionId} does not match response ID ${responseId}`
+      );
+    return cbor8.decode(new Uint8Array(output));
+  }
+  /**
+  	 * Do not call this directly.
+  enc
+  	 * Establishes a connection to the server using the specified endpoint & encoding & driver.
+  	 *
+  	 * @protected
+  	 */
+  [CONNECT_SYMBOL]() {
+    this.#connectWithRetry();
+  }
+  async #connectWithRetry() {
+    this.#connecting = true;
+    try {
+      await pRetry(this.#connectAndWait.bind(this), {
+        forever: true,
+        minTimeout: 250,
+        maxTimeout: 3e4,
+        onFailedAttempt: (error) => {
+          logger4().warn("failed to reconnect", {
+            attempt: error.attemptNumber,
+            error: stringifyError(error)
+          });
+        },
+        // Cancel retry if aborted
+        signal: this.#abortController.signal
+      });
+    } catch (err) {
+      if (err.name === "AbortError") {
+        logger4().info("connection retry aborted");
+        return;
+      } else {
+        throw err;
+      }
+    }
+    this.#connecting = false;
+  }
+  async #connectAndWait() {
+    try {
+      if (this.#onOpenPromise)
+        throw new Error("#onOpenPromise already defined");
+      this.#onOpenPromise = Promise.withResolvers();
+      if (this.#client[TRANSPORT_SYMBOL] === "websocket") {
+        await this.#connectWebSocket();
+      } else if (this.#client[TRANSPORT_SYMBOL] === "sse") {
+        await this.#connectSse();
+      } else {
+        assertUnreachable(this.#client[TRANSPORT_SYMBOL]);
+      }
+      await this.#onOpenPromise.promise;
+    } finally {
+      this.#onOpenPromise = void 0;
+    }
+  }
+  async #connectWebSocket({ signal } = {}) {
+    const ws = await this.#driver.connectWebSocket(
+      void 0,
+      this.#actorQuery,
+      this.#encodingKind,
+      this.#params,
+      signal ? { signal } : void 0
+    );
+    this.#transport = { websocket: ws };
+    ws.addEventListener("open", () => {
+      logger4().debug("websocket open");
+    });
+    ws.addEventListener("message", async (ev) => {
+      this.#handleOnMessage(ev.data);
+    });
+    ws.addEventListener("close", (ev) => {
+      this.#handleOnClose(ev);
+    });
+    ws.addEventListener("error", (_ev) => {
+      this.#handleOnError();
+    });
+  }
+  async #connectSse({ signal } = {}) {
+    const eventSource = await this.#driver.connectSse(
+      void 0,
+      this.#actorQuery,
+      this.#encodingKind,
+      this.#params,
+      signal ? { signal } : void 0
+    );
+    this.#transport = { sse: eventSource };
+    eventSource.onopen = () => {
+      logger4().debug("eventsource open");
+    };
+    eventSource.onmessage = (ev) => {
+      this.#handleOnMessage(ev.data);
+    };
+    eventSource.onerror = (_ev) => {
+      if (eventSource.readyState === eventSource.CLOSED) {
+        this.#handleOnClose(new Event("error"));
+      } else {
+        this.#handleOnError();
+      }
+    };
+  }
+  /** Called by the onopen event from drivers. */
+  #handleOnOpen() {
+    logger4().debug("socket open", {
+      messageQueueLength: this.#messageQueue.length
+    });
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.resolve(void 0);
+    } else {
+      logger4().warn("#onOpenPromise is undefined");
+    }
+    for (const eventName of this.#eventSubscriptions.keys()) {
+      this.#sendSubscription(eventName, true);
+    }
+    const queue = this.#messageQueue;
+    this.#messageQueue = [];
+    for (const msg of queue) {
+      this.#sendMessage(msg);
+    }
+  }
+  /** Called by the onmessage event from drivers. */
+  async #handleOnMessage(data) {
+    logger4().trace("received message", {
+      dataType: typeof data,
+      isBlob: data instanceof Blob,
+      isArrayBuffer: data instanceof ArrayBuffer
+    });
+    const response = await this.#parseMessage(data);
+    logger4().trace(
+      "parsed message",
+      getEnvUniversal("_RIVETKIT_LOG_MESSAGE") ? {
+        message: jsonStringifyCompat(response).substring(0, 100) + "..."
+      } : {}
+    );
+    if (response.body.tag === "Init") {
+      this.#actorId = response.body.val.actorId;
+      this.#connectionId = response.body.val.connectionId;
+      this.#connectionToken = response.body.val.connectionToken;
+      logger4().trace("received init message", {
+        actorId: this.#actorId,
+        connectionId: this.#connectionId
+      });
+      this.#handleOnOpen();
+    } else if (response.body.tag === "Error") {
+      const { code, message, metadata, actionId } = response.body.val;
+      if (actionId) {
+        const inFlight = this.#takeActionInFlight(Number(actionId));
+        logger4().warn("action error", {
+          actionId,
+          actionName: inFlight?.name,
+          code,
+          message,
+          metadata
+        });
+        inFlight.reject(new ActorError2(code, message, metadata));
+      } else {
+        logger4().warn("connection error", {
+          code,
+          message,
+          metadata
+        });
+        const actorError = new ActorError2(code, message, metadata);
+        if (this.#onOpenPromise) {
+          this.#onOpenPromise.reject(actorError);
+        }
+        for (const [id, inFlight] of this.#actionsInFlight.entries()) {
+          inFlight.reject(actorError);
+          this.#actionsInFlight.delete(id);
+        }
+        this.#dispatchActorError(actorError);
+      }
+    } else if (response.body.tag === "ActionResponse") {
+      const { id: actionId } = response.body.val;
+      logger4().trace("received action response", {
+        actionId
+      });
+      const inFlight = this.#takeActionInFlight(Number(actionId));
+      logger4().trace("resolving action promise", {
+        actionId,
+        actionName: inFlight?.name
+      });
+      inFlight.resolve(response.body.val);
+    } else if (response.body.tag === "Event") {
+      logger4().trace("received event", { name: response.body.val.name });
+      this.#dispatchEvent(response.body.val);
+    } else {
+      assertUnreachable(response.body);
+    }
+  }
+  /** Called by the onclose event from drivers. */
+  #handleOnClose(event) {
+    if (this.#onOpenPromise) {
+      this.#onOpenPromise.reject(new Error("Closed"));
+    }
+    const closeEvent = event;
+    if (closeEvent.wasClean) {
+      logger4().info("socket closed", {
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean
+      });
+    } else {
+      logger4().warn("socket closed", {
+        code: closeEvent.code,
+        reason: closeEvent.reason,
+        wasClean: closeEvent.wasClean
+      });
+    }
+    this.#transport = void 0;
+    if (!this.#disposed && !this.#connecting) {
+      this.#connectWithRetry();
+    }
+  }
+  /** Called by the onerror event from drivers. */
+  #handleOnError() {
+    if (this.#disposed) return;
+    logger4().warn("socket error");
+  }
+  #takeActionInFlight(id) {
+    const inFlight = this.#actionsInFlight.get(id);
+    if (!inFlight) {
+      throw new InternalError2(`No in flight response for ${id}`);
+    }
+    this.#actionsInFlight.delete(id);
+    return inFlight;
+  }
+  #dispatchEvent(event) {
+    const { name, args: argsRaw } = event;
+    const args = cbor8.decode(new Uint8Array(argsRaw));
+    const listeners = this.#eventSubscriptions.get(name);
+    if (!listeners) return;
+    for (const listener of [...listeners]) {
+      listener.callback(...args);
+      if (listener.once) {
+        listeners.delete(listener);
+      }
+    }
+    if (listeners.size === 0) {
+      this.#eventSubscriptions.delete(name);
+    }
+  }
+  #dispatchActorError(error) {
+    for (const handler of [...this.#errorHandlers]) {
+      try {
+        handler(error);
+      } catch (err) {
+        logger4().error("Error in connection error handler", {
+          error: stringifyError(err)
+        });
+      }
+    }
+  }
+  #addEventSubscription(eventName, callback, once) {
+    const listener = {
+      callback,
+      once
+    };
+    let subscriptionSet = this.#eventSubscriptions.get(eventName);
+    if (subscriptionSet === void 0) {
+      subscriptionSet = /* @__PURE__ */ new Set();
+      this.#eventSubscriptions.set(eventName, subscriptionSet);
+      this.#sendSubscription(eventName, true);
+    }
+    subscriptionSet.add(listener);
+    return () => {
+      const listeners = this.#eventSubscriptions.get(eventName);
+      if (listeners) {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          this.#eventSubscriptions.delete(eventName);
+          this.#sendSubscription(eventName, false);
+        }
+      }
+    };
+  }
+  /**
+   * Subscribes to an event that will happen repeatedly.
+   *
+   * @template Args - The type of arguments the event callback will receive.
+   * @param {string} eventName - The name of the event to subscribe to.
+   * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+   * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+   * @see {@link https://rivet.gg/docs/events|Events Documentation}
+   */
+  on(eventName, callback) {
+    return this.#addEventSubscription(eventName, callback, false);
+  }
+  /**
+   * Subscribes to an event that will be triggered only once.
+   *
+   * @template Args - The type of arguments the event callback will receive.
+   * @param {string} eventName - The name of the event to subscribe to.
+   * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.
+   * @returns {EventUnsubscribe} - A function to unsubscribe from the event.
+   * @see {@link https://rivet.gg/docs/events|Events Documentation}
+   */
+  once(eventName, callback) {
+    return this.#addEventSubscription(eventName, callback, true);
+  }
+  /**
+   * Subscribes to connection errors.
+   *
+   * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.
+   * @returns {() => void} - A function to unsubscribe from the error handler.
+   */
+  onError(callback) {
+    this.#errorHandlers.add(callback);
+    return () => {
+      this.#errorHandlers.delete(callback);
+    };
+  }
+  #sendMessage(message, opts) {
+    if (this.#disposed) {
+      throw new ActorConnDisposed();
+    }
+    let queueMessage = false;
+    if (!this.#transport) {
+      queueMessage = true;
+    } else if ("websocket" in this.#transport) {
+      if (this.#transport.websocket.readyState === 1) {
+        try {
+          const messageSerialized = serializeWithEncoding(
+            this.#encodingKind,
+            message,
+            TO_SERVER_VERSIONED
+          );
+          this.#transport.websocket.send(messageSerialized);
+          logger4().trace("sent websocket message", {
+            len: messageLength(messageSerialized)
+          });
+        } catch (error) {
+          logger4().warn("failed to send message, added to queue", {
+            error
+          });
+          queueMessage = true;
+        }
+      } else {
+        queueMessage = true;
+      }
+    } else if ("sse" in this.#transport) {
+      if (this.#transport.sse.readyState === 1) {
+        this.#sendHttpMessage(message, opts);
+      } else {
+        queueMessage = true;
+      }
+    } else {
+      assertUnreachable(this.#transport);
+    }
+    if (!opts?.ephemeral && queueMessage) {
+      this.#messageQueue.push(message);
+      logger4().debug("queued connection message");
+    }
+  }
+  async #sendHttpMessage(message, opts) {
+    try {
+      if (!this.#actorId || !this.#connectionId || !this.#connectionToken)
+        throw new InternalError2("Missing connection ID or token.");
+      logger4().trace(
+        "sent http message",
+        getEnvUniversal("_RIVETKIT_LOG_MESSAGE") ? {
+          message: jsonStringifyCompat(message).substring(0, 100) + "..."
+        } : {}
+      );
+      await this.#driver.sendHttpMessage(
+        void 0,
+        this.#actorId,
+        this.#encodingKind,
+        this.#connectionId,
+        this.#connectionToken,
+        message,
+        opts?.signal ? { signal: opts.signal } : void 0
+      );
+    } catch (error) {
+      logger4().warn("failed to send message, added to queue", {
+        error
+      });
+      if (!opts?.ephemeral) {
+        this.#messageQueue.unshift(message);
+      }
+    }
+  }
+  async #parseMessage(data) {
+    invariant5(this.#transport, "transport must be defined");
+    if (encodingIsBinary(this.#encodingKind) && "sse" in this.#transport) {
+      if (typeof data === "string") {
+        const binaryString = atob(data);
+        data = new Uint8Array(
+          [...binaryString].map((char) => char.charCodeAt(0))
+        );
+      } else {
+        throw new InternalError2(
+          `Expected data to be a string for SSE, got ${data}.`
+        );
+      }
+    }
+    const buffer = await inputDataToBuffer(data);
+    return deserializeWithEncoding(
+      this.#encodingKind,
+      buffer,
+      TO_CLIENT_VERSIONED
+    );
+  }
+  /**
+   * Disconnects from the actor.
+   *
+   * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      logger4().warn("connection already disconnected");
+      return;
+    }
+    this.#disposed = true;
+    logger4().debug("disposing actor conn");
+    clearInterval(this.#keepNodeAliveInterval);
+    this.#abortController.abort();
+    this.#client[ACTOR_CONNS_SYMBOL].delete(this);
+    if (!this.#transport) {
+    } else if ("websocket" in this.#transport) {
+      const ws = this.#transport.websocket;
+      if (ws.readyState === 2 || ws.readyState === 3) {
+        logger4().debug("ws already closed or closing");
+      } else {
+        const { promise, resolve } = Promise.withResolvers();
+        ws.addEventListener("close", () => {
+          logger4().debug("ws closed");
+          resolve(void 0);
+        });
+        ws.close();
+        await promise;
+      }
+    } else if ("sse" in this.#transport) {
+      this.#transport.sse.close();
+    } else {
+      assertUnreachable(this.#transport);
+    }
+    this.#transport = void 0;
+  }
+  #sendSubscription(eventName, subscribe) {
+    this.#sendMessage(
+      {
+        body: {
+          tag: "SubscriptionRequest",
+          val: {
+            eventName,
+            subscribe
+          }
+        }
+      },
+      { ephemeral: true }
+    );
+  }
+};
+
+// src/client/actor-handle.ts
+import invariant6 from "invariant";
+
+// src/client/raw-utils.ts
+async function rawHttpFetch(driver, actorQuery, params, input, init) {
+  let path3;
+  let mergedInit = init || {};
+  if (typeof input === "string") {
+    path3 = input;
+  } else if (input instanceof URL) {
+    path3 = input.pathname + input.search;
+  } else if (input instanceof Request) {
+    const url = new URL(input.url);
+    path3 = url.pathname + url.search;
+    const requestHeaders = new Headers(input.headers);
+    const initHeaders = new Headers(init?.headers || {});
+    const mergedHeaders = new Headers(requestHeaders);
+    for (const [key, value] of initHeaders) {
+      mergedHeaders.set(key, value);
+    }
+    mergedInit = {
+      method: input.method,
+      body: input.body,
+      mode: input.mode,
+      credentials: input.credentials,
+      redirect: input.redirect,
+      referrer: input.referrer,
+      referrerPolicy: input.referrerPolicy,
+      integrity: input.integrity,
+      keepalive: input.keepalive,
+      signal: input.signal,
+      ...mergedInit,
+      // init overrides Request properties
+      headers: mergedHeaders
+      // headers must be set after spread to ensure proper merge
+    };
+    if (mergedInit.body) {
+      mergedInit.duplex = "half";
+    }
+  } else {
+    throw new TypeError("Invalid input type for fetch");
+  }
+  return await driver.rawHttpRequest(
+    void 0,
+    actorQuery,
+    // Force JSON so it's readable by the user
+    "json",
+    params,
+    path3,
+    mergedInit,
+    void 0
+  );
+}
+async function rawWebSocket(driver, actorQuery, params, path3, protocols) {
+  return await driver.rawWebSocket(
+    void 0,
+    actorQuery,
+    // Force JSON so it's readable by the user
+    "json",
+    params,
+    path3 || "",
+    protocols,
+    void 0
+  );
+}
+
+// src/client/actor-handle.ts
+var ActorHandleRaw = class {
+  #client;
+  #driver;
+  #encodingKind;
+  #actorQuery;
+  #params;
+  /**
+   * Do not call this directly.
+   *
+   * Creates an instance of ActorHandleRaw.
+   *
+   * @protected
+   */
+  constructor(client, driver, params, encodingKind, actorQuery) {
+    this.#client = client;
+    this.#driver = driver;
+    this.#encodingKind = encodingKind;
+    this.#actorQuery = actorQuery;
+    this.#params = params;
+  }
+  /**
+   * Call a raw action. This method sends an HTTP request to invoke the named action.
+   *
+   * @see {@link ActorHandle}
+   * @template Args - The type of arguments to pass to the action function.
+   * @template Response - The type of the response returned by the action function.
+   */
+  async action(opts) {
+    return await this.#driver.action(
+      void 0,
+      this.#actorQuery,
+      this.#encodingKind,
+      this.#params,
+      opts.name,
+      opts.args,
+      { signal: opts.signal }
+    );
+  }
+  /**
+   * Establishes a persistent connection to the actor.
+   *
+   * @template AD The actor class that this connection is for.
+   * @returns {ActorConn<AD>} A connection to the actor.
+   */
+  connect() {
+    logger4().debug("establishing connection from handle", {
+      query: this.#actorQuery
+    });
+    const conn = new ActorConnRaw(
+      this.#client,
+      this.#driver,
+      this.#params,
+      this.#encodingKind,
+      this.#actorQuery
+    );
+    return this.#client[CREATE_ACTOR_CONN_PROXY](
+      conn
+    );
+  }
+  /**
+   * Makes a raw HTTP request to the actor.
+   *
+   * @param input - The URL, path, or Request object
+   * @param init - Standard fetch RequestInit options
+   * @returns Promise<Response> - The raw HTTP response
+   */
+  async fetch(input, init) {
+    return rawHttpFetch(
+      this.#driver,
+      this.#actorQuery,
+      this.#params,
+      input,
+      init
+    );
+  }
+  /**
+   * Creates a raw WebSocket connection to the actor.
+   *
+   * @param path - The path for the WebSocket connection (e.g., "stream")
+   * @param protocols - Optional WebSocket subprotocols
+   * @returns WebSocket - A raw WebSocket connection
+   */
+  async websocket(path3, protocols) {
+    return rawWebSocket(
+      this.#driver,
+      this.#actorQuery,
+      this.#params,
+      path3,
+      protocols
+    );
+  }
+  /**
+   * Resolves the actor to get its unique actor ID
+   *
+   * @returns {Promise<string>} - A promise that resolves to the actor's ID
+   */
+  async resolve({ signal } = {}) {
+    if ("getForKey" in this.#actorQuery || "getOrCreateForKey" in this.#actorQuery) {
+      let name;
+      if ("getForKey" in this.#actorQuery) {
+        name = this.#actorQuery.getForKey.name;
+      } else if ("getOrCreateForKey" in this.#actorQuery) {
+        name = this.#actorQuery.getOrCreateForKey.name;
+      } else {
+        assertUnreachable2(this.#actorQuery);
+      }
+      const actorId = await this.#driver.resolveActorId(
+        void 0,
+        this.#actorQuery,
+        this.#encodingKind,
+        this.#params,
+        signal ? { signal } : void 0
+      );
+      this.#actorQuery = { getForId: { actorId, name } };
+      return actorId;
+    } else if ("getForId" in this.#actorQuery) {
+      return this.#actorQuery.getForId.actorId;
+    } else if ("create" in this.#actorQuery) {
+      invariant6(false, "actorQuery cannot be create");
+    } else {
+      assertUnreachable2(this.#actorQuery);
+    }
+  }
+};
+
+// src/client/client.ts
+var ACTOR_CONNS_SYMBOL = Symbol("actorConns");
+var CREATE_ACTOR_CONN_PROXY = Symbol("createActorConnProxy");
+var TRANSPORT_SYMBOL = Symbol("transport");
+var ClientRaw = class {
+  #disposed = false;
+  [ACTOR_CONNS_SYMBOL] = /* @__PURE__ */ new Set();
+  #driver;
+  #encodingKind;
+  [TRANSPORT_SYMBOL];
+  /**
+   * Creates an instance of Client.
+   *
+   * @param {string} managerEndpoint - The manager endpoint. See {@link https://rivet.gg/docs/setup|Initial Setup} for instructions on getting the manager endpoint.
+   * @param {ClientOptions} [opts] - Options for configuring the client.
+   * @see {@link https://rivet.gg/docs/setup|Initial Setup}
+   */
+  constructor(driver, opts) {
+    this.#driver = driver;
+    this.#encodingKind = opts?.encoding ?? "bare";
+    this[TRANSPORT_SYMBOL] = opts?.transport ?? "websocket";
+  }
+  /**
+   * Gets a stateless handle to a actor by its ID.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string} actorId - The ID of the actor.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getForId(name, actorId, opts) {
+    logger4().debug("get handle to actor with id", {
+      name,
+      actorId,
+      params: opts?.params
+    });
+    const actorQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(opts?.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetWithIdOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  get(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger4().debug("get handle to actor", {
+      name,
+      key: keyArray,
+      parameters: opts?.params
+    });
+    const actorQuery = {
+      getForKey: {
+        name,
+        key: keyArray
+      }
+    };
+    const handle = this.#createHandle(opts?.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Gets a stateless handle to a actor by its key, creating it if necessary.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {GetOptions} [opts] - Options for getting the actor.
+   * @returns {ActorHandle<AD>} - A handle to the actor.
+   */
+  getOrCreate(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    logger4().debug("get or create handle to actor", {
+      name,
+      key: keyArray,
+      parameters: opts?.params,
+      createInRegion: opts?.createInRegion
+    });
+    const actorQuery = {
+      getOrCreateForKey: {
+        name,
+        key: keyArray,
+        input: opts?.createWithInput,
+        region: opts?.createInRegion
+      }
+    };
+    const handle = this.#createHandle(opts?.params, actorQuery);
+    return createActorProxy(handle);
+  }
+  /**
+   * Creates a new actor with the provided key and returns a stateless handle to it.
+   * Resolves the actor ID and returns a handle with getForId query.
+   *
+   * @template AD The actor class that this handle is for.
+   * @param {string} name - The name of the actor.
+   * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.
+   * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).
+   * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.
+   */
+  async create(name, key, opts) {
+    const keyArray = typeof key === "string" ? [key] : key || [];
+    const createQuery = {
+      create: {
+        ...opts,
+        // Do these last to override `opts`
+        name,
+        key: keyArray
+      }
+    };
+    logger4().debug("create actor handle", {
+      name,
+      key: keyArray,
+      parameters: opts?.params,
+      create: createQuery.create
+    });
+    const actorId = await this.#driver.resolveActorId(
+      void 0,
+      createQuery,
+      this.#encodingKind,
+      opts?.params,
+      opts?.signal ? { signal: opts.signal } : void 0
+    );
+    logger4().debug("created actor with ID", {
+      name,
+      key: keyArray,
+      actorId
+    });
+    const getForIdQuery = {
+      getForId: {
+        name,
+        actorId
+      }
+    };
+    const handle = this.#createHandle(opts?.params, getForIdQuery);
+    const proxy = createActorProxy(handle);
+    return proxy;
+  }
+  #createHandle(params, actorQuery) {
+    return new ActorHandleRaw(
+      this,
+      this.#driver,
+      params,
+      this.#encodingKind,
+      actorQuery
+    );
+  }
+  [CREATE_ACTOR_CONN_PROXY](conn) {
+    this[ACTOR_CONNS_SYMBOL].add(conn);
+    conn[CONNECT_SYMBOL]();
+    return createActorProxy(conn);
+  }
+  /**
+   * Disconnects from all actors.
+   *
+   * @returns {Promise<void>} A promise that resolves when all connections are closed.
+   */
+  async dispose() {
+    if (this.#disposed) {
+      logger4().warn("client already disconnected");
+      return;
+    }
+    this.#disposed = true;
+    logger4().debug("disposing client");
+    const disposePromises = [];
+    for (const conn of this[ACTOR_CONNS_SYMBOL].values()) {
+      disposePromises.push(conn.dispose());
+    }
+    await Promise.all(disposePromises);
+  }
+};
+function createClientWithDriver(driver, opts) {
+  const client = new ClientRaw(driver, opts);
+  return new Proxy(client, {
+    get: (target, prop, receiver) => {
+      if (typeof prop === "symbol" || prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (typeof prop === "string") {
+        return {
+          // Handle methods (stateless action)
+          get: (key, opts2) => {
+            return target.get(
+              prop,
+              key,
+              opts2
+            );
+          },
+          getOrCreate: (key, opts2) => {
+            return target.getOrCreate(prop, key, opts2);
+          },
+          getForId: (actorId, opts2) => {
+            return target.getForId(
+              prop,
+              actorId,
+              opts2
+            );
+          },
+          create: async (key, opts2 = {}) => {
+            return await target.create(prop, key, opts2);
+          }
+        };
+      }
+      return void 0;
+    }
+  });
+}
+function createActorProxy(handle) {
+  const methodCache = /* @__PURE__ */ new Map();
+  return new Proxy(handle, {
+    get(target, prop, receiver) {
+      if (typeof prop === "symbol") {
+        return Reflect.get(target, prop, receiver);
+      }
+      if (prop === "constructor" || prop in target) {
+        const value = Reflect.get(target, prop, receiver);
+        if (typeof value === "function") {
+          return value.bind(target);
+        }
+        return value;
+      }
+      if (typeof prop === "string") {
+        if (prop === "then") return void 0;
+        let method = methodCache.get(prop);
+        if (!method) {
+          method = (...args) => target.action({ name: prop, args });
+          methodCache.set(prop, method);
+        }
+        return method;
+      }
+    },
+    // Support for 'in' operator
+    has(target, prop) {
+      if (typeof prop === "string") {
+        return true;
+      }
+      return Reflect.has(target, prop);
+    },
+    // Support instanceof checks
+    getPrototypeOf(target) {
+      return Reflect.getPrototypeOf(target);
+    },
+    // Prevent property enumeration of non-existent action methods
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    // Support proper property descriptors
+    getOwnPropertyDescriptor(target, prop) {
+      const targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);
+      if (targetDescriptor) {
+        return targetDescriptor;
+      }
+      if (typeof prop === "string") {
+        return {
+          configurable: true,
+          enumerable: false,
+          writable: false,
+          value: (...args) => target.action({ name: prop, args })
+        };
+      }
+      return void 0;
+    }
+  });
+}
+
+// src/common/inline-websocket-adapter2.ts
+import { WSContext } from "hono/ws";
+var LOGGER_NAME3 = "fake-event-source2";
+function logger5() {
+  return getLogger(LOGGER_NAME3);
+}
+var InlineWebSocketAdapter2 = class {
+  // WebSocket readyState values
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  // Private properties
+  #handler;
+  #wsContext;
+  #readyState = 0;
+  // Start in CONNECTING state
+  #queuedMessages = [];
+  // Event buffering is needed since events can be fired
+  // before JavaScript has a chance to add event listeners (e.g. within the same tick)
+  #bufferedEvents = [];
+  // Event listeners with buffering
+  #eventListeners = /* @__PURE__ */ new Map();
+  constructor(handler) {
+    this.#handler = handler;
+    this.#wsContext = new WSContext({
+      raw: this,
+      send: (data) => {
+        logger5().debug("WSContext.send called");
+        this.#handleMessage(data);
+      },
+      close: (code, reason) => {
+        logger5().debug("WSContext.close called", { code, reason });
+        this.#handleClose(code || 1e3, reason || "");
+      },
+      // Set readyState to 1 (OPEN) since handlers expect an open connection
+      readyState: 1
+    });
+    this.#initialize();
+  }
+  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) {
+    logger5().debug("send called", { readyState: this.readyState });
+    if (this.readyState !== this.OPEN) {
+      const error = new Error("WebSocket is not open");
+      logger5().warn("cannot send message, websocket not open", {
+        readyState: this.readyState,
+        dataType: typeof data,
+        dataLength: typeof data === "string" ? data.length : "binary",
+        error
+      });
+      this.#fireError(error);
+      return;
+    }
+    this.#handler.onMessage({ data }, this.#wsContext);
+  }
+  /**
+   * Closes the connection
+   */
+  close(code = 1e3, reason = "") {
+    if (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {
+      return;
+    }
+    logger5().debug("closing fake websocket", { code, reason });
+    this.#readyState = this.CLOSING;
+    try {
+      this.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);
+    } catch (err) {
+      logger5().error("error closing websocket", { error: err });
+    } finally {
+      this.#readyState = this.CLOSED;
+      const closeEvent = {
+        type: "close",
+        wasClean: code === 1e3,
+        code,
+        reason,
+        target: this,
+        currentTarget: this
+      };
+      this.#fireClose(closeEvent);
+    }
+  }
+  /**
+   * Initialize the connection with the handler
+   */
+  async #initialize() {
+    try {
+      logger5().debug("fake websocket initializing");
+      logger5().debug("calling handler.onOpen with WSContext");
+      this.#handler.onOpen(void 0, this.#wsContext);
+      this.#readyState = this.OPEN;
+      logger5().debug("fake websocket initialized and now OPEN");
+      this.#fireOpen();
+      if (this.#queuedMessages.length > 0) {
+        if (this.readyState !== this.OPEN) {
+          logger5().warn("socket no longer open, dropping queued messages");
+          return;
+        }
+        logger5().debug(
+          `now processing ${this.#queuedMessages.length} queued messages`
+        );
+        const messagesToProcess = [...this.#queuedMessages];
+        this.#queuedMessages = [];
+        for (const message of messagesToProcess) {
+          logger5().debug("processing queued message");
+          this.#handleMessage(message);
+        }
+      }
+    } catch (err) {
+      logger5().error("error opening fake websocket", {
+        error: err,
+        errorMessage: err instanceof Error ? err.message : String(err),
+        stack: err instanceof Error ? err.stack : void 0
+      });
+      this.#fireError(err);
+      this.close(1011, "Internal error during initialization");
+    }
+  }
+  /**
+   * Handle messages received from the server via the WSContext
+   */
+  #handleMessage(data) {
+    if (this.readyState !== this.OPEN) {
+      logger5().debug("message received before socket is OPEN, queuing", {
+        readyState: this.readyState,
+        dataType: typeof data,
+        dataLength: typeof data === "string" ? data.length : data instanceof ArrayBuffer ? data.byteLength : data instanceof Uint8Array ? data.byteLength : "unknown"
+      });
+      this.#queuedMessages.push(data);
+      return;
+    }
+    logger5().debug("fake websocket received message from server", {
+      dataType: typeof data,
+      dataLength: typeof data === "string" ? data.length : data instanceof ArrayBuffer ? data.byteLength : data instanceof Uint8Array ? data.byteLength : "unknown"
+    });
+    const event = {
+      type: "message",
+      data,
+      target: this,
+      currentTarget: this
+    };
+    this.#dispatchEvent("message", event);
+  }
+  #handleClose(code, reason) {
+    if (this.readyState === this.CLOSED) return;
+    this.#readyState = this.CLOSED;
+    const event = {
+      type: "close",
+      code,
+      reason,
+      wasClean: code === 1e3,
+      target: this,
+      currentTarget: this
+    };
+    this.#dispatchEvent("close", event);
+  }
+  addEventListener(type, listener) {
+    if (!this.#eventListeners.has(type)) {
+      this.#eventListeners.set(type, []);
+    }
+    this.#eventListeners.get(type).push(listener);
+    this.#flushBufferedEvents(type);
+  }
+  removeEventListener(type, listener) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners) {
+      const index = listeners.indexOf(listener);
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    }
+  }
+  #dispatchEvent(type, event) {
+    const listeners = this.#eventListeners.get(type);
+    if (listeners && listeners.length > 0) {
+      logger5().debug(
+        `dispatching ${type} event to ${listeners.length} listeners`
+      );
+      for (const listener of listeners) {
+        try {
+          listener(event);
+        } catch (err) {
+          logger5().error(`error in ${type} event listener`, { error: err });
+        }
+      }
+    } else {
+      logger5().debug(`no ${type} listeners registered, buffering event`);
+      this.#bufferedEvents.push({ type, event });
+    }
+    switch (type) {
+      case "open":
+        if (this.#onopen) {
+          try {
+            this.#onopen(event);
+          } catch (error) {
+            logger5().error("error in onopen handler", { error });
+          }
+        }
+        break;
+      case "close":
+        if (this.#onclose) {
+          try {
+            this.#onclose(event);
+          } catch (error) {
+            logger5().error("error in onclose handler", { error });
+          }
+        }
+        break;
+      case "error":
+        if (this.#onerror) {
+          try {
+            this.#onerror(event);
+          } catch (error) {
+            logger5().error("error in onerror handler", { error });
+          }
+        }
+        break;
+      case "message":
+        if (this.#onmessage) {
+          try {
+            this.#onmessage(event);
+          } catch (error) {
+            logger5().error("error in onmessage handler", { error });
+          }
+        }
+        break;
+    }
+  }
+  dispatchEvent(event) {
+    this.#dispatchEvent(event.type, event);
+    return true;
+  }
+  #flushBufferedEvents(type) {
+    const eventsToFlush = this.#bufferedEvents.filter(
+      (buffered) => buffered.type === type
+    );
+    this.#bufferedEvents = this.#bufferedEvents.filter(
+      (buffered) => buffered.type !== type
+    );
+    for (const { event } of eventsToFlush) {
+      this.#dispatchEvent(type, event);
+    }
+  }
+  #fireOpen() {
+    try {
+      const event = {
+        type: "open",
+        target: this,
+        currentTarget: this
+      };
+      this.#dispatchEvent("open", event);
+    } catch (err) {
+      logger5().error("error in open event", { error: err });
+    }
+  }
+  #fireClose(event) {
+    try {
+      this.#dispatchEvent("close", event);
+    } catch (err) {
+      logger5().error("error in close event", { error: err });
+    }
+  }
+  #fireError(error) {
+    try {
+      const event = {
+        type: "error",
+        target: this,
+        currentTarget: this,
+        error,
+        message: error instanceof Error ? error.message : String(error)
+      };
+      this.#dispatchEvent("error", event);
+    } catch (err) {
+      logger5().error("error in error event", { error: err });
+    }
+    logger5().error("websocket error", { error });
+  }
+  // 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/drivers/engine/actor-driver.ts
+import { Runner } from "@rivetkit/engine-runner";
+import * as cbor10 from "cbor-x";
+import { WSContext as WSContext2 } from "hono/ws";
+import invariant7 from "invariant";
+
+// src/registry/run-config.ts
+import { z as z8 } from "zod";
+
+// src/inspector/config.ts
+import { z as z7 } from "zod";
+var defaultTokenFn = () => {
+  const envToken = getEnvUniversal("RIVETKIT_INSPECTOR_TOKEN");
+  if (envToken) {
+    return envToken;
+  }
+  return "";
+};
+var defaultEnabled = () => {
+  return getEnvUniversal("NODE_ENV") !== "production" || !getEnvUniversal("RIVETKIT_INSPECTOR_DISABLE");
+};
+var defaultInspectorOrigins = [
+  "http://localhost:43708",
+  "https://studio.rivet.gg"
+];
+var defaultCors = {
+  origin: (origin) => {
+    if (defaultInspectorOrigins.includes(origin) || origin.startsWith("https://") && origin.endsWith("rivet-gg.vercel.app")) {
+      return origin;
+    } else {
+      return null;
+    }
+  },
+  allowMethods: ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+  allowHeaders: [
+    "Content-Type",
+    "Authorization",
+    HEADER_ACTOR_QUERY,
+    "last-event-id"
+  ],
+  maxAge: 3600,
+  credentials: true
+};
+var InspectorConfigSchema = z7.object({
+  enabled: z7.boolean().optional().default(defaultEnabled),
+  /** CORS configuration for the router. Uses Hono's CORS middleware options. */
+  cors: z7.custom().optional().default(() => defaultCors),
+  /**
+   * Token used to access the Inspector.
+   */
+  token: z7.function().returns(z7.string()).optional().default(() => defaultTokenFn),
+  /**
+   * Default RivetKit server endpoint for Rivet Inspector to connect to. This should be the same endpoint as what you use for your Rivet client to connect to RivetKit.
+   *
+   * This is a convenience property just for printing out the inspector URL.
+   */
+  defaultEndpoint: z7.string().optional()
+}).optional().default(() => ({
+  enabled: defaultEnabled(),
+  token: defaultTokenFn,
+  cors: defaultCors
+}));
+
+// src/registry/run-config.ts
+var DriverConfigSchema = z8.object({
+  /** Machine-readable name to identify this driver by. */
+  name: z8.string(),
+  manager: z8.custom(),
+  actor: z8.custom()
+});
+var RunConfigSchema = z8.object({
+  driver: DriverConfigSchema.optional(),
+  /** Endpoint to connect to the Rivet engine. Can be configured via RIVET_ENGINE env var. */
+  engine: z8.string().optional(),
+  // This is a function to allow for lazy configuration of upgradeWebSocket on the
+  // fly. This is required since the dependencies that profie upgradeWebSocket
+  // (specifically Node.js) can sometimes only be specified after the router is
+  // created or must be imported async using `await import(...)`
+  getUpgradeWebSocket: z8.custom().optional(),
+  role: z8.enum(["all", "server", "runner"]).optional().default("all"),
+  /** CORS configuration for the router. Uses Hono's CORS middleware options. */
+  cors: z8.custom().optional(),
+  maxIncomingMessageSize: z8.number().optional().default(65536),
+  inspector: InspectorConfigSchema,
+  /**
+   * Base path for the router. This is used to prefix all routes.
+   * For example, if the base path is `/api`, then the route `/actors` will be
+   * available at `/api/actors`.
+   */
+  basePath: z8.string().optional().default("/")
+}).default({});
+
+// src/driver-helpers/utils.ts
+import * as cbor9 from "cbor-x";
+function serializeEmptyPersistData(input) {
+  const persistData = {
+    input: input !== void 0 ? bufferToArrayBuffer(cbor9.encode(input)) : null,
+    hasInitialized: false,
+    state: bufferToArrayBuffer(cbor9.encode(void 0)),
+    connections: [],
+    scheduledEvents: []
+  };
+  return PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(persistData);
+}
+
+// src/drivers/engine/keys.ts
+var EMPTY_KEY = "/";
+var KEY_SEPARATOR = "/";
+function serializeActorKey(key) {
+  if (key.length === 0) {
+    return EMPTY_KEY;
+  }
+  const escapedParts = key.map((part) => {
+    if (part === "") {
+      return "\\0";
+    }
+    let escaped = part.replace(/\\/g, "\\\\");
+    escaped = escaped.replace(/\//g, `\\${KEY_SEPARATOR}`);
+    return escaped;
+  });
+  return escapedParts.join(KEY_SEPARATOR);
+}
+function deserializeActorKey(keyString) {
+  if (keyString === void 0 || keyString === null || keyString === EMPTY_KEY) {
+    return [];
+  }
+  const parts = [];
+  let currentPart = "";
+  let escaping = false;
+  let isEmptyStringMarker = false;
+  for (let i = 0; i < keyString.length; i++) {
+    const char = keyString[i];
+    if (escaping) {
+      if (char === "0") {
+        isEmptyStringMarker = true;
+      } else {
+        currentPart += char;
+      }
+      escaping = false;
+    } else if (char === "\\") {
+      escaping = true;
+    } else if (char === KEY_SEPARATOR) {
+      if (isEmptyStringMarker) {
+        parts.push("");
+        isEmptyStringMarker = false;
+      } else {
+        parts.push(currentPart);
+      }
+      currentPart = "";
+    } else {
+      currentPart += char;
+    }
+  }
+  if (escaping) {
+    parts.push(currentPart + "\\");
+  } else if (isEmptyStringMarker) {
+    parts.push("");
+  } else if (currentPart !== "" || parts.length > 0) {
+    parts.push(currentPart);
+  }
+  return parts;
+}
+
+// src/drivers/engine/kv.ts
+var KEYS = {
+  PERSIST_DATA: Uint8Array.from([1, 1])
+};
+
+// src/drivers/engine/log.ts
+var LOGGER_NAME4 = "driver-engine";
+function logger6() {
+  return getLogger(LOGGER_NAME4);
+}
+
+// src/drivers/engine/actor-driver.ts
+var EngineActorDriver = class {
+  #registryConfig;
+  #runConfig;
+  #managerDriver;
+  #inlineClient;
+  #config;
+  #runner;
+  #actors = /* @__PURE__ */ new Map();
+  #actorRouter;
+  #version = 1;
+  // Version for the runner protocol
+  constructor(registryConfig, runConfig, managerDriver, inlineClient, config4) {
+    this.#registryConfig = registryConfig;
+    this.#runConfig = runConfig;
+    this.#managerDriver = managerDriver;
+    this.#inlineClient = inlineClient;
+    this.#config = config4;
+    this.#actorRouter = createActorRouter(runConfig, this);
+    let hasDisconnected = false;
+    const runnerConfig = {
+      version: this.#version,
+      endpoint: config4.endpoint,
+      pegboardEndpoint: config4.pegboardEndpoint,
+      namespace: config4.namespace,
+      totalSlots: config4.totalSlots,
+      runnerName: config4.runnerName,
+      runnerKey: config4.runnerKey,
+      metadata: {
+        inspectorToken: this.#runConfig.inspector.token()
+      },
+      prepopulateActorNames: Object.fromEntries(
+        Object.keys(this.#registryConfig.use).map((name) => [
+          name,
+          { metadata: {} }
+        ])
+      ),
+      onConnected: () => {
+        if (hasDisconnected) {
+          logger6().info("runner reconnected", {
+            namespace: this.#config.namespace,
+            runnerName: this.#config.runnerName
+          });
+        } else {
+          logger6().debug("runner connected", {
+            namespace: this.#config.namespace,
+            runnerName: this.#config.runnerName
+          });
+        }
+      },
+      onDisconnected: () => {
+        logger6().warn("runner disconnected", {
+          namespace: this.#config.namespace,
+          runnerName: this.#config.runnerName
+        });
+        hasDisconnected = true;
+      },
+      fetch: this.#runnerFetch.bind(this),
+      websocket: this.#runnerWebSocket.bind(this),
+      onActorStart: this.#runnerOnActorStart.bind(this),
+      onActorStop: this.#runnerOnActorStop.bind(this)
+    };
+    this.#runner = new Runner(runnerConfig);
+    this.#runner.start();
+    logger6().debug("engine runner started", {
+      endpoint: config4.endpoint,
+      namespace: config4.namespace,
+      runnerName: config4.runnerName
+    });
+  }
+  async #loadActorHandler(actorId) {
+    const handler = this.#actors.get(actorId);
+    if (!handler) throw new Error(`Actor handler does not exist ${actorId}`);
+    if (handler.actorStartPromise) await handler.actorStartPromise.promise;
+    if (!handler.actor) throw new Error("Actor should be loaded");
+    return handler;
+  }
+  async loadActor(actorId) {
+    const handler = await this.#loadActorHandler(actorId);
+    if (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);
+    return handler.actor;
+  }
+  getGenericConnGlobalState(actorId) {
+    const handler = this.#actors.get(actorId);
+    if (!handler) {
+      throw new Error(`Actor ${actorId} not loaded`);
+    }
+    return handler.genericConnGlobalState;
+  }
+  getContext(actorId) {
+    return {};
+  }
+  async readPersistedData(actorId) {
+    const handler = this.#actors.get(actorId);
+    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
+    if (handler.persistedData) return handler.persistedData;
+    const [value] = await this.#runner.kvGet(actorId, [KEYS.PERSIST_DATA]);
+    if (value !== null) {
+      handler.persistedData = value;
+      return value;
+    } else {
+      return void 0;
+    }
+  }
+  async writePersistedData(actorId, data) {
+    const handler = this.#actors.get(actorId);
+    if (!handler) throw new Error(`Actor ${actorId} not loaded`);
+    handler.persistedData = data;
+    await this.#runner.kvPut(actorId, [[KEYS.PERSIST_DATA, data]]);
+  }
+  async setAlarm(actor2, timestamp) {
+  }
+  async getDatabase(_actorId) {
+    return void 0;
+  }
+  // Runner lifecycle callbacks
+  async #runnerOnActorStart(actorId, generation, config4) {
+    logger6().debug("runner actor starting", {
+      actorId,
+      name: config4.name,
+      key: config4.key,
+      generation
+    });
+    let input;
+    if (config4.input) {
+      input = cbor10.decode(config4.input);
+    }
+    let handler = this.#actors.get(actorId);
+    if (!handler) {
+      handler = {
+        genericConnGlobalState: new GenericConnGlobalState(),
+        actorStartPromise: Promise.withResolvers(),
+        persistedData: serializeEmptyPersistData(input)
+      };
+      this.#actors.set(actorId, handler);
+    }
+    const name = config4.name;
+    invariant7(config4.key, "actor should have a key");
+    const key = deserializeActorKey(config4.key);
+    const definition = lookupInRegistry(
+      this.#registryConfig,
+      config4.name
+      // TODO: Remove cast
+    );
+    handler.actor = definition.instantiate();
+    const connDrivers = createGenericConnDrivers(
+      handler.genericConnGlobalState
+    );
+    await handler.actor.start(
+      connDrivers,
+      this,
+      this.#inlineClient,
+      actorId,
+      name,
+      key,
+      "unknown"
+      // TODO: Add regions
+    );
+    handler.actorStartPromise?.resolve();
+    handler.actorStartPromise = void 0;
+    logger6().debug("runner actor started", { actorId, name, key });
+  }
+  async #runnerOnActorStop(actorId, generation) {
+    logger6().debug("runner actor stopping", { actorId, generation });
+    const handler = this.#actors.get(actorId);
+    if (handler?.actor) {
+      await handler.actor._stop();
+      this.#actors.delete(actorId);
+    }
+    logger6().debug("runner actor stopped", { actorId });
+  }
+  async #runnerFetch(actorId, request) {
+    logger6().debug("runner fetch", {
+      actorId,
+      url: request.url,
+      method: request.method
+    });
+    return await this.#actorRouter.fetch(request, { actorId });
+  }
+  async #runnerWebSocket(actorId, websocketRaw, request) {
+    const websocket = websocketRaw;
+    logger6().debug("runner websocket", { actorId, url: request.url });
+    const url = new URL(request.url);
+    const encodingRaw = request.headers.get(HEADER_ENCODING);
+    const connParamsRaw = request.headers.get(HEADER_CONN_PARAMS);
+    const authDataRaw = request.headers.get(HEADER_AUTH_DATA);
+    const encoding = EncodingSchema.parse(encodingRaw);
+    const connParams = connParamsRaw ? JSON.parse(connParamsRaw) : void 0;
+    const authData = authDataRaw ? JSON.parse(authDataRaw) : void 0;
+    let wsHandlerPromise;
+    if (url.pathname === PATH_CONNECT_WEBSOCKET) {
+      wsHandlerPromise = handleWebSocketConnect(
+        request,
+        this.#runConfig,
+        this,
+        actorId,
+        encoding,
+        connParams,
+        authData
+      );
+    } else if (url.pathname.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+      wsHandlerPromise = handleRawWebSocketHandler(
+        request,
+        url.pathname + url.search,
+        this,
+        actorId,
+        authData
+      );
+    } else {
+      throw new Error(`Unreachable path: ${url.pathname}`);
+    }
+    const wsContext = new WSContext2(websocket);
+    wsHandlerPromise.catch((err) => {
+      logger6().error("building websocket handlers errored", { err });
+      wsContext.close(1011, `${err}`);
+    });
+    if (websocket.readyState === 1) {
+      wsHandlerPromise.then((x) => x.onOpen?.(new Event("open"), wsContext));
+    } else {
+      websocket.addEventListener("open", (event) => {
+        wsHandlerPromise.then((x) => x.onOpen?.(event, wsContext));
+      });
+    }
+    websocket.addEventListener("message", (event) => {
+      wsHandlerPromise.then((x) => x.onMessage?.(event, wsContext));
+    });
+    websocket.addEventListener("close", (event) => {
+      wsHandlerPromise.then((x) => x.onClose?.(event, wsContext));
+    });
+    websocket.addEventListener("error", (event) => {
+      wsHandlerPromise.then((x) => x.onError?.(event, wsContext));
+    });
+  }
+  async sleep(actorId) {
+    this.#runner.sleepActor(actorId);
+  }
+  async shutdown(immediate) {
+    logger6().info("stopping engine actor driver");
+    await this.#runner.shutdown(immediate);
+  }
+};
+
+// src/drivers/engine/config.ts
+import { z as z9 } from "zod";
+var ConfigSchema = z9.object({
+  app: z9.custom().optional(),
+  endpoint: z9.string().default(
+    () => getEnvUniversal("RIVET_ENGINE") ?? "http://localhost:7080"
+  ),
+  pegboardEndpoint: z9.string().optional(),
+  namespace: z9.string().default(() => getEnvUniversal("RIVET_NAMESPACE") ?? "default"),
+  runnerName: z9.string().default(() => getEnvUniversal("RIVET_RUNNER") ?? "rivetkit"),
+  // TODO: Automatically attempt ot determine key by common env vars (e.g. k8s pod name)
+  runnerKey: z9.string().default(
+    () => getEnvUniversal("RIVET_RUNNER_KEY") ?? crypto.randomUUID()
+  ),
+  totalSlots: z9.number().default(1e5),
+  addresses: z9.record(
+    z9.object({
+      host: z9.string(),
+      port: z9.number()
+    })
+  ).default({ main: { host: "127.0.0.1", port: 5051 } })
+}).default({});
+
+// src/drivers/engine/manager-driver.ts
+import * as cbor11 from "cbor-x";
+import invariant8 from "invariant";
+
+// src/common/websocket.ts
+var webSocketPromise = null;
+async function importWebSocket() {
+  if (webSocketPromise !== null) {
+    return webSocketPromise;
+  }
+  webSocketPromise = (async () => {
+    let _WebSocket;
+    if (typeof WebSocket !== "undefined") {
+      _WebSocket = WebSocket;
+      logger4().debug("using native websocket");
+    } else {
+      try {
+        const ws = await import("ws");
+        _WebSocket = ws.default;
+        logger4().debug("using websocket from npm");
+      } catch {
+        _WebSocket = class MockWebSocket {
+          constructor() {
+            throw new Error(
+              'WebSocket support requires installing the "ws" peer dependency.'
+            );
+          }
+        };
+        logger4().debug("using mock websocket");
+      }
+    }
+    return _WebSocket;
+  })();
+  return webSocketPromise;
+}
+
+// src/drivers/engine/api-utils.ts
+var EngineApiError = class extends Error {
+  constructor(group, code, message) {
+    super(message || `Engine API error: ${group}/${code}`);
+    this.group = group;
+    this.code = code;
+    this.name = "EngineApiError";
+  }
+};
+async function apiCall(endpoint, namespace, method, path3, body) {
+  const url = `${endpoint}${path3}${path3.includes("?") ? "&" : "?"}namespace=${encodeURIComponent(namespace)}`;
+  const options = {
+    method,
+    headers: {
+      "Content-Type": "application/json"
+    }
+  };
+  if (body !== void 0 && method !== "GET") {
+    options.body = JSON.stringify(body);
+  }
+  logger6().debug("making api call", { method, url });
+  const response = await fetch(url, options);
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger6().error("api call failed", {
+      status: response.status,
+      statusText: response.statusText,
+      error: errorText,
+      method,
+      path: path3
+    });
+    try {
+      const errorData = JSON.parse(errorText);
+      if (errorData.kind === "error" && errorData.group && errorData.code) {
+        throw new EngineApiError(
+          errorData.group,
+          errorData.code,
+          errorData.message
+        );
+      }
+    } catch (parseError) {
+    }
+    throw new Error(
+      `API call failed: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.json();
+}
+
+// src/drivers/engine/api-endpoints.ts
+async function getActor(config4, actorId) {
+  return apiCall(
+    config4.endpoint,
+    config4.namespace,
+    "GET",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+async function getActorById(config4, name, key) {
+  const serializedKey = serializeActorKey(key);
+  return apiCall(
+    config4.endpoint,
+    config4.namespace,
+    "GET",
+    `/actors/by-id?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`
+  );
+}
+async function getOrCreateActorById(config4, request) {
+  return apiCall(
+    config4.endpoint,
+    config4.namespace,
+    "PUT",
+    `/actors/by-id`,
+    request
+  );
+}
+async function createActor(config4, request) {
+  return apiCall(
+    config4.endpoint,
+    config4.namespace,
+    "POST",
+    `/actors`,
+    request
+  );
+}
+async function destroyActor(config4, actorId) {
+  return apiCall(
+    config4.endpoint,
+    config4.namespace,
+    "DELETE",
+    `/actors/${encodeURIComponent(actorId)}`
+  );
+}
+
+// src/drivers/engine/ws-proxy.ts
+async function createWebSocketProxy(c, targetUrl, headers) {
+  const WebSocket2 = await importWebSocket();
+  for (const [k, v] of c.req.raw.headers.entries()) {
+    if (!k.startsWith("sec-") && k !== "connection" && k !== "upgrade") {
+      headers[k] = v;
+    }
+  }
+  const state = {};
+  return {
+    onOpen: async (event, clientWs) => {
+      logger6().debug("client websocket connected", { targetUrl });
+      if (clientWs.readyState !== 1) {
+        logger6().warn("client websocket not open on connection", {
+          targetUrl,
+          readyState: clientWs.readyState
+        });
+        return;
+      }
+      const targetWs = new WebSocket2(targetUrl, { headers });
+      state.targetWs = targetWs;
+      state.connectPromise = new Promise((resolve, reject) => {
+        targetWs.addEventListener("open", () => {
+          logger6().debug("target websocket connected", { targetUrl });
+          if (clientWs.readyState !== 1) {
+            logger6().warn("client websocket closed before target connected", {
+              targetUrl,
+              clientReadyState: clientWs.readyState
+            });
+            targetWs.close(1001, "Client disconnected");
+            reject(new Error("Client disconnected"));
+            return;
+          }
+          resolve();
+        });
+        targetWs.addEventListener("error", (error) => {
+          logger6().warn("target websocket error during connection", {
+            targetUrl
+          });
+          reject(error);
+        });
+      });
+      state.targetWs.addEventListener("message", (event2) => {
+        if (typeof event2.data === "string" || event2.data instanceof ArrayBuffer) {
+          clientWs.send(event2.data);
+        } else if (event2.data instanceof Blob) {
+          event2.data.arrayBuffer().then((buffer) => {
+            clientWs.send(buffer);
+          });
+        }
+      });
+      state.targetWs.addEventListener("close", (event2) => {
+        logger6().debug("target websocket closed", {
+          targetUrl,
+          code: event2.code,
+          reason: event2.reason
+        });
+        closeWebSocketIfOpen(clientWs, event2.code, event2.reason);
+      });
+      state.targetWs.addEventListener("error", (error) => {
+        logger6().error("target websocket error", { targetUrl, error });
+        closeWebSocketIfOpen(clientWs, 1011, "Target WebSocket error");
+      });
+    },
+    onMessage: async (event, clientWs) => {
+      if (!state.targetWs || !state.connectPromise) {
+        logger6().error("websocket state not initialized", { targetUrl });
+        return;
+      }
+      try {
+        await state.connectPromise;
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.send(event.data);
+        } else {
+          logger6().warn("target websocket not open", {
+            targetUrl,
+            readyState: state.targetWs.readyState
+          });
+        }
+      } catch (error) {
+        logger6().error("failed to connect to target websocket", {
+          targetUrl,
+          error
+        });
+        closeWebSocketIfOpen(clientWs, 1011, "Failed to connect to target");
+      }
+    },
+    onClose: (event, clientWs) => {
+      logger6().debug("client websocket closed", {
+        targetUrl,
+        code: event.code,
+        reason: event.reason,
+        wasClean: event.wasClean
+      });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN || state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close(1e3, event.reason || "Client disconnected");
+        }
+      }
+    },
+    onError: (event, clientWs) => {
+      logger6().error("client websocket error", { targetUrl, event });
+      if (state.targetWs) {
+        if (state.targetWs.readyState === WebSocket2.OPEN) {
+          state.targetWs.close(1011, "Client WebSocket error");
+        } else if (state.targetWs.readyState === WebSocket2.CONNECTING) {
+          state.targetWs.close();
+        }
+      }
+    }
+  };
+}
+function closeWebSocketIfOpen(ws, code, reason) {
+  if (ws.readyState === 1) {
+    ws.close(code, reason);
+  } else if ("close" in ws && ws.readyState === WebSocket.OPEN) {
+    ws.close(code, reason);
+  }
+}
+
+// src/drivers/engine/manager-driver.ts
+var EngineManagerDriver = class {
+  #config;
+  #runConfig;
+  #importWebSocketPromise;
+  constructor(config4, runConfig) {
+    this.#config = config4;
+    this.#runConfig = runConfig;
+    if (!this.#runConfig.inspector.token()) {
+      const token = generateRandomString();
+      this.#runConfig.inspector.token = () => token;
+    }
+    this.#importWebSocketPromise = importWebSocket();
+  }
+  async sendRequest(actorId, actorRequest) {
+    logger6().debug("sending request to actor via guard", {
+      actorId,
+      method: actorRequest.method,
+      url: actorRequest.url
+    });
+    return this.#forwardHttpRequest(actorRequest, actorId);
+  }
+  async openWebSocket(path3, actorId, encoding, params) {
+    const WebSocket2 = await this.#importWebSocketPromise;
+    const guardUrl = `${this.#config.endpoint}${path3}`;
+    logger6().debug("opening websocket to actor via guard", {
+      actorId,
+      path: path3,
+      guardUrl
+    });
+    const ws = new WebSocket2(guardUrl, {
+      headers: buildGuardHeadersForWebSocket(actorId, encoding, params)
+    });
+    logger6().debug("websocket connection opened", { actorId });
+    return ws;
+  }
+  async proxyRequest(_c, actorRequest, actorId) {
+    logger6().debug("forwarding request to actor via guard", {
+      actorId,
+      method: actorRequest.method,
+      url: actorRequest.url,
+      hasBody: !!actorRequest.body
+    });
+    return this.#forwardHttpRequest(actorRequest, actorId);
+  }
+  async proxyWebSocket(c, path3, actorId, encoding, params, authData) {
+    const upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();
+    invariant8(upgradeWebSocket, "missing getUpgradeWebSocket");
+    const guardUrl = `${this.#config.endpoint}${path3}`;
+    const wsGuardUrl = guardUrl.replace("http://", "ws://");
+    logger6().debug("forwarding websocket to actor via guard", {
+      actorId,
+      path: path3,
+      guardUrl
+    });
+    const headers = buildGuardHeadersForWebSocket(
+      actorId,
+      encoding,
+      params,
+      authData
+    );
+    const args = await createWebSocketProxy(c, wsGuardUrl, headers);
+    return await upgradeWebSocket(() => args)(c, noopNext());
+  }
+  extraStartupLog() {
+    return {
+      engine: this.#config.endpoint,
+      namespace: this.#config.namespace,
+      runner: this.#config.runnerName,
+      address: Object.values(this.#config.addresses).map((v) => `${v.host}:${v.port}`).join(", ")
+    };
+  }
+  async getForId({
+    c,
+    name,
+    actorId
+  }) {
+    try {
+      const response = await getActor(this.#config, actorId);
+      if (response.actor.name !== name) {
+        logger6().debug("actor name mismatch from api", {
+          actorId,
+          apiName: response.actor.name,
+          requestedName: name
+        });
+        return void 0;
+      }
+      const keyRaw = response.actor.key;
+      invariant8(keyRaw, `actor ${actorId} should have key`);
+      const key = deserializeActorKey(keyRaw);
+      return {
+        actorId,
+        name,
+        key
+      };
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getWithKey({
+    c,
+    name,
+    key
+  }) {
+    logger6().debug("getWithKey: searching for actor", { name, key });
+    try {
+      const response = await getActorById(this.#config, name, key);
+      if (!response.actor_id) {
+        return void 0;
+      }
+      const actorId = response.actor_id;
+      logger6().debug("getWithKey: found actor via api", {
+        actorId,
+        name,
+        key
+      });
+      return {
+        actorId,
+        name,
+        key
+      };
+    } catch (error) {
+      if (error instanceof EngineApiError && error.group === "actor" && error.code === "not_found") {
+        return void 0;
+      }
+      throw error;
+    }
+  }
+  async getOrCreateWithKey(input) {
+    const { c, name, key, input: actorInput, region } = input;
+    logger6().info(
+      "getOrCreateWithKey: getting or creating actor via engine api",
+      {
+        name,
+        key
+      }
+    );
+    const response = await getOrCreateActorById(this.#config, {
+      name,
+      key: serializeActorKey(key),
+      runner_name_selector: this.#config.runnerName,
+      input: input ? cbor11.encode(actorInput).toString("base64") : void 0,
+      crash_policy: "sleep"
+    });
+    const actorId = response.actor_id;
+    logger6().info("getOrCreateWithKey: actor ready", {
+      actorId,
+      name,
+      key,
+      created: response.created
+    });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async createActor({
+    c,
+    name,
+    key,
+    input
+  }) {
+    const existingActor = await this.getWithKey({ c, name, key });
+    if (existingActor) {
+      throw new ActorAlreadyExists(name, key);
+    }
+    logger6().info("creating actor via engine api", { name, key });
+    const result = await createActor(this.#config, {
+      name,
+      runner_name_selector: this.#config.runnerName,
+      key: serializeActorKey(key),
+      input: input ? cbor11.encode(input).toString("base64") : null,
+      crash_policy: "sleep"
+    });
+    const actorId = result.actor.actor_id;
+    logger6().info("actor created", { actorId, name, key });
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  async destroyActor(actorId) {
+    logger6().info("destroying actor via engine api", { actorId });
+    await destroyActor(this.#config, actorId);
+    logger6().info("actor destroyed", { actorId });
+  }
+  async #forwardHttpRequest(actorRequest, actorId) {
+    const url = new URL(actorRequest.url);
+    const guardUrl = `${this.#config.endpoint}${url.pathname}${url.search}`;
+    let bodyToSend = null;
+    const guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);
+    if (actorRequest.body && actorRequest.method !== "GET" && actorRequest.method !== "HEAD") {
+      if (actorRequest.bodyUsed) {
+        throw new Error("Request body has already been consumed");
+      }
+      const clonedRequest = actorRequest.clone();
+      bodyToSend = await clonedRequest.arrayBuffer();
+      guardHeaders.delete("transfer-encoding");
+      guardHeaders.set(
+        "content-length",
+        String(bodyToSend.byteLength)
+      );
+    }
+    const guardRequest = new Request(guardUrl, {
+      method: actorRequest.method,
+      headers: guardHeaders,
+      body: bodyToSend
+    });
+    return mutableResponse(await fetch(guardRequest));
+  }
+};
+function mutableResponse(fetchRes) {
+  return new Response(fetchRes.body, fetchRes);
+}
+function buildGuardHeadersForHttp(actorRequest, actorId) {
+  const headers = new Headers();
+  for (const [key, value] of actorRequest.headers.entries()) {
+    headers.set(key, value);
+  }
+  headers.set("x-rivet-target", "actor");
+  headers.set("x-rivet-actor", actorId);
+  headers.set("x-rivet-port", "main");
+  return headers;
+}
+function buildGuardHeadersForWebSocket(actorId, encoding, params, authData) {
+  const headers = {};
+  headers["x-rivet-target"] = "actor";
+  headers["x-rivet-actor"] = actorId;
+  headers["x-rivet-port"] = "main";
+  headers[HEADER_EXPOSE_INTERNAL_ERROR] = "true";
+  headers[HEADER_ENCODING] = encoding;
+  if (params) {
+    headers[HEADER_CONN_PARAMS] = JSON.stringify(params);
+  }
+  if (authData) {
+    headers[HEADER_AUTH_DATA] = JSON.stringify(authData);
+  }
+  return headers;
+}
+
+// src/drivers/engine/mod.ts
+function createEngineDriver(inputConfig) {
+  const config4 = ConfigSchema.parse(inputConfig);
+  return {
+    name: "engine",
+    manager: (_registryConfig, runConfig) => {
+      return new EngineManagerDriver(config4, runConfig);
+    },
+    actor: (registryConfig, runConfig, managerDriver, inlineClient) => {
+      return new EngineActorDriver(
+        registryConfig,
+        runConfig,
+        managerDriver,
+        inlineClient,
+        config4
+      );
+    }
+  };
+}
+
+// src/drivers/file-system/actor.ts
+var FileSystemActorDriver = class {
+  #registryConfig;
+  #runConfig;
+  #managerDriver;
+  #inlineClient;
+  #state;
+  constructor(registryConfig, runConfig, managerDriver, inlineClient, state) {
+    this.#registryConfig = registryConfig;
+    this.#runConfig = runConfig;
+    this.#managerDriver = managerDriver;
+    this.#inlineClient = inlineClient;
+    this.#state = state;
+  }
+  async loadActor(actorId) {
+    return this.#state.startActor(
+      this.#registryConfig,
+      this.#runConfig,
+      this.#inlineClient,
+      this,
+      actorId
+    );
+  }
+  getGenericConnGlobalState(actorId) {
+    return this.#state.getActorOrError(actorId).genericConnGlobalState;
+  }
+  /**
+   * Get the current storage directory path
+   */
+  get storagePath() {
+    return this.#state.storagePath;
+  }
+  getContext(_actorId) {
+    return {};
+  }
+  async readPersistedData(actorId) {
+    return new Uint8Array(
+      (await this.#state.loadActorStateOrError(actorId)).persistedData
+    );
+  }
+  async writePersistedData(actorId, data) {
+    const state = await this.#state.loadActorStateOrError(actorId);
+    await this.#state.writeActor(actorId, {
+      ...state,
+      persistedData: bufferToArrayBuffer(data)
+    });
+  }
+  async setAlarm(actor2, timestamp) {
+    await this.#state.setActorAlarm(actor2.id, timestamp);
+  }
+  getDatabase(actorId) {
+    return this.#state.createDatabase(actorId);
+  }
+  sleep(actorId) {
+    return this.#state.sleepActor(actorId);
+  }
+};
+
+// src/drivers/file-system/global-state.ts
+import * as crypto4 from "node:crypto";
+import * as fsSync2 from "node:fs";
+import * as fs2 from "node:fs/promises";
+import * as path2 from "node:path";
+import invariant9 from "invariant";
+
+// dist/schemas/file-system-driver/v1.ts
+import * as bare3 from "@bare-ts/lib";
+var config3 = /* @__PURE__ */ bare3.Config({});
+function read03(bc) {
+  const len = bare3.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [bare3.readString(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = bare3.readString(bc);
+  }
+  return result;
+}
+function write03(bc, x) {
+  bare3.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    bare3.writeString(bc, x[i]);
+  }
+}
+function readActorState(bc) {
+  return {
+    actorId: bare3.readString(bc),
+    name: bare3.readString(bc),
+    key: read03(bc),
+    persistedData: bare3.readData(bc),
+    createdAt: bare3.readU64(bc)
+  };
+}
+function writeActorState(bc, x) {
+  bare3.writeString(bc, x.actorId);
+  bare3.writeString(bc, x.name);
+  write03(bc, x.key);
+  bare3.writeData(bc, x.persistedData);
+  bare3.writeU64(bc, x.createdAt);
+}
+function encodeActorState(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeActorState(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorState(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readActorState(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function readActorAlarm(bc) {
+  return {
+    actorId: bare3.readString(bc),
+    timestamp: bare3.readUint(bc)
+  };
+}
+function writeActorAlarm(bc, x) {
+  bare3.writeString(bc, x.actorId);
+  bare3.writeUint(bc, x.timestamp);
+}
+function encodeActorAlarm(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeActorAlarm(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActorAlarm(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readActorAlarm(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// src/schemas/file-system-driver/versioned.ts
+var CURRENT_VERSION3 = 1;
+var migrations3 = /* @__PURE__ */ new Map();
+var ACTOR_STATE_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION3,
+  migrations: migrations3,
+  serializeVersion: (data) => encodeActorState(data),
+  deserializeVersion: (bytes) => decodeActorState(bytes)
+});
+var ACTOR_ALARM_VERSIONED = createVersionedDataHandler({
+  currentVersion: CURRENT_VERSION3,
+  migrations: migrations3,
+  serializeVersion: (data) => encodeActorAlarm(data),
+  deserializeVersion: (bytes) => decodeActorAlarm(bytes)
+});
+
+// src/drivers/file-system/log.ts
+var LOGGER_NAME5 = "driver-fs";
+function logger7() {
+  return getLogger(LOGGER_NAME5);
+}
+
+// src/drivers/file-system/utils.ts
+import * as crypto3 from "node:crypto";
+import * as fsSync from "node:fs";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+function generateActorId(name, key) {
+  const jsonString = JSON.stringify([name, key]);
+  const hash = crypto3.createHash("sha256").update(jsonString).digest("hex").substring(0, 16);
+  return hash;
+}
+function createHashForPath(dirPath) {
+  const normalizedPath = path.normalize(dirPath);
+  const lastComponent = path.basename(normalizedPath);
+  const hash = crypto3.createHash("sha256").update(normalizedPath).digest("hex").substring(0, 8);
+  return `${lastComponent}-${hash}`;
+}
+function getStoragePath(customPath) {
+  const dataPath = getDataPath("rivetkit");
+  const pathToHash = customPath || process.cwd();
+  const dirHash = createHashForPath(pathToHash);
+  return path.join(dataPath, dirHash);
+}
+async function pathExists(path3) {
+  try {
+    await fs.access(path3);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function ensureDirectoryExists(directoryPath) {
+  if (!await pathExists(directoryPath)) {
+    await fs.mkdir(directoryPath, { recursive: true });
+  }
+}
+function ensureDirectoryExistsSync(directoryPath) {
+  if (!fsSync.existsSync(directoryPath)) {
+    fsSync.mkdirSync(directoryPath, { recursive: true });
+  }
+}
+function getDataPath(appName) {
+  const platform = process.platform;
+  const homeDir = os.homedir();
+  switch (platform) {
+    case "win32":
+      return path.join(
+        process.env.APPDATA || path.join(homeDir, "AppData", "Roaming"),
+        appName
+      );
+    case "darwin":
+      return path.join(homeDir, "Library", "Application Support", appName);
+    default:
+      return path.join(
+        process.env.XDG_DATA_HOME || path.join(homeDir, ".local", "share"),
+        appName
+      );
+  }
+}
+
+// src/drivers/file-system/global-state.ts
+var FileSystemGlobalState = class {
+  #storagePath;
+  #stateDir;
+  #dbsDir;
+  #alarmsDir;
+  #persist;
+  #actors = /* @__PURE__ */ new Map();
+  #actorCountOnStartup = 0;
+  #runnerParams;
+  get storagePath() {
+    return this.#storagePath;
+  }
+  get actorCountOnStartup() {
+    return this.#actorCountOnStartup;
+  }
+  constructor(persist = true, customPath) {
+    this.#persist = persist;
+    this.#storagePath = persist ? getStoragePath(customPath) : "/tmp";
+    this.#stateDir = path2.join(this.#storagePath, "state");
+    this.#dbsDir = path2.join(this.#storagePath, "databases");
+    this.#alarmsDir = path2.join(this.#storagePath, "alarms");
+    if (this.#persist) {
+      ensureDirectoryExistsSync(this.#stateDir);
+      ensureDirectoryExistsSync(this.#dbsDir);
+      ensureDirectoryExistsSync(this.#alarmsDir);
+      try {
+        const actorIds = fsSync2.readdirSync(this.#stateDir);
+        this.#actorCountOnStartup = actorIds.length;
+      } catch (error) {
+        logger7().error("failed to count actors", { error });
+      }
+      logger7().debug("file system driver ready", {
+        dir: this.#storagePath,
+        actorCount: this.#actorCountOnStartup
+      });
+      try {
+        this.#cleanupTempFilesSync();
+      } catch (err) {
+        logger7().error("failed to cleanup temp files", { error: err });
+      }
+    } else {
+      logger7().debug("memory driver ready");
+    }
+  }
+  getActorStatePath(actorId) {
+    return path2.join(this.#stateDir, actorId);
+  }
+  getActorDbPath(actorId) {
+    return path2.join(this.#dbsDir, `${actorId}.db`);
+  }
+  getActorAlarmPath(actorId) {
+    return path2.join(this.#alarmsDir, actorId);
+  }
+  async *getActorsIterator(params) {
+    let actorIds = Array.from(this.#actors.keys()).sort();
+    if (fsSync2.existsSync(this.#stateDir)) {
+      actorIds = fsSync2.readdirSync(this.#stateDir).filter((id) => !id.includes(".tmp")).sort();
+    }
+    const startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;
+    for (let i = startIndex; i < actorIds.length; i++) {
+      const actorId = actorIds[i];
+      if (!actorId) {
+        continue;
+      }
+      try {
+        const state = await this.loadActorStateOrError(actorId);
+        yield state;
+      } catch (error) {
+        logger7().error("failed to load actor state", { actorId, error });
+      }
+    }
+  }
+  /**
+   * Ensures an entry exists for this actor.
+   *
+   * Used for #createActor and #loadActor.
+   */
+  #upsertEntry(actorId) {
+    let entry = this.#actors.get(actorId);
+    if (entry) {
+      return entry;
+    }
+    entry = {
+      id: actorId,
+      genericConnGlobalState: new GenericConnGlobalState(),
+      removed: false
+    };
+    this.#actors.set(actorId, entry);
+    return entry;
+  }
+  /**
+   * Creates a new actor and writes to file system.
+   */
+  async createActor(actorId, name, key, input) {
+    if (this.#actors.has(actorId)) {
+      throw new ActorAlreadyExists(name, key);
+    }
+    const entry = this.#upsertEntry(actorId);
+    entry.state = {
+      actorId,
+      name,
+      key,
+      createdAt: BigInt(Date.now()),
+      persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
+    };
+    await this.writeActor(actorId, entry.state);
+    return entry;
+  }
+  /**
+   * Loads the actor from disk or returns the existing actor entry. This will return an entry even if the actor does not actually exist.
+   */
+  async loadActor(actorId) {
+    const entry = this.#upsertEntry(actorId);
+    if (entry.state) {
+      return entry;
+    }
+    if (!this.#persist) {
+      return entry;
+    }
+    if (entry.loadPromise) {
+      await entry.loadPromise;
+      return entry;
+    }
+    entry.loadPromise = this.loadActorState(entry);
+    return entry.loadPromise;
+  }
+  async loadActorState(entry) {
+    const stateFilePath = this.getActorStatePath(entry.id);
+    try {
+      const stateData = await fs2.readFile(stateFilePath);
+      entry.state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(
+        new Uint8Array(stateData)
+      );
+      return entry;
+    } catch (innerError) {
+      if (innerError.code === "ENOENT") {
+        entry.loadPromise = void 0;
+        return entry;
+      }
+      const error = new Error(`Failed to load actor state: ${innerError}`);
+      throw error;
+    }
+  }
+  async loadOrCreateActor(actorId, name, key, input) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      entry.state = {
+        actorId,
+        name,
+        key,
+        createdAt: BigInt(Date.now()),
+        persistedData: bufferToArrayBuffer(serializeEmptyPersistData(input))
+      };
+      await this.writeActor(actorId, entry.state);
+    }
+    return entry;
+  }
+  async sleepActor(actorId) {
+    invariant9(
+      this.#persist,
+      "cannot sleep actor with memory driver, must use file system driver"
+    );
+    const actor2 = this.#actors.get(actorId);
+    invariant9(actor2, `tried to sleep ${actorId}, does not exist`);
+    if (actor2.loadPromise) await actor2.loadPromise.catch();
+    if (actor2.startPromise?.promise) await actor2.startPromise.promise.catch();
+    actor2.removed = true;
+    invariant9(actor2.actor, "actor should be loaded");
+    await actor2.actor._stop();
+    this.#actors.delete(actorId);
+  }
+  /**
+   * Save actor state to disk.
+   */
+  async writeActor(actorId, state) {
+    if (!this.#persist) {
+      return;
+    }
+    const entry = this.#actors.get(actorId);
+    invariant9(entry, "actor entry does not exist");
+    await this.#performWrite(actorId, state);
+  }
+  async setActorAlarm(actorId, timestamp) {
+    const entry = this.#actors.get(actorId);
+    invariant9(entry, "actor entry does not exist");
+    if (this.#persist) {
+      const alarmPath = this.getActorAlarmPath(actorId);
+      const tempPath = `${alarmPath}.tmp.${crypto4.randomUUID()}`;
+      try {
+        await ensureDirectoryExists(path2.dirname(alarmPath));
+        const alarmData = {
+          actorId,
+          timestamp: BigInt(timestamp)
+        };
+        const data = ACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(alarmData);
+        await fs2.writeFile(tempPath, data);
+        await fs2.rename(tempPath, alarmPath);
+      } catch (error) {
+        try {
+          await fs2.unlink(tempPath);
+        } catch {
+        }
+        logger7().error("failed to write alarm", { actorId, error });
+        throw new Error(`Failed to write alarm: ${error}`);
+      }
+    }
+    this.#scheduleAlarmTimeout(actorId, timestamp);
+  }
+  /**
+   * Perform the actual write operation with atomic writes
+   */
+  async #performWrite(actorId, state) {
+    const dataPath = this.getActorStatePath(actorId);
+    const tempPath = `${dataPath}.tmp.${crypto4.randomUUID()}`;
+    try {
+      await ensureDirectoryExists(path2.dirname(dataPath));
+      const bareState = {
+        actorId: state.actorId,
+        name: state.name,
+        key: state.key,
+        createdAt: state.createdAt,
+        persistedData: state.persistedData
+      };
+      const serializedState = ACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);
+      await fs2.writeFile(tempPath, serializedState);
+      await fs2.rename(tempPath, dataPath);
+    } catch (error) {
+      try {
+        await fs2.unlink(tempPath);
+      } catch {
+      }
+      logger7().error("failed to save actor state", { actorId, error });
+      throw new Error(`Failed to save actor state: ${error}`);
+    }
+  }
+  /**
+   * Call this method after the actor driver has been initiated.
+   *
+   * This will trigger all initial alarms from the file system.
+   *
+   * This needs to be sync since DriverConfig.actor is sync
+   */
+  onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver) {
+    if (this.#runnerParams) {
+      logger7().warn("already called onRunnerStart");
+      return;
+    }
+    this.#runnerParams = {
+      registryConfig,
+      runConfig,
+      inlineClient,
+      actorDriver
+    };
+    try {
+      this.#loadAlarmsSync();
+    } catch (err) {
+      logger7().error("failed to load alarms on startup", { error: err });
+    }
+  }
+  async startActor(registryConfig, runConfig, inlineClient, actorDriver, actorId) {
+    const entry = await this.loadActor(actorId);
+    if (!entry.state) {
+      throw new Error(`Actor does exist and cannot be started: ${actorId}`);
+    }
+    if (entry.startPromise) {
+      await entry.startPromise.promise;
+      invariant9(entry.actor, "actor should have loaded");
+      return entry.actor;
+    }
+    if (entry.actor) {
+      return entry.actor;
+    }
+    entry.startPromise = Promise.withResolvers();
+    try {
+      const definition = lookupInRegistry(registryConfig, entry.state.name);
+      entry.actor = definition.instantiate();
+      const connDrivers = createGenericConnDrivers(
+        entry.genericConnGlobalState
+      );
+      await entry.actor.start(
+        connDrivers,
+        actorDriver,
+        inlineClient,
+        actorId,
+        entry.state.name,
+        entry.state.key,
+        "unknown"
+      );
+      entry.startPromise.resolve();
+      entry.startPromise = void 0;
+      return entry.actor;
+    } catch (innerError) {
+      const error = new Error(
+        `Failed to start actor ${actorId}: ${innerError}`,
+        { cause: innerError }
+      );
+      entry.startPromise?.reject(error);
+      entry.startPromise = void 0;
+      throw error;
+    }
+  }
+  async loadActorStateOrError(actorId) {
+    const state = (await this.loadActor(actorId)).state;
+    if (!state) throw new Error(`Actor does not exist: ${actorId}`);
+    return state;
+  }
+  getActorOrError(actorId) {
+    const entry = this.#actors.get(actorId);
+    if (!entry) throw new Error(`No entry for actor: ${actorId}`);
+    return entry;
+  }
+  async createDatabase(actorId) {
+    return this.getActorDbPath(actorId);
+  }
+  /**
+   * Load all persisted alarms from disk and schedule their timers.
+   */
+  #loadAlarmsSync() {
+    try {
+      const files = fsSync2.existsSync(this.#alarmsDir) ? fsSync2.readdirSync(this.#alarmsDir) : [];
+      for (const file of files) {
+        if (file.includes(".tmp.")) continue;
+        const fullPath = path2.join(this.#alarmsDir, file);
+        try {
+          const buf = fsSync2.readFileSync(fullPath);
+          const alarmData = ACTOR_ALARM_VERSIONED.deserializeWithEmbeddedVersion(
+            new Uint8Array(buf)
+          );
+          const timestamp = Number(alarmData.timestamp);
+          if (Number.isFinite(timestamp)) {
+            this.#scheduleAlarmTimeout(alarmData.actorId, timestamp);
+          } else {
+            logger7().debug("invalid alarm file contents", { file });
+          }
+        } catch (err) {
+          logger7().error("failed to read alarm file", {
+            file,
+            error: stringifyError(err)
+          });
+        }
+      }
+    } catch (err) {
+      logger7().error("failed to list alarms directory", { error: err });
+    }
+  }
+  /**
+   * Schedule an alarm timer for an actor without writing to disk.
+   */
+  #scheduleAlarmTimeout(actorId, timestamp) {
+    const entry = this.#upsertEntry(actorId);
+    if (entry.alarmTimestamp !== void 0 && timestamp >= entry.alarmTimestamp) {
+      logger7().debug("skipping alarm schedule (later than existing)", {
+        actorId,
+        timestamp,
+        current: entry.alarmTimestamp
+      });
+      return;
+    }
+    logger7().debug("scheduling alarm", { actorId, timestamp });
+    entry.alarmTimeout?.abort();
+    entry.alarmTimestamp = timestamp;
+    const delay = Math.max(0, timestamp - Date.now());
+    entry.alarmTimeout = setLongTimeout(async () => {
+      entry.alarmTimestamp = void 0;
+      if (this.#persist) {
+        try {
+          await fs2.unlink(this.getActorAlarmPath(actorId));
+        } catch (err) {
+          if (err?.code !== "ENOENT") {
+            logger7().debug("failed to remove alarm file", {
+              actorId,
+              error: stringifyError(err)
+            });
+          }
+        }
+      }
+      try {
+        logger7().debug("triggering alarm", { actorId, timestamp });
+        const loaded = await this.loadActor(actorId);
+        if (!loaded.state) throw new Error(`Actor does not exist: ${actorId}`);
+        const runnerParams = this.#runnerParams;
+        invariant9(runnerParams, "missing runner params");
+        if (!loaded.actor) {
+          await this.startActor(
+            runnerParams.registryConfig,
+            runnerParams.runConfig,
+            runnerParams.inlineClient,
+            runnerParams.actorDriver,
+            actorId
+          );
+        }
+        invariant9(loaded.actor, "actor should be loaded after wake");
+        await loaded.actor._onAlarm();
+      } catch (err) {
+        logger7().error("failed to handle alarm", {
+          actorId,
+          error: stringifyError(err)
+        });
+      }
+    }, delay);
+  }
+  getOrCreateInspectorAccessToken() {
+    const tokenPath = path2.join(this.#storagePath, "inspector-token");
+    if (fsSync2.existsSync(tokenPath)) {
+      return fsSync2.readFileSync(tokenPath, "utf-8");
+    }
+    const newToken = generateRandomString();
+    fsSync2.writeFileSync(tokenPath, newToken);
+    return newToken;
+  }
+  /**
+   * Cleanup stale temp files on startup (synchronous)
+   */
+  #cleanupTempFilesSync() {
+    try {
+      const files = fsSync2.readdirSync(this.#stateDir);
+      const tempFiles = files.filter((f) => f.includes(".tmp."));
+      const oneHourAgo = Date.now() - 36e5;
+      for (const tempFile of tempFiles) {
+        try {
+          const fullPath = path2.join(this.#stateDir, tempFile);
+          const stat = fsSync2.statSync(fullPath);
+          if (stat.mtimeMs < oneHourAgo) {
+            fsSync2.unlinkSync(fullPath);
+            logger7().info("cleaned up stale temp file", { file: tempFile });
+          }
+        } catch (err) {
+          logger7().debug("failed to cleanup temp file", {
+            file: tempFile,
+            error: err
+          });
+        }
+      }
+    } catch (err) {
+      logger7().error("failed to read actors directory for cleanup", {
+        error: err
+      });
+    }
+  }
+};
+
+// src/drivers/file-system/manager.ts
+import invariant11 from "invariant";
+
+// src/inline-client-driver/mod.ts
+import * as cbor12 from "cbor-x";
+import invariant10 from "invariant";
+import onChange2 from "on-change";
+
+// src/common/eventsource.ts
+var eventSourcePromise = null;
+async function importEventSource() {
+  if (eventSourcePromise !== null) {
+    return eventSourcePromise;
+  }
+  eventSourcePromise = (async () => {
+    let _EventSource;
+    try {
+      const es = await import("eventsource");
+      _EventSource = es.EventSource;
+      logger4().debug("using eventsource from npm");
+    } catch (err) {
+      _EventSource = class MockEventSource {
+        constructor() {
+          throw new Error(
+            'EventSource support requires installing the "eventsource" peer dependency.'
+          );
+        }
+      };
+      logger4().debug("using mock eventsource");
+    }
+    return _EventSource;
+  })();
+  return eventSourcePromise;
+}
+
+// src/inline-client-driver/log.ts
+var LOGGER_NAME6 = "inline-client-driver";
+function logger8() {
+  return getLogger(LOGGER_NAME6);
+}
+
+// src/inline-client-driver/mod.ts
+function createInlineClientDriver(managerDriver) {
+  const driver = {
+    action: async (c, actorQuery, encoding, params, actionName, args, opts) => {
+      try {
+        const { actorId } = await queryActor(c, actorQuery, managerDriver);
+        logger8().debug("found actor for action", { actorId });
+        invariant10(actorId, "Missing actor ID");
+        logger8().debug("handling action", { actionName, encoding });
+        const responseData = await sendHttpRequest({
+          url: `http://actor/action/${encodeURIComponent(actionName)}`,
+          method: "POST",
+          headers: {
+            [HEADER_ENCODING]: encoding,
+            ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {},
+            [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
+          },
+          body: {
+            args: bufferToArrayBuffer(cbor12.encode(args))
+          },
+          encoding,
+          customFetch: managerDriver.sendRequest.bind(managerDriver, actorId),
+          signal: opts?.signal,
+          requestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,
+          responseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED
+        });
+        return cbor12.decode(new Uint8Array(responseData.output));
+      } catch (err) {
+        const { code, message, metadata } = deconstructError(
+          err,
+          logger8(),
+          {},
+          true
+        );
+        const x = new ActorError2(code, message, metadata);
+        throw new ActorError2(code, message, metadata);
+      }
+    },
+    resolveActorId: async (c, actorQuery, _encodingKind) => {
+      const { actorId } = await queryActor(c, actorQuery, managerDriver);
+      logger8().debug("resolved actor", { actorId });
+      invariant10(actorId, "missing actor ID");
+      return actorId;
+    },
+    connectWebSocket: async (c, actorQuery, encodingKind, params) => {
+      const { actorId } = await queryActor(c, actorQuery, managerDriver);
+      logger8().debug("found actor for action", { actorId });
+      invariant10(actorId, "Missing actor ID");
+      logger8().debug("opening websocket", { actorId, encoding: encodingKind });
+      const ws = await managerDriver.openWebSocket(
+        PATH_CONNECT_WEBSOCKET,
+        actorId,
+        encodingKind,
+        params
+      );
+      return ws;
+    },
+    connectSse: async (c, actorQuery, encodingKind, params) => {
+      const { actorId } = await queryActor(c, actorQuery, managerDriver);
+      logger8().debug("found actor for sse connection", { actorId });
+      invariant10(actorId, "Missing actor ID");
+      logger8().debug("opening sse connection", {
+        actorId,
+        encoding: encodingKind
+      });
+      const EventSourceClass = await importEventSource();
+      const eventSource = new EventSourceClass("http://actor/connect/sse", {
+        fetch: (input, init) => {
+          return fetch(input, {
+            ...init,
+            headers: {
+              ...init?.headers,
+              "User-Agent": httpUserAgent(),
+              [HEADER_ENCODING]: encodingKind,
+              ...params !== void 0 ? { [HEADER_CONN_PARAMS]: JSON.stringify(params) } : {},
+              [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
+            }
+          });
+        }
+      });
+      return eventSource;
+    },
+    sendHttpMessage: async (c, actorId, encoding, connectionId, connectionToken, message) => {
+      logger8().debug("sending http message", { actorId, connectionId });
+      await sendHttpRequest({
+        url: "http://actor/connections/message",
+        method: "POST",
+        headers: {
+          [HEADER_ENCODING]: encoding,
+          [HEADER_CONN_ID]: connectionId,
+          [HEADER_CONN_TOKEN]: connectionToken,
+          [HEADER_EXPOSE_INTERNAL_ERROR]: "true"
+        },
+        body: message,
+        encoding,
+        skipParseResponse: true,
+        customFetch: managerDriver.sendRequest.bind(managerDriver, actorId),
+        requestVersionedDataHandler: TO_SERVER_VERSIONED,
+        responseVersionedDataHandler: TO_CLIENT_VERSIONED
+      });
+    },
+    rawHttpRequest: async (c, actorQuery, encoding, params, path3, init) => {
+      try {
+        const { actorId } = await queryActor(c, actorQuery, managerDriver);
+        logger8().debug("found actor for raw http", { actorId });
+        invariant10(actorId, "Missing actor ID");
+        const normalizedPath = path3.startsWith("/") ? path3.slice(1) : path3;
+        const url = new URL(`http://actor/raw/http/${normalizedPath}`);
+        const proxyRequestHeaders = new Headers(init.headers);
+        if (params) {
+          proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));
+        }
+        const proxyRequest = new Request(url, {
+          ...init,
+          headers: proxyRequestHeaders
+        });
+        return await managerDriver.sendRequest(actorId, proxyRequest);
+      } catch (err) {
+        const { code, message, metadata } = deconstructError(
+          err,
+          logger8(),
+          {},
+          true
+        );
+        throw new ActorError2(code, message, metadata);
+      }
+    },
+    rawWebSocket: async (c, actorQuery, encoding, params, path3, protocols) => {
+      const { actorId } = await queryActor(c, actorQuery, managerDriver);
+      logger8().debug("found actor for action", { actorId });
+      invariant10(actorId, "Missing actor ID");
+      const normalizedPath = path3.startsWith("/") ? path3.slice(1) : path3;
+      logger8().debug("opening websocket", {
+        actorId,
+        encoding,
+        path: normalizedPath
+      });
+      const ws = await managerDriver.openWebSocket(
+        `${PATH_RAW_WEBSOCKET_PREFIX}${normalizedPath}`,
+        actorId,
+        encoding,
+        params
+      );
+      return ws;
+    }
+  };
+  return driver;
+}
+async function queryActor(c, query, driver) {
+  logger8().debug("querying actor", { query });
+  let actorOutput;
+  if ("getForId" in query) {
+    const output = await driver.getForId({
+      c,
+      name: query.getForId.name,
+      actorId: query.getForId.actorId
+    });
+    if (!output) throw new ActorNotFound(query.getForId.actorId);
+    actorOutput = output;
+  } else if ("getForKey" in query) {
+    const existingActor = await driver.getWithKey({
+      c,
+      name: query.getForKey.name,
+      key: query.getForKey.key
+    });
+    if (!existingActor) {
+      throw new ActorNotFound(
+        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
+      );
+    }
+    actorOutput = existingActor;
+  } else if ("getOrCreateForKey" in query) {
+    const getOrCreateOutput = await driver.getOrCreateWithKey({
+      c,
+      name: query.getOrCreateForKey.name,
+      key: query.getOrCreateForKey.key,
+      input: query.getOrCreateForKey.input,
+      region: query.getOrCreateForKey.region
+    });
+    actorOutput = {
+      actorId: getOrCreateOutput.actorId
+    };
+  } else if ("create" in query) {
+    const createOutput = await driver.createActor({
+      c,
+      name: query.create.name,
+      key: query.create.key,
+      input: query.create.input,
+      region: query.create.region
+    });
+    actorOutput = {
+      actorId: createOutput.actorId
+    };
+  } else {
+    throw new InvalidRequest("Invalid query format");
+  }
+  logger8().debug("actor query result", {
+    actorId: actorOutput.actorId
+  });
+  return { actorId: actorOutput.actorId };
+}
+
+// src/inspector/manager.ts
+import { sValidator as sValidator2 } from "@hono/standard-validator";
+import { Hono as Hono3 } from "hono";
+function createManagerInspectorRouter() {
+  return new Hono3().get("/ping", (c) => {
+    return c.json({ message: "pong" }, 200);
+  }).get("/actors", async (c) => {
+    const limit = Number.parseInt(c.req.query("limit") ?? "") || void 0;
+    const cursor = c.req.query("cursor") || void 0;
+    if (!limit || limit && limit <= 0) {
+      return c.json("Invalid limit", 400);
+    }
+    try {
+      const actors = await c.var.inspector.accessors.getAllActors({
+        limit,
+        cursor
+      });
+      return c.json(actors, 200);
+    } catch (error) {
+      inspectorLogger().error("Failed to fetch actors", error);
+      return c.json("Failed to fetch actors", 500);
+    }
+  }).post("/actors", sValidator2("json", CreateActorSchema), async (c) => {
+    const actor2 = await c.var.inspector.accessors.createActor(
+      c.req.valid("json")
+    );
+    return c.json(actor2, 201);
+  }).get("/builds", async (c) => {
+    const builds = await c.var.inspector.accessors.getBuilds();
+    return c.json(builds, 200);
+  }).get("/actor/:id", async (c) => {
+    const id = c.req.param("id");
+    const actor2 = await c.var.inspector.accessors.getActorById(id);
+    if (!actor2) {
+      return c.json({ error: "Actor not found" }, 404);
+    }
+    return c.json(actor2, 200);
+  }).get("/bootstrap", async (c) => {
+    const actors = await c.var.inspector.accessors.getAllActors({
+      limit: 10
+    });
+    return c.json({ actors }, 200);
+  });
+}
+var ManagerInspector = class {
+  accessors;
+  constructor(accessors) {
+    this.accessors = accessors();
+    inspectorLogger().debug("Manager Inspector enabled and ready");
+  }
+};
+
+// src/drivers/file-system/manager.ts
+var FileSystemManagerDriver = class {
+  #registryConfig;
+  #runConfig;
+  #state;
+  #driverConfig;
+  #actorDriver;
+  #actorRouter;
+  inspector;
+  constructor(registryConfig, runConfig, state, driverConfig) {
+    this.#registryConfig = registryConfig;
+    this.#runConfig = runConfig;
+    this.#state = state;
+    this.#driverConfig = driverConfig;
+    if (runConfig.inspector.enabled) {
+      let transformActor2 = function(actorState) {
+        return {
+          id: actorState.actorId,
+          name: actorState.name,
+          key: actorState.key,
+          startedAt,
+          createdAt: new Date(Number(actorState.createdAt)).toISOString(),
+          features: [
+            "state" /* State */,
+            "connections" /* Connections */,
+            "console" /* Console */,
+            "events-monitoring" /* EventsMonitoring */,
+            "database" /* Database */
+          ]
+        };
+      };
+      var transformActor = transformActor2;
+      if (!this.#runConfig.inspector.token()) {
+        this.#runConfig.inspector.token = () => this.#state.getOrCreateInspectorAccessToken();
+      }
+      const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.inspector = new ManagerInspector(() => {
+        return {
+          getAllActors: async ({ cursor, limit }) => {
+            const itr = this.#state.getActorsIterator({ cursor });
+            const actors = [];
+            for await (const actor2 of itr) {
+              actors.push(transformActor2(actor2));
+              if (limit && actors.length >= limit) {
+                break;
+              }
+            }
+            return actors;
+          },
+          getActorById: async (id) => {
+            try {
+              const result = await this.#state.loadActorStateOrError(id);
+              return transformActor2(result);
+            } catch {
+              return null;
+            }
+          },
+          getBuilds: async () => {
+            return Object.keys(this.#registryConfig.use).map((name) => ({
+              name
+            }));
+          },
+          createActor: async (input) => {
+            const { actorId } = await this.createActor(input);
+            try {
+              const result = await this.#state.loadActorStateOrError(actorId);
+              return transformActor2(result);
+            } catch {
+              return null;
+            }
+          }
+        };
+      });
+    }
+    const inlineClient = createClientWithDriver(createInlineClientDriver(this));
+    this.#actorDriver = this.#driverConfig.actor(
+      registryConfig,
+      runConfig,
+      this,
+      inlineClient
+    );
+    this.#actorRouter = createActorRouter(this.#runConfig, this.#actorDriver);
+  }
+  async sendRequest(actorId, actorRequest) {
+    return await this.#actorRouter.fetch(actorRequest, {
+      actorId
+    });
+  }
+  async openWebSocket(path3, actorId, encoding, params) {
+    if (path3 === PATH_CONNECT_WEBSOCKET) {
+      const wsHandler = await handleWebSocketConnect(
+        void 0,
+        this.#runConfig,
+        this.#actorDriver,
+        actorId,
+        encoding,
+        params,
+        void 0
+      );
+      return new InlineWebSocketAdapter2(wsHandler);
+    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+      const wsHandler = await handleRawWebSocketHandler(
+        void 0,
+        path3,
+        this.#actorDriver,
+        actorId,
+        void 0
+      );
+      return new InlineWebSocketAdapter2(wsHandler);
+    } else {
+      throw new Error(`Unreachable path: ${path3}`);
+    }
+  }
+  async proxyRequest(c, actorRequest, actorId) {
+    return await this.#actorRouter.fetch(actorRequest, {
+      actorId
+    });
+  }
+  async proxyWebSocket(c, path3, actorId, encoding, connParams, authData) {
+    const upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();
+    invariant11(upgradeWebSocket, "missing getUpgradeWebSocket");
+    if (path3 === PATH_CONNECT_WEBSOCKET) {
+      const wsHandler = await handleWebSocketConnect(
+        c.req.raw,
+        this.#runConfig,
+        this.#actorDriver,
+        actorId,
+        encoding,
+        connParams,
+        authData
+      );
+      return upgradeWebSocket(() => wsHandler)(c, noopNext());
+    } else if (path3.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {
+      const wsHandler = await handleRawWebSocketHandler(
+        c.req.raw,
+        path3,
+        this.#actorDriver,
+        actorId,
+        authData
+      );
+      return upgradeWebSocket(() => wsHandler)(c, noopNext());
+    } else {
+      throw new Error(`Unreachable path: ${path3}`);
+    }
+  }
+  async getForId({ actorId }) {
+    const actor2 = await this.#state.loadActor(actorId);
+    if (!actor2.state) {
+      return void 0;
+    }
+    try {
+      return {
+        actorId,
+        name: actor2.state.name,
+        key: actor2.state.key
+      };
+    } catch (error) {
+      logger7().error("failed to read actor state", { actorId, error });
+      return void 0;
+    }
+  }
+  async getWithKey({
+    name,
+    key
+  }) {
+    const actorId = generateActorId(name, key);
+    const actor2 = await this.#state.loadActor(actorId);
+    if (actor2.state) {
+      return {
+        actorId,
+        name,
+        key
+      };
+    }
+    return void 0;
+  }
+  async getOrCreateWithKey(input) {
+    const actorId = generateActorId(input.name, input.key);
+    const actorEntry = await this.#state.loadOrCreateActor(
+      actorId,
+      input.name,
+      input.key,
+      input.input
+    );
+    invariant11(actorEntry.state, "must have state");
+    return {
+      actorId: actorEntry.state.actorId,
+      name: actorEntry.state.name,
+      key: actorEntry.state.key
+    };
+  }
+  async createActor({ name, key, input }) {
+    const actorId = generateActorId(name, key);
+    await this.#state.createActor(actorId, name, key, input);
+    return {
+      actorId,
+      name,
+      key
+    };
+  }
+  extraStartupLog() {
+    return {
+      instances: this.#state.actorCountOnStartup,
+      data: this.#state.storagePath
+    };
+  }
+};
+
+// src/drivers/file-system/mod.ts
+function createFileSystemOrMemoryDriver(persist = true, customPath) {
+  const state = new FileSystemGlobalState(persist, customPath);
+  const driverConfig = {
+    name: persist ? "file-system" : "memory",
+    manager: (registryConfig, runConfig) => new FileSystemManagerDriver(
+      registryConfig,
+      runConfig,
+      state,
+      driverConfig
+    ),
+    actor: (registryConfig, runConfig, managerDriver, inlineClient) => {
+      const actorDriver = new FileSystemActorDriver(
+        registryConfig,
+        runConfig,
+        managerDriver,
+        inlineClient,
+        state
+      );
+      state.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);
+      return actorDriver;
+    }
+  };
+  return driverConfig;
+}
+
+// src/drivers/default.ts
+function chooseDefaultDriver(runConfig) {
+  const engineEndpoint = runConfig.engine || getEnvUniversal("RIVET_ENGINE");
+  if (engineEndpoint && runConfig.driver) {
+    throw new UserError(
+      "Cannot specify both 'engine' and 'driver' in configuration"
+    );
+  }
+  if (runConfig.driver) {
+    return runConfig.driver;
+  }
+  if (engineEndpoint) {
+    logger().debug("using rivet engine driver", { endpoint: engineEndpoint });
+    return createEngineDriver({ endpoint: engineEndpoint });
+  }
+  logger().debug("using default file system driver");
+  return createFileSystemOrMemoryDriver(true);
+}
+
+// src/manager/router.ts
+import { createRoute, OpenAPIHono } from "@hono/zod-openapi";
+import * as cbor13 from "cbor-x";
+import {
+  Hono as Hono4
+} from "hono";
+import { cors } from "hono/cors";
+import { streamSSE as streamSSE3 } from "hono/streaming";
+import invariant12 from "invariant";
+import { z as z10 } from "zod";
+
+// src/manager/auth.ts
+function getIntentsFromQuery(query) {
+  const intents = /* @__PURE__ */ new Set();
+  if ("getForId" in query) {
+    intents.add("get");
+  } else if ("getForKey" in query) {
+    intents.add("get");
+  } else if ("getOrCreateForKey" in query) {
+    intents.add("get");
+    intents.add("create");
+  } else if ("create" in query) {
+    intents.add("create");
+  }
+  return intents;
+}
+async function getActorNameFromQuery(c, driver, query) {
+  if ("getForId" in query) {
+    const output = await driver.getForId({
+      c,
+      name: query.getForId.name,
+      actorId: query.getForId.actorId
+    });
+    if (!output) throw new ActorNotFound(query.getForId.actorId);
+    return output.name;
+  } else if ("getForKey" in query) {
+    return query.getForKey.name;
+  } else if ("getOrCreateForKey" in query) {
+    return query.getOrCreateForKey.name;
+  } else if ("create" in query) {
+    return query.create.name;
+  } else {
+    throw new InvalidRequest("Invalid query format");
+  }
+}
+async function authenticateRequest(c, actorDefinition, intents, params) {
+  if (!("onAuth" in actorDefinition.config)) {
+    throw new Forbidden(
+      "Actor requires authentication but no onAuth handler is defined (https://rivet.gg/docs/actors/authentication/). Provide an empty handler to disable auth: `onAuth: () => {}`"
+    );
+  }
+  try {
+    const dataOrPromise = actorDefinition.config.onAuth(
+      {
+        request: c.req.raw,
+        intents
+      },
+      params
+    );
+    if (dataOrPromise instanceof Promise) {
+      return await dataOrPromise;
+    } else {
+      return dataOrPromise;
+    }
+  } catch (error) {
+    logger2().info("authentication error", { error: stringifyError(error) });
+    throw error;
+  }
+}
+async function authenticateEndpoint(c, driver, registryConfig, query, additionalIntents, params) {
+  const intents = getIntentsFromQuery(query);
+  for (const intent of additionalIntents) {
+    intents.add(intent);
+  }
+  const actorName = await getActorNameFromQuery(c, driver, query);
+  const actorDefinition = registryConfig.use[actorName];
+  if (!actorDefinition) {
+    throw new ActorNotFound(actorName);
+  }
+  return await authenticateRequest(c, actorDefinition, intents, params);
+}
+
+// src/manager/router.ts
+function parseWebSocketProtocols(protocols) {
+  let queryRaw;
+  let encodingRaw;
+  let connParamsRaw;
+  if (protocols) {
+    const protocolList = protocols.split(",").map((p) => p.trim());
+    for (const protocol of protocolList) {
+      if (protocol.startsWith("query.")) {
+        queryRaw = decodeURIComponent(protocol.substring("query.".length));
+      } else if (protocol.startsWith("encoding.")) {
+        encodingRaw = protocol.substring("encoding.".length);
+      } else if (protocol.startsWith("conn_params.")) {
+        connParamsRaw = decodeURIComponent(
+          protocol.substring("conn_params.".length)
+        );
+      }
+    }
+  }
+  return { queryRaw, encodingRaw, connParamsRaw };
+}
+var OPENAPI_ENCODING = z10.string().openapi({
+  description: "The encoding format to use for the response (json, cbor)",
+  example: "json"
+});
+var OPENAPI_ACTOR_QUERY = z10.string().openapi({
+  description: "Actor query information"
+});
+var OPENAPI_CONN_PARAMS = z10.string().openapi({
+  description: "Connection parameters"
+});
+var OPENAPI_ACTOR_ID = z10.string().openapi({
+  description: "Actor ID (used in some endpoints)",
+  example: "actor-123456"
+});
+var OPENAPI_CONN_ID = z10.string().openapi({
+  description: "Connection ID",
+  example: "conn-123456"
+});
+var OPENAPI_CONN_TOKEN = z10.string().openapi({
+  description: "Connection token"
+});
+function buildOpenApiResponses(schema, validateBody) {
+  return {
+    200: {
+      description: "Success",
+      content: validateBody ? {
+        "application/json": {
+          schema
+        }
+      } : {}
+    },
+    400: {
+      description: "User error"
+    },
+    500: {
+      description: "Internal error"
+    }
+  };
+}
+function createManagerRouter(registryConfig, runConfig, inlineClientDriver, managerDriver, validateBody) {
+  const router = new OpenAPIHono({ strict: false }).basePath(
+    runConfig.basePath
+  );
+  router.use("*", loggerMiddleware(logger2()));
+  if (runConfig.cors || runConfig.inspector?.cors) {
+    router.use("*", async (c, next) => {
+      const path3 = c.req.path;
+      if (path3.endsWith("/actors/connect/websocket") || path3.includes("/actors/raw/websocket/") || // inspectors implement their own CORS handling
+      path3.endsWith("/inspect") || path3.endsWith("/actors/inspect")) {
+        return next();
+      }
+      return cors({
+        ...runConfig.cors ?? {},
+        ...runConfig.inspector?.cors ?? {},
+        origin: (origin, c2) => {
+          const inspectorOrigin = runConfig.inspector?.cors?.origin;
+          if (inspectorOrigin !== void 0) {
+            if (typeof inspectorOrigin === "function") {
+              const allowed = inspectorOrigin(origin, c2);
+              if (allowed) return allowed;
+            } else if (Array.isArray(inspectorOrigin)) {
+              return inspectorOrigin.includes(origin) ? origin : void 0;
+            } else {
+              return inspectorOrigin;
+            }
+          }
+          if (runConfig.cors?.origin !== void 0) {
+            if (typeof runConfig.cors.origin === "function") {
+              const allowed = runConfig.cors.origin(origin, c2);
+              if (allowed) return allowed;
+            } else {
+              return runConfig.cors.origin;
+            }
+          }
+          return null;
+        },
+        allowMethods: (origin, c2) => {
+          const inspectorMethods = runConfig.inspector?.cors?.allowMethods;
+          if (inspectorMethods) {
+            if (typeof inspectorMethods === "function") {
+              return inspectorMethods(origin, c2);
+            }
+            return inspectorMethods;
+          }
+          if (runConfig.cors?.allowMethods) {
+            if (typeof runConfig.cors.allowMethods === "function") {
+              return runConfig.cors.allowMethods(origin, c2);
+            }
+            return runConfig.cors.allowMethods;
+          }
+          return [];
+        },
+        allowHeaders: [
+          ...runConfig.cors?.allowHeaders ?? [],
+          ...runConfig.inspector?.cors?.allowHeaders ?? [],
+          ...ALLOWED_PUBLIC_HEADERS,
+          "Content-Type",
+          "User-Agent"
+        ],
+        credentials: runConfig.cors?.credentials ?? runConfig.inspector?.cors?.credentials ?? true
+      })(c, next);
+    });
+  }
+  router.get("/", (c) => {
+    return c.text(
+      "This is an RivetKit registry.\n\nLearn more at https://rivetkit.org"
+    );
+  });
+  {
+    const ResolveQuerySchema = z10.object({
+      query: z10.any().openapi({
+        example: { getForId: { actorId: "actor-123" } }
+      })
+    }).openapi("ResolveQuery");
+    const ResolveResponseSchema = z10.object({
+      i: z10.string().openapi({
+        example: "actor-123"
+      })
+    }).openapi("ResolveResponse");
+    const resolveRoute = createRoute({
+      method: "post",
+      path: "/actors/resolve",
+      request: {
+        body: {
+          content: validateBody ? {
+            "application/json": {
+              schema: ResolveQuerySchema
+            }
+          } : {}
+        },
+        headers: z10.object({
+          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY
+        })
+      },
+      responses: buildOpenApiResponses(ResolveResponseSchema, validateBody)
+    });
+    router.openapi(
+      resolveRoute,
+      (c) => handleResolveRequest(c, registryConfig, managerDriver)
+    );
+  }
+  {
+    router.use("*", (c, next) => {
+      if (c.req.path.endsWith("/actors/connect/websocket")) {
+        return handleWebSocketConnectRequest(
+          c,
+          registryConfig,
+          runConfig,
+          managerDriver
+        );
+      }
+      return next();
+    });
+    const wsRoute = createRoute({
+      method: "get",
+      path: "/actors/connect/websocket",
+      responses: {
+        101: {
+          description: "WebSocket upgrade"
+        }
+      }
+    });
+    router.openapi(wsRoute, () => {
+      throw new Error("Should be unreachable");
+    });
+  }
+  {
+    const sseRoute = createRoute({
+      method: "get",
+      path: "/actors/connect/sse",
+      request: {
+        headers: z10.object({
+          [HEADER_ENCODING]: OPENAPI_ENCODING,
+          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY,
+          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
+        })
+      },
+      responses: {
+        200: {
+          description: "SSE stream",
+          content: {
+            "text/event-stream": {
+              schema: z10.unknown()
+            }
+          }
+        }
+      }
+    });
+    router.openapi(
+      sseRoute,
+      (c) => handleSseConnectRequest(c, registryConfig, runConfig, managerDriver)
+    );
+  }
+  {
+    const ActionParamsSchema = z10.object({
+      action: z10.string().openapi({
+        param: {
+          name: "action",
+          in: "path"
+        },
+        example: "myAction"
+      })
+    }).openapi("ActionParams");
+    const ActionRequestSchema = z10.object({
+      query: z10.any().openapi({
+        example: { getForId: { actorId: "actor-123" } }
+      }),
+      body: z10.any().optional().openapi({
+        example: { param1: "value1", param2: 123 }
+      })
+    }).openapi("ActionRequest");
+    const ActionResponseSchema = z10.any().openapi("ActionResponse");
+    const actionRoute = createRoute({
+      method: "post",
+      path: "/actors/actions/{action}",
+      request: {
+        params: ActionParamsSchema,
+        body: {
+          content: validateBody ? {
+            "application/json": {
+              schema: ActionRequestSchema
+            }
+          } : {}
+        },
+        headers: z10.object({
+          [HEADER_ENCODING]: OPENAPI_ENCODING,
+          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
+        })
+      },
+      responses: buildOpenApiResponses(ActionResponseSchema, validateBody)
+    });
+    router.openapi(
+      actionRoute,
+      (c) => handleActionRequest(c, registryConfig, runConfig, managerDriver)
+    );
+  }
+  {
+    const ConnectionMessageRequestSchema = z10.object({
+      message: z10.any().openapi({
+        example: { type: "message", content: "Hello, actor!" }
+      })
+    }).openapi("ConnectionMessageRequest");
+    const ConnectionMessageResponseSchema = z10.any().openapi("ConnectionMessageResponse");
+    const messageRoute = createRoute({
+      method: "post",
+      path: "/actors/message",
+      request: {
+        body: {
+          content: validateBody ? {
+            "application/json": {
+              schema: ConnectionMessageRequestSchema
+            }
+          } : {}
+        },
+        headers: z10.object({
+          [HEADER_ACTOR_ID]: OPENAPI_ACTOR_ID,
+          [HEADER_CONN_ID]: OPENAPI_CONN_ID,
+          [HEADER_ENCODING]: OPENAPI_ENCODING,
+          [HEADER_CONN_TOKEN]: OPENAPI_CONN_TOKEN
+        })
+      },
+      responses: buildOpenApiResponses(
+        ConnectionMessageResponseSchema,
+        validateBody
+      )
+    });
+    router.openapi(
+      messageRoute,
+      (c) => handleMessageRequest(c, registryConfig, runConfig, managerDriver)
+    );
+  }
+  {
+    const RawHttpRequestBodySchema = z10.any().optional().openapi({
+      description: "Raw request body (can be any content type)"
+    });
+    const RawHttpResponseSchema = z10.any().openapi({
+      description: "Raw response from actor's onFetch handler"
+    });
+    const rawHttpRouteConfig = {
+      path: "/actors/raw/http/*",
+      request: {
+        headers: z10.object({
+          [HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY.optional(),
+          [HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional()
+        }),
+        body: {
+          content: {
+            "*/*": {
+              schema: RawHttpRequestBodySchema
+            }
+          }
+        }
+      },
+      responses: {
+        200: {
+          description: "Success - response from actor's onFetch handler",
+          content: {
+            "*/*": {
+              schema: RawHttpResponseSchema
+            }
+          }
+        },
+        404: {
+          description: "Actor does not have an onFetch handler"
+        },
+        500: {
+          description: "Internal server error or invalid response from actor"
+        }
+      }
+    };
+    const httpMethods = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "head",
+      "options"
+    ];
+    for (const method of httpMethods) {
+      const route = createRoute({
+        method,
+        ...rawHttpRouteConfig
+      });
+      router.openapi(route, async (c) => {
+        return handleRawHttpRequest(
+          c,
+          registryConfig,
+          runConfig,
+          managerDriver
+        );
+      });
+    }
+  }
+  {
+    router.use("*", async (c, next) => {
+      if (c.req.path.includes("/raw/websocket/")) {
+        return handleRawWebSocketRequest(
+          c,
+          registryConfig,
+          runConfig,
+          managerDriver
+        );
+      }
+      return next();
+    });
+    const rawWebSocketRoute = createRoute({
+      method: "get",
+      path: "/actors/raw/websocket/*",
+      request: {},
+      responses: {
+        101: {
+          description: "WebSocket upgrade successful"
+        },
+        400: {
+          description: "WebSockets not enabled or invalid request"
+        },
+        404: {
+          description: "Actor does not have an onWebSocket handler"
+        }
+      }
+    });
+    router.openapi(rawWebSocketRoute, () => {
+      throw new Error("Should be unreachable");
+    });
+  }
+  if (runConfig.inspector?.enabled) {
+    router.route(
+      "/actors/inspect",
+      new Hono4().use(
+        cors(runConfig.inspector.cors),
+        secureInspector(runConfig),
+        universalActorProxy({
+          registryConfig,
+          runConfig,
+          driver: managerDriver
+        })
+      ).all(
+        "/",
+        (c) => (
+          // this should be handled by the actor proxy, but just in case
+          c.text("Unreachable.", 404)
+        )
+      )
+    );
+    router.route(
+      "/inspect",
+      new Hono4().use(
+        cors(runConfig.inspector.cors),
+        secureInspector(runConfig),
+        async (c, next) => {
+          const inspector = managerDriver.inspector;
+          invariant12(inspector, "inspector not supported on this platform");
+          c.set("inspector", inspector);
+          await next();
+        }
+      ).route("/", createManagerInspectorRouter())
+    );
+  }
+  if (registryConfig.test.enabled) {
+    router.post(".test/inline-driver/call", async (c) => {
+      const buffer = await c.req.arrayBuffer();
+      const { encoding, transport, method, args } = cbor13.decode(new Uint8Array(buffer));
+      logger2().debug("received inline request", {
+        encoding,
+        transport,
+        method,
+        args
+      });
+      let response;
+      try {
+        const output = await inlineClientDriver[method](
+          ...args
+        );
+        response = { ok: output };
+      } catch (rawErr) {
+        const err = deconstructError(rawErr, logger2(), {}, true);
+        response = { err };
+      }
+      return c.body(cbor13.encode(response));
+    });
+    router.get(".test/inline-driver/connect-websocket", async (c) => {
+      const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+      invariant12(upgradeWebSocket, "websockets not supported on this platform");
+      return upgradeWebSocket(async (c2) => {
+        const {
+          actorQuery: actorQueryRaw,
+          params: paramsRaw,
+          encodingKind
+        } = c2.req.query();
+        const actorQuery = JSON.parse(actorQueryRaw);
+        const params = paramsRaw !== void 0 ? JSON.parse(paramsRaw) : void 0;
+        logger2().debug("received test inline driver websocket", {
+          actorQuery,
+          params,
+          encodingKind
+        });
+        const clientWsPromise = inlineClientDriver.connectWebSocket(
+          void 0,
+          actorQuery,
+          encodingKind,
+          params,
+          void 0
+        );
+        return await createTestWebSocketProxy(clientWsPromise, "standard");
+      })(c, noopNext());
+    });
+    router.get(".test/inline-driver/raw-websocket", async (c) => {
+      const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+      invariant12(upgradeWebSocket, "websockets not supported on this platform");
+      return upgradeWebSocket(async (c2) => {
+        const {
+          actorQuery: actorQueryRaw,
+          params: paramsRaw,
+          encodingKind,
+          path: path3,
+          protocols: protocolsRaw
+        } = c2.req.query();
+        const actorQuery = JSON.parse(actorQueryRaw);
+        const params = paramsRaw !== void 0 ? JSON.parse(paramsRaw) : void 0;
+        const protocols = protocolsRaw !== void 0 ? JSON.parse(protocolsRaw) : void 0;
+        logger2().debug("received test inline driver raw websocket", {
+          actorQuery,
+          params,
+          encodingKind,
+          path: path3,
+          protocols
+        });
+        logger2().debug("calling inlineClientDriver.rawWebSocket");
+        const clientWsPromise = inlineClientDriver.rawWebSocket(
+          void 0,
+          actorQuery,
+          encodingKind,
+          params,
+          path3,
+          protocols,
+          void 0
+        );
+        logger2().debug("calling createTestWebSocketProxy");
+        return await createTestWebSocketProxy(clientWsPromise, "raw");
+      })(c, noopNext());
+    });
+    router.all(".test/inline-driver/raw-http/*", async (c) => {
+      const actorQueryHeader = c.req.header(HEADER_ACTOR_QUERY);
+      const paramsHeader = c.req.header(HEADER_CONN_PARAMS);
+      const encodingHeader = c.req.header(HEADER_ENCODING);
+      if (!actorQueryHeader || !encodingHeader) {
+        return c.text("Missing required headers", 400);
+      }
+      const actorQuery = JSON.parse(actorQueryHeader);
+      const params = paramsHeader ? JSON.parse(paramsHeader) : void 0;
+      const encoding = encodingHeader;
+      const fullPath = c.req.path;
+      const pathOnly = fullPath.split("/.test/inline-driver/raw-http/")[1] || "";
+      const url = new URL(c.req.url);
+      const pathWithQuery = pathOnly + url.search;
+      logger2().debug("received test inline driver raw http", {
+        actorQuery,
+        params,
+        encoding,
+        path: pathWithQuery,
+        method: c.req.method
+      });
+      try {
+        const response = await inlineClientDriver.rawHttpRequest(
+          void 0,
+          actorQuery,
+          encoding,
+          params,
+          pathWithQuery,
+          {
+            method: c.req.method,
+            headers: c.req.raw.headers,
+            body: c.req.raw.body
+          },
+          void 0
+        );
+        return response;
+      } catch (error) {
+        logger2().error("error in test inline raw http", {
+          error: stringifyError(error)
+        });
+        const err = deconstructError(error, logger2(), {}, true);
+        return c.json(
+          {
+            error: {
+              code: err.code,
+              message: err.message,
+              metadata: err.metadata
+            }
+          },
+          err.statusCode
+        );
+      }
+    });
+  }
+  managerDriver.modifyManagerRouter?.(
+    registryConfig,
+    router
+  );
+  const mountedRouter = new Hono4();
+  mountedRouter.route("/", router);
+  mountedRouter.route("/registry", router);
+  mountedRouter.notFound(handleRouteNotFound);
+  mountedRouter.onError(handleRouteError.bind(void 0, {}));
+  return { router: mountedRouter, openapi: router };
+}
+async function queryActor2(c, query, driver) {
+  logger2().debug("querying actor", { query });
+  let actorOutput;
+  if ("getForId" in query) {
+    const output = await driver.getForId({
+      c,
+      name: query.getForId.name,
+      actorId: query.getForId.actorId
+    });
+    if (!output) throw new ActorNotFound(query.getForId.actorId);
+    actorOutput = output;
+  } else if ("getForKey" in query) {
+    const existingActor = await driver.getWithKey({
+      c,
+      name: query.getForKey.name,
+      key: query.getForKey.key
+    });
+    if (!existingActor) {
+      throw new ActorNotFound(
+        `${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`
+      );
+    }
+    actorOutput = existingActor;
+  } else if ("getOrCreateForKey" in query) {
+    const getOrCreateOutput = await driver.getOrCreateWithKey({
+      c,
+      name: query.getOrCreateForKey.name,
+      key: query.getOrCreateForKey.key,
+      input: query.getOrCreateForKey.input,
+      region: query.getOrCreateForKey.region
+    });
+    actorOutput = {
+      actorId: getOrCreateOutput.actorId
+    };
+  } else if ("create" in query) {
+    const createOutput = await driver.createActor({
+      c,
+      name: query.create.name,
+      key: query.create.key,
+      input: query.create.input,
+      region: query.create.region
+    });
+    actorOutput = {
+      actorId: createOutput.actorId
+    };
+  } else {
+    throw new InvalidRequest("Invalid query format");
+  }
+  logger2().debug("actor query result", {
+    actorId: actorOutput.actorId
+  });
+  return { actorId: actorOutput.actorId };
+}
+async function createTestWebSocketProxy(clientWsPromise, connectionType) {
+  let clientWs = null;
+  try {
+    logger2().debug("awaiting client websocket promise");
+    const ws = await clientWsPromise;
+    clientWs = ws;
+    logger2().debug("client websocket promise resolved", {
+      constructor: ws?.constructor.name
+    });
+    await new Promise((resolve, reject) => {
+      const onOpen = () => {
+        logger2().debug("test websocket connection opened");
+        resolve();
+      };
+      const onError = (error) => {
+        logger2().error("test websocket connection failed", { error });
+        reject(
+          new Error(`Failed to open WebSocket: ${error.message || error}`)
+        );
+      };
+      ws.addEventListener("open", onOpen);
+      ws.addEventListener("error", onError);
+    });
+  } catch (error) {
+    logger2().error(
+      `failed to establish client ${connectionType} websocket connection`,
+      { error }
+    );
+    return {
+      onOpen: (_evt, serverWs) => {
+        serverWs.close(1011, "Failed to establish connection");
+      },
+      onMessage: () => {
+      },
+      onError: () => {
+      },
+      onClose: () => {
+      }
+    };
+  }
+  return {
+    onOpen: (_evt, serverWs) => {
+      logger2().debug(`test ${connectionType} websocket connection opened`);
+      logger2().debug("clientWs info", {
+        constructor: clientWs.constructor.name,
+        hasAddEventListener: typeof clientWs.addEventListener === "function",
+        readyState: clientWs.readyState
+      });
+      clientWs.addEventListener("message", (clientEvt) => {
+        logger2().debug(
+          `test ${connectionType} websocket connection message from client`,
+          {
+            dataType: typeof clientEvt.data,
+            isBlob: clientEvt.data instanceof Blob,
+            isArrayBuffer: clientEvt.data instanceof ArrayBuffer,
+            dataConstructor: clientEvt.data?.constructor?.name,
+            dataStr: typeof clientEvt.data === "string" ? clientEvt.data.substring(0, 100) : void 0
+          }
+        );
+        if (serverWs.readyState === 1) {
+          if (clientEvt.data instanceof Blob) {
+            clientEvt.data.arrayBuffer().then((buffer) => {
+              logger2().debug(
+                "converted client blob to arraybuffer, sending to server",
+                {
+                  bufferSize: buffer.byteLength
+                }
+              );
+              serverWs.send(buffer);
+            }).catch((error) => {
+              logger2().error("failed to convert blob to arraybuffer", {
+                error
+              });
+            });
+          } else {
+            logger2().debug("sending client data directly to server", {
+              dataType: typeof clientEvt.data,
+              dataLength: typeof clientEvt.data === "string" ? clientEvt.data.length : void 0
+            });
+            serverWs.send(clientEvt.data);
+          }
+        }
+      });
+      clientWs.addEventListener("close", (clientEvt) => {
+        logger2().debug(`test ${connectionType} websocket connection closed`);
+        if (serverWs.readyState !== 3) {
+          serverWs.close(clientEvt.code, clientEvt.reason);
+        }
+      });
+      clientWs.addEventListener("error", () => {
+        logger2().debug(`test ${connectionType} websocket connection error`);
+        if (serverWs.readyState !== 3) {
+          serverWs.close(1011, "Error in client websocket");
+        }
+      });
+    },
+    onMessage: (evt) => {
+      logger2().debug("received message from server", {
+        dataType: typeof evt.data,
+        isBlob: evt.data instanceof Blob,
+        isArrayBuffer: evt.data instanceof ArrayBuffer,
+        dataConstructor: evt.data?.constructor?.name,
+        dataStr: typeof evt.data === "string" ? evt.data.substring(0, 100) : void 0
+      });
+      if (clientWs.readyState === 1) {
+        if (evt.data instanceof Blob) {
+          evt.data.arrayBuffer().then((buffer) => {
+            logger2().debug("converted blob to arraybuffer, sending", {
+              bufferSize: buffer.byteLength
+            });
+            clientWs.send(buffer);
+          }).catch((error) => {
+            logger2().error("failed to convert blob to arraybuffer", {
+              error
+            });
+          });
+        } else {
+          logger2().debug("sending data directly", {
+            dataType: typeof evt.data,
+            dataLength: typeof evt.data === "string" ? evt.data.length : void 0
+          });
+          clientWs.send(evt.data);
+        }
+      }
+    },
+    onClose: (event, serverWs) => {
+      logger2().debug(`server ${connectionType} websocket closed`, {
+        wasClean: event.wasClean,
+        code: event.code,
+        reason: event.reason
+      });
+      serverWs.close(1e3, "hack_force_close");
+      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
+        clientWs.close(1e3, event.reason);
+      }
+    },
+    onError: (error) => {
+      logger2().error(`error in server ${connectionType} websocket`, { error });
+      if (clientWs && clientWs.readyState !== clientWs.CLOSED && clientWs.readyState !== clientWs.CLOSING) {
+        clientWs.close(1011, "Error in server websocket");
+      }
+    }
+  };
+}
+async function handleSseConnectRequest(c, registryConfig, _runConfig, driver) {
+  let encoding;
+  try {
+    encoding = getRequestEncoding(c.req);
+    logger2().debug("sse connection request received", { encoding });
+    const params = ConnectRequestSchema.safeParse({
+      query: getRequestQuery(c),
+      encoding: c.req.header(HEADER_ENCODING),
+      connParams: c.req.header(HEADER_CONN_PARAMS)
+    });
+    if (!params.success) {
+      logger2().error("invalid connection parameters", {
+        error: params.error
+      });
+      throw new InvalidRequest(params.error);
+    }
+    const query = params.data.query;
+    const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
+    const authData = await authenticateEndpoint(
+      c,
+      driver,
+      registryConfig,
+      query,
+      ["connect"],
+      connParams
+    );
+    const { actorId } = await queryActor2(c, query, driver);
+    invariant12(actorId, "Missing actor ID");
+    logger2().debug("sse connection to actor", { actorId });
+    logger2().debug("using custom proxy mode for sse connection");
+    const url = new URL("http://actor/connect/sse");
+    const proxyRequestHeaderes = new Headers();
+    proxyRequestHeaderes.set(HEADER_ENCODING, params.data.encoding);
+    if (params.data.connParams) {
+      proxyRequestHeaderes.set(HEADER_CONN_PARAMS, params.data.connParams);
+    }
+    if (authData) {
+      proxyRequestHeaderes.set(HEADER_AUTH_DATA, JSON.stringify(authData));
+    }
+    const proxyRequest = new Request(url, { headers: proxyRequestHeaderes });
+    return await driver.proxyRequest(c, proxyRequest, actorId);
+  } catch (error) {
+    const { code, message, metadata } = deconstructError(error, logger2(), {
+      sseEvent: "setup"
+    });
+    return streamSSE3(c, async (stream) => {
+      try {
+        if (encoding) {
+          const errorMsg = {
+            body: {
+              tag: "Error",
+              val: {
+                code,
+                message,
+                metadata: bufferToArrayBuffer(cbor13.encode(metadata)),
+                actionId: null
+              }
+            }
+          };
+          const serialized = serializeWithEncoding(
+            encoding,
+            errorMsg,
+            TO_CLIENT_VERSIONED
+          );
+          await stream.writeSSE({
+            data: typeof serialized === "string" ? serialized : Buffer.from(serialized).toString("base64")
+          });
+        } else {
+          await stream.writeSSE({
+            data: code,
+            event: "error"
+          });
+        }
+      } catch (serializeError) {
+        logger2().error("failed to send error to sse client", {
+          error: serializeError
+        });
+        await stream.writeSSE({
+          data: "internal error during error handling",
+          event: "error"
+        });
+      }
+    });
+  }
+}
+async function handleWebSocketConnectRequest(c, registryConfig, runConfig, driver) {
+  const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+  if (!upgradeWebSocket) {
+    return c.text(
+      "WebSockets are not enabled for this driver. Use SSE instead.",
+      400
+    );
+  }
+  let encoding;
+  try {
+    logger2().debug("websocket connection request received");
+    const protocols = c.req.header("sec-websocket-protocol");
+    const { queryRaw, encodingRaw, connParamsRaw } = parseWebSocketProtocols(protocols);
+    let queryUnvalidated;
+    try {
+      queryUnvalidated = JSON.parse(queryRaw);
+    } catch (error) {
+      logger2().error("invalid query json", { error });
+      throw new InvalidQueryJSON(error);
+    }
+    let connParamsUnvalidated = null;
+    try {
+      if (connParamsRaw) {
+        connParamsUnvalidated = JSON.parse(connParamsRaw);
+      }
+    } catch (error) {
+      logger2().error("invalid conn params", { error });
+      throw new InvalidParams(
+        `Invalid params JSON: ${stringifyError(error)}`
+      );
+    }
+    const params = ConnectWebSocketRequestSchema.safeParse({
+      query: queryUnvalidated,
+      encoding: encodingRaw,
+      connParams: connParamsUnvalidated
+    });
+    if (!params.success) {
+      logger2().error("invalid connection parameters", {
+        error: params.error
+      });
+      throw new InvalidRequest(params.error);
+    }
+    encoding = params.data.encoding;
+    const authData = await authenticateEndpoint(
+      c,
+      driver,
+      registryConfig,
+      params.data.query,
+      ["connect"],
+      connParamsRaw
+    );
+    const { actorId } = await queryActor2(c, params.data.query, driver);
+    logger2().debug("found actor for websocket connection", {
+      actorId
+    });
+    invariant12(actorId, "missing actor id");
+    return await driver.proxyWebSocket(
+      c,
+      PATH_CONNECT_WEBSOCKET,
+      actorId,
+      params.data.encoding,
+      params.data.connParams,
+      authData
+    );
+  } catch (error) {
+    const { code, message, metadata } = deconstructError(error, logger2(), {
+      wsEvent: "setup"
+    });
+    return await upgradeWebSocket(() => ({
+      onOpen: (_evt, ws) => {
+        if (encoding) {
+          try {
+            const errorMsg = {
+              body: {
+                tag: "Error",
+                val: {
+                  code,
+                  message,
+                  metadata: bufferToArrayBuffer(cbor13.encode(metadata)),
+                  actionId: null
+                }
+              }
+            };
+            const serialized = serializeWithEncoding(
+              encoding,
+              errorMsg,
+              TO_CLIENT_VERSIONED
+            );
+            ws.send(serialized);
+            ws.close(1011, code);
+          } catch (serializeError) {
+            logger2().error("failed to send error to websocket client", {
+              error: serializeError
+            });
+            ws.close(1011, "internal error during error handling");
+          }
+        } else {
+          ws.close(1011, code);
+        }
+      }
+    }))(c, noopNext());
+  }
+}
+async function handleMessageRequest(c, _registryConfig, _runConfig, driver) {
+  logger2().debug("connection message request received");
+  try {
+    const params = ConnMessageRequestSchema.safeParse({
+      actorId: c.req.header(HEADER_ACTOR_ID),
+      connId: c.req.header(HEADER_CONN_ID),
+      encoding: c.req.header(HEADER_ENCODING),
+      connToken: c.req.header(HEADER_CONN_TOKEN)
+    });
+    if (!params.success) {
+      logger2().error("invalid connection parameters", {
+        error: params.error
+      });
+      throw new InvalidRequest(params.error);
+    }
+    const { actorId, connId, encoding, connToken } = params.data;
+    const url = new URL("http://actor/connections/message");
+    const proxyRequestHeaders = new Headers();
+    proxyRequestHeaders.set(HEADER_ENCODING, encoding);
+    proxyRequestHeaders.set(HEADER_CONN_ID, connId);
+    proxyRequestHeaders.set(HEADER_CONN_TOKEN, connToken);
+    const proxyRequest = new Request(url, {
+      method: "POST",
+      body: c.req.raw.body,
+      duplex: "half",
+      headers: proxyRequestHeaders
+    });
+    return await driver.proxyRequest(c, proxyRequest, actorId);
+  } catch (error) {
+    logger2().error("error proxying connection message", { error });
+    if (!ActorError.isActorError(error)) {
+      throw new ProxyError("connection message", error);
+    } else {
+      throw error;
+    }
+  }
+}
+async function handleActionRequest(c, registryConfig, _runConfig, driver) {
+  try {
+    const actionName = c.req.param("action");
+    logger2().debug("action call received", { actionName });
+    const params = ConnectRequestSchema.safeParse({
+      query: getRequestQuery(c),
+      encoding: c.req.header(HEADER_ENCODING),
+      connParams: c.req.header(HEADER_CONN_PARAMS)
+    });
+    if (!params.success) {
+      logger2().error("invalid connection parameters", {
+        error: params.error
+      });
+      throw new InvalidRequest(params.error);
+    }
+    const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
+    const authData = await authenticateEndpoint(
+      c,
+      driver,
+      registryConfig,
+      params.data.query,
+      ["action"],
+      connParams
+    );
+    const { actorId } = await queryActor2(c, params.data.query, driver);
+    logger2().debug("found actor for action", { actorId });
+    invariant12(actorId, "Missing actor ID");
+    const url = new URL(
+      `http://actor/action/${encodeURIComponent(actionName)}`
+    );
+    const proxyRequestHeaders = new Headers();
+    proxyRequestHeaders.set(HEADER_ENCODING, params.data.encoding);
+    if (params.data.connParams) {
+      proxyRequestHeaders.set(HEADER_CONN_PARAMS, params.data.connParams);
+    }
+    if (authData) {
+      proxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));
+    }
+    const proxyRequest = new Request(url, {
+      method: "POST",
+      body: c.req.raw.body,
+      headers: proxyRequestHeaders
+    });
+    return await driver.proxyRequest(c, proxyRequest, actorId);
+  } catch (error) {
+    logger2().error("error in action handler", { error: stringifyError(error) });
+    if (!ActorError.isActorError(error)) {
+      throw new ProxyError("Action call", error);
+    } else {
+      throw error;
+    }
+  }
+}
+async function handleResolveRequest(c, registryConfig, driver) {
+  const encoding = getRequestEncoding(c.req);
+  logger2().debug("resolve request encoding", { encoding });
+  const params = ResolveRequestSchema.safeParse({
+    query: getRequestQuery(c),
+    connParams: c.req.header(HEADER_CONN_PARAMS)
+  });
+  if (!params.success) {
+    logger2().error("invalid connection parameters", {
+      error: params.error
+    });
+    throw new InvalidRequest(params.error);
+  }
+  const connParams = params.data.connParams ? JSON.parse(params.data.connParams) : void 0;
+  const query = params.data.query;
+  await authenticateEndpoint(c, driver, registryConfig, query, [], connParams);
+  const { actorId } = await queryActor2(c, query, driver);
+  logger2().debug("resolved actor", { actorId });
+  invariant12(actorId, "Missing actor ID");
+  const response = {
+    actorId
+  };
+  const serialized = serializeWithEncoding(
+    encoding,
+    response,
+    HTTP_RESOLVE_RESPONSE_VERSIONED
+  );
+  return c.body(serialized);
+}
+async function handleRawHttpRequest(c, registryConfig, _runConfig, driver) {
+  try {
+    const subpath = c.req.path.split("/raw/http/")[1] || "";
+    logger2().debug("raw http request received", { subpath });
+    const queryHeader = c.req.header(HEADER_ACTOR_QUERY);
+    if (!queryHeader) {
+      throw new InvalidRequest("Missing actor query header");
+    }
+    const query = JSON.parse(queryHeader);
+    const connParamsHeader = c.req.header(HEADER_CONN_PARAMS);
+    const connParams = connParamsHeader ? JSON.parse(connParamsHeader) : void 0;
+    const authData = await authenticateEndpoint(
+      c,
+      driver,
+      registryConfig,
+      query,
+      ["action"],
+      connParams
+    );
+    const { actorId } = await queryActor2(c, query, driver);
+    logger2().debug("found actor for raw http", { actorId });
+    invariant12(actorId, "Missing actor ID");
+    const originalUrl = new URL(c.req.url);
+    const url = new URL(
+      `http://actor/raw/http/${subpath}${originalUrl.search}`
+    );
+    logger2().debug("rewriting http url", {
+      from: c.req.url,
+      to: url
+    });
+    const proxyRequestHeaders = new Headers(c.req.raw.headers);
+    if (connParams) {
+      proxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(connParams));
+    }
+    if (authData) {
+      proxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));
+    }
+    const proxyRequest = new Request(url, {
+      method: c.req.method,
+      headers: proxyRequestHeaders,
+      body: c.req.raw.body
+    });
+    return await driver.proxyRequest(c, proxyRequest, actorId);
+  } catch (error) {
+    logger2().error("error in raw http handler", {
+      error: stringifyError(error)
+    });
+    if (!ActorError.isActorError(error)) {
+      throw new ProxyError("Raw HTTP request", error);
+    } else {
+      throw error;
+    }
+  }
+}
+async function handleRawWebSocketRequest(c, registryConfig, runConfig, driver) {
+  const upgradeWebSocket = runConfig.getUpgradeWebSocket?.();
+  if (!upgradeWebSocket) {
+    return c.text("WebSockets are not enabled for this driver.", 400);
+  }
+  try {
+    const subpath = c.req.path.split("/raw/websocket/")[1] || "";
+    logger2().debug("raw websocket request received", { subpath });
+    const protocols = c.req.header("sec-websocket-protocol");
+    const {
+      queryRaw: queryFromProtocol,
+      connParamsRaw: connParamsFromProtocol
+    } = parseWebSocketProtocols(protocols);
+    if (!queryFromProtocol) {
+      throw new InvalidRequest("Missing query in WebSocket protocol");
+    }
+    const query = JSON.parse(queryFromProtocol);
+    let connParams;
+    if (connParamsFromProtocol) {
+      connParams = JSON.parse(connParamsFromProtocol);
+    }
+    const authData = await authenticateEndpoint(
+      c,
+      driver,
+      registryConfig,
+      query,
+      ["action"],
+      connParams
+    );
+    const { actorId } = await queryActor2(c, query, driver);
+    logger2().debug("found actor for raw websocket", { actorId });
+    invariant12(actorId, "Missing actor ID");
+    logger2().debug("using custom proxy mode for raw websocket");
+    const originalUrl = new URL(c.req.url);
+    const proxyPath = `${PATH_RAW_WEBSOCKET_PREFIX}${subpath}${originalUrl.search}`;
+    logger2().debug("manager router proxyWebSocket", {
+      originalUrl: c.req.url,
+      subpath,
+      search: originalUrl.search,
+      proxyPath
+    });
+    return await driver.proxyWebSocket(
+      c,
+      proxyPath,
+      actorId,
+      "json",
+      // Default encoding for raw WebSocket
+      connParams,
+      authData
+    );
+  } catch (error) {
+    const { code } = deconstructError(error, logger2(), {
+      wsEvent: "setup"
+    });
+    return await upgradeWebSocket(() => ({
+      onOpen: (_evt, ws) => {
+        ws.close(1011, code);
+      }
+    }))(c, noopNext());
+  }
+}
+function universalActorProxy({
+  registryConfig,
+  runConfig,
+  driver
+}) {
+  return async (c, _next) => {
+    if (c.req.header("upgrade") === "websocket") {
+      return handleRawWebSocketRequest(c, registryConfig, runConfig, driver);
+    } else {
+      const queryHeader = c.req.header(HEADER_ACTOR_QUERY);
+      if (!queryHeader) {
+        throw new InvalidRequest("Missing actor query header");
+      }
+      const query = ActorQuerySchema.parse(JSON.parse(queryHeader));
+      const { actorId } = await queryActor2(c, query, driver);
+      const url = new URL(c.req.url);
+      url.hostname = "actor";
+      url.pathname = url.pathname.replace(new RegExp(`^${runConfig.basePath}`, ""), "").replace(/^\/?registry\/actors/, "").replace(/^\/?actors/, "");
+      const proxyRequest = new Request(url, {
+        method: c.req.method,
+        headers: c.req.raw.headers,
+        body: c.req.raw.body
+      });
+      return await driver.proxyRequest(c, proxyRequest, actorId);
+    }
+  };
+}
+
+// src/registry/config.ts
+import { z as z11 } from "zod";
+var ActorsSchema = z11.record(
+  z11.string(),
+  z11.custom()
+);
+var TestConfigSchema = z11.object({ enabled: z11.boolean() });
+var RegistryConfigSchema = z11.object({
+  use: z11.record(z11.string(), z11.custom()),
+  // TODO: Find a better way of passing around the test config
+  /**
+   * Test configuration.
+   *
+   * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.
+   * @internal
+   **/
+  test: TestConfigSchema.optional().default({ enabled: false })
+});
+
+// src/registry/log.ts
+var LOGGER_NAME7 = "registry";
+function logger9() {
+  return getLogger(LOGGER_NAME7);
+}
+
+// src/registry/serve.ts
+import { Hono as Hono5 } from "hono";
+async function crossPlatformServe(rivetKitRouter, userRouter) {
+  const app = userRouter ?? new Hono5();
+  let serve;
+  try {
+    const dep = await import("@hono/node-server");
+    serve = dep.serve;
+  } catch (err) {
+    logger9().error(
+      "failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'"
+    );
+    process.exit(1);
+  }
+  app.route("/registry", rivetKitRouter);
+  let createNodeWebSocket;
+  try {
+    const dep = await import("@hono/node-ws");
+    createNodeWebSocket = dep.createNodeWebSocket;
+  } catch (err) {
+    logger9().error(
+      "failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'"
+    );
+    process.exit(1);
+  }
+  const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({
+    app
+  });
+  const port = Number.parseInt(
+    getEnvUniversal("PORT") ?? getEnvUniversal("PORT_HTTP") ?? "8080"
+  );
+  const server = serve(
+    { fetch: app.fetch, port },
+    () => logger9().info("server listening", { port })
+  );
+  injectWebSocket(server);
+  return { upgradeWebSocket };
+}
+
+// src/registry/mod.ts
+var Registry = class {
+  #config;
+  get config() {
+    return this.#config;
+  }
+  constructor(config4) {
+    this.#config = config4;
+  }
+  /**
+   * Runs the registry for a server.
+   */
+  createServer(inputConfig) {
+    const config4 = RunConfigSchema.parse(inputConfig);
+    const driver = chooseDefaultDriver(config4);
+    let upgradeWebSocket;
+    if (!config4.getUpgradeWebSocket) {
+      config4.getUpgradeWebSocket = () => upgradeWebSocket;
+    }
+    const managerDriver = driver.manager(this.#config, config4);
+    const clientDriver = createInlineClientDriver(managerDriver);
+    const { router: hono } = createManagerRouter(
+      this.#config,
+      config4,
+      clientDriver,
+      managerDriver,
+      false
+    );
+    const client = createClientWithDriver(clientDriver);
+    const driverLog = managerDriver.extraStartupLog?.() ?? {};
+    logger9().info("rivetkit ready", {
+      driver: driver.name,
+      definitions: Object.keys(this.#config.use).length,
+      ...driverLog
+    });
+    if (config4.inspector?.enabled) {
+      logger9().info("inspector ready", {
+        url: getInspectorUrl(config4)
+      });
+    }
+    if (config4.role === "all" || config4.role === "runner") {
+      const inlineClient = createClientWithDriver(
+        createInlineClientDriver(managerDriver)
+      );
+      const _actorDriver = driver.actor(
+        this.#config,
+        config4,
+        managerDriver,
+        inlineClient
+      );
+    }
+    return {
+      client,
+      hono,
+      handler: async (req) => await hono.fetch(req),
+      serve: async (app) => {
+        const out = await crossPlatformServe(hono, app);
+        upgradeWebSocket = out.upgradeWebSocket;
+      }
+    };
+  }
+  /**
+   * Runs the registry as a standalone server.
+   */
+  async runServer(inputConfig) {
+    const { serve } = this.createServer(inputConfig);
+    serve();
+  }
+};
+function setup(input) {
+  const config4 = RegistryConfigSchema.parse(input);
+  return new Registry(config4);
+}
+
+// fixtures/driver-test-suite/action-inputs.ts
+var inputActor = actor({
+  onAuth: () => {
+  },
+  createState: (c, input) => {
+    return {
+      initialInput: input,
+      onCreateInput: void 0
+    };
+  },
+  onCreate: (c, input) => {
+    c.state.onCreateInput = input;
+  },
+  actions: {
+    getInputs: (c) => {
+      return {
+        initialInput: c.state.initialInput,
+        onCreateInput: c.state.onCreateInput
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/action-timeout.ts
+var shortTimeoutActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  options: {
+    actionTimeout: 50
+    // 50ms timeout
+  },
+  actions: {
+    quickAction: async (c) => {
+      return "quick response";
+    },
+    slowAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return "slow response";
+    }
+  }
+});
+var longTimeoutActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  options: {
+    actionTimeout: 200
+    // 200ms timeout
+  },
+  actions: {
+    delayedAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return "delayed response";
+    }
+  }
+});
+var defaultTimeoutActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  actions: {
+    normalAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return "normal response";
+    }
+  }
+});
+var syncTimeoutActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  options: {
+    actionTimeout: 50
+    // 50ms timeout
+  },
+  actions: {
+    syncAction: (c) => {
+      return "sync response";
+    }
+  }
+});
+
+// fixtures/driver-test-suite/action-types.ts
+var syncActionActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  actions: {
+    // Simple synchronous action that returns a value directly
+    increment: (c, amount = 1) => {
+      c.state.value += amount;
+      return c.state.value;
+    },
+    // Synchronous action that returns an object
+    getInfo: (c) => {
+      return {
+        currentValue: c.state.value,
+        timestamp: Date.now()
+      };
+    },
+    // Synchronous action with no return value (void)
+    reset: (c) => {
+      c.state.value = 0;
+    }
+  }
+});
+var asyncActionActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0, data: null },
+  actions: {
+    // Async action with a delay
+    delayedIncrement: async (c, amount = 1) => {
+      await Promise.resolve();
+      c.state.value += amount;
+      return c.state.value;
+    },
+    // Async action that simulates an API call
+    fetchData: async (c, id) => {
+      await Promise.resolve();
+      const data = { id, timestamp: Date.now() };
+      c.state.data = data;
+      return data;
+    },
+    // Async action with error handling
+    asyncWithError: async (c, shouldError) => {
+      await Promise.resolve();
+      if (shouldError) {
+        throw new UserError("Intentional error");
+      }
+      return "Success";
+    }
+  }
+});
+var promiseActor = actor({
+  onAuth: () => {
+  },
+  state: { results: [] },
+  actions: {
+    // Action that returns a resolved promise
+    resolvedPromise: (c) => {
+      return Promise.resolve("resolved value");
+    },
+    // Action that returns a promise that resolves after a delay
+    delayedPromise: (c) => {
+      return new Promise((resolve) => {
+        c.state.results.push("delayed");
+        resolve("delayed value");
+      });
+    },
+    // Action that returns a rejected promise
+    rejectedPromise: (c) => {
+      return Promise.reject(new UserError("promised rejection"));
+    },
+    // Action to check the collected results
+    getResults: (c) => {
+      return c.state.results;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/actor-onstatechange.ts
+var onStateChangeActor = actor({
+  onAuth: () => {
+  },
+  state: {
+    value: 0,
+    changeCount: 0
+  },
+  actions: {
+    // Action that modifies state - should trigger onStateChange
+    setValue: (c, newValue) => {
+      c.state.value = newValue;
+      return c.state.value;
+    },
+    // Action that modifies state multiple times - should trigger onStateChange for each change
+    incrementMultiple: (c, times) => {
+      for (let i = 0; i < times; i++) {
+        c.state.value++;
+      }
+      return c.state.value;
+    },
+    // Action that doesn't modify state - should NOT trigger onStateChange
+    getValue: (c) => {
+      return c.state.value;
+    },
+    // Action that reads and returns without modifying - should NOT trigger onStateChange
+    getDoubled: (c) => {
+      const doubled = c.state.value * 2;
+      return doubled;
+    },
+    // Get the count of how many times onStateChange was called
+    getChangeCount: (c) => {
+      return c.state.changeCount;
+    },
+    // Reset change counter for testing
+    resetChangeCount: (c) => {
+      c.state.changeCount = 0;
+    }
+  },
+  // Track onStateChange calls
+  onStateChange: (c) => {
+    c.state.changeCount++;
+  }
+});
+
+// fixtures/driver-test-suite/auth.ts
+var authActor = actor({
+  state: { requests: 0 },
+  onAuth: (opts, params) => {
+    const apiKey = params?.apiKey;
+    if (!apiKey) {
+      throw new UserError("API key required", { code: "missing_auth" });
+    }
+    if (apiKey !== "valid-api-key") {
+      throw new UserError("Invalid API key", { code: "invalid_auth" });
+    }
+    return { userId: "user123", token: apiKey };
+  },
+  actions: {
+    getRequests: (c) => {
+      c.state.requests++;
+      return c.state.requests;
+    },
+    getUserAuth: (c) => c.conn.auth
+  }
+});
+var intentAuthActor = actor({
+  state: { value: 0 },
+  onAuth: ({ request, intents }, params) => {
+    console.log("intents", intents, params);
+    const role = params.role;
+    if (intents.has("create") && role !== "admin") {
+      throw new UserError("Admin role required for create operations", {
+        code: "insufficient_permissions"
+      });
+    }
+    if (intents.has("action") && !["admin", "user"].includes(role || "")) {
+      throw new UserError("User or admin role required for actions", {
+        code: "insufficient_permissions"
+      });
+    }
+    return { role, timestamp: Date.now() };
+  },
+  actions: {
+    getValue: (c) => c.state.value,
+    setValue: (c, value) => {
+      c.state.value = value;
+      return value;
+    },
+    getAuth: (c) => c.conn.auth
+  }
+});
+var publicActor = actor({
+  state: { visitors: 0 },
+  onAuth: () => {
+    return null;
+  },
+  actions: {
+    visit: (c) => {
+      c.state.visitors++;
+      return c.state.visitors;
+    }
+  }
+});
+var noAuthActor = actor({
+  state: { value: 42 },
+  actions: {
+    getValue: (c) => c.state.value
+  }
+});
+var asyncAuthActor = actor({
+  state: { count: 0 },
+  onAuth: async (opts, params) => {
+    const token = params?.token;
+    if (!token) {
+      throw new UserError("Token required", { code: "missing_token" });
+    }
+    if (token === "invalid") {
+      throw new UserError("Token is invalid", { code: "invalid_token" });
+    }
+    return { userId: `user-${token}`, validated: true };
+  },
+  actions: {
+    increment: (c) => {
+      c.state.count++;
+      return c.state.count;
+    },
+    getAuthData: (c) => c.conn.auth
+  }
+});
+
+// fixtures/driver-test-suite/conn-liveness.ts
+var connLivenessActor = actor({
+  onAuth: () => {
+  },
+  state: {
+    counter: 0,
+    acceptingConnections: true
+  },
+  options: {
+    connectionLivenessInterval: 5e3,
+    connectionLivenessTimeout: 2500
+  },
+  onConnect: (c, conn) => {
+    if (!c.state.acceptingConnections) {
+      conn.disconnect();
+      throw new Error("Actor is not accepting connections");
+    }
+  },
+  actions: {
+    getWsConnectionsLiveness: (c) => {
+      return Array.from(c.conns.values()).filter((conn) => conn.driver === CONNECTION_DRIVER_WEBSOCKET).map((conn) => ({
+        id: conn.id,
+        status: conn.status,
+        lastSeen: conn.lastSeen
+      }));
+    },
+    getConnectionId: (c) => {
+      return c.conn.id;
+    },
+    kill: (c, connId) => {
+      c.state.acceptingConnections = false;
+      const conn = c.conns.get(connId);
+      if (conn) {
+        conn.disconnect();
+      }
+    },
+    getCounter: (c) => {
+      return c.state.counter;
+    },
+    increment: (c, amount) => {
+      c.state.counter += amount;
+      return c.state.counter;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/conn-params.ts
+var counterWithParams = actor({
+  onAuth: () => {
+  },
+  state: { count: 0, initializers: [] },
+  createConnState: (c, opts, params) => {
+    return {
+      name: params.name || "anonymous"
+    };
+  },
+  onConnect: (c, conn) => {
+    c.state.initializers.push(conn.state.name);
+  },
+  actions: {
+    increment: (c, x) => {
+      c.state.count += x;
+      c.broadcast("newCount", {
+        count: c.state.count,
+        by: c.conn.state.name
+      });
+      return c.state.count;
+    },
+    getInitializers: (c) => {
+      return c.state.initializers;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/conn-state.ts
+var connStateActor = actor({
+  onAuth: () => {
+  },
+  state: {
+    sharedCounter: 0,
+    disconnectionCount: 0
+  },
+  // Define connection state
+  createConnState: (c, opts, params) => {
+    return {
+      username: params?.username || "anonymous",
+      role: params?.role || "user",
+      counter: 0,
+      createdAt: Date.now()
+    };
+  },
+  // Lifecycle hook when a connection is established
+  onConnect: (c, conn) => {
+    c.broadcast("userConnected", {
+      id: conn.id,
+      username: "anonymous",
+      role: "user"
+    });
+  },
+  // Lifecycle hook when a connection is closed
+  onDisconnect: (c, conn) => {
+    c.state.disconnectionCount += 1;
+    c.broadcast("userDisconnected", {
+      id: conn.id
+    });
+  },
+  actions: {
+    // Action to increment the connection's counter
+    incrementConnCounter: (c, amount = 1) => {
+      c.conn.state.counter += amount;
+    },
+    // Action to increment the shared counter
+    incrementSharedCounter: (c, amount = 1) => {
+      c.state.sharedCounter += amount;
+      return c.state.sharedCounter;
+    },
+    // Get the connection state
+    getConnectionState: (c) => {
+      return { id: c.conn.id, ...c.conn.state };
+    },
+    // Check all active connections
+    getConnectionIds: (c) => {
+      return c.conns.keys().toArray();
+    },
+    // Get disconnection count
+    getDisconnectionCount: (c) => {
+      return c.state.disconnectionCount;
+    },
+    // Get all active connection states
+    getAllConnectionStates: (c) => {
+      return c.conns.entries().map(([id, conn]) => ({ id, ...conn.state })).toArray();
+    },
+    // Send message to a specific connection with matching ID
+    sendToConnection: (c, targetId, message) => {
+      if (c.conns.has(targetId)) {
+        c.conns.get(targetId).send("directMessage", { from: c.conn.id, message });
+        return true;
+      } else {
+        return false;
+      }
+    },
+    // Update connection state (simulated for tests)
+    updateConnection: (c, updates) => {
+      if (updates.username) c.conn.state.username = updates.username;
+      if (updates.role) c.conn.state.role = updates.role;
+      return c.conn.state;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/counter.ts
+var counter = actor({
+  onAuth: () => {
+  },
+  state: { count: 0 },
+  actions: {
+    increment: (c, x) => {
+      c.state.count += x;
+      c.broadcast("newCount", c.state.count);
+      return c.state.count;
+    },
+    getCount: (c) => {
+      return c.state.count;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/error-handling.ts
+var errorHandlingActor = actor({
+  onAuth: () => {
+  },
+  state: {
+    errorLog: []
+  },
+  actions: {
+    // Action that throws a UserError with just a message
+    throwSimpleError: () => {
+      throw new UserError("Simple error message");
+    },
+    // Action that throws a UserError with code and metadata
+    throwDetailedError: () => {
+      throw new UserError("Detailed error message", {
+        code: "detailed_error",
+        metadata: {
+          reason: "test",
+          timestamp: Date.now()
+        }
+      });
+    },
+    // Action that throws an internal error
+    throwInternalError: () => {
+      throw new Error("This is an internal error");
+    },
+    // Action that returns successfully
+    successfulAction: () => {
+      return "success";
+    },
+    // Action that times out (simulated with a long delay)
+    timeoutAction: async (c) => {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve("This should not be reached if timeout works");
+        }, 1e4);
+      });
+    },
+    // Action with configurable delay to test timeout edge cases
+    delayedAction: async (c, delayMs) => {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(`Completed after ${delayMs}ms`);
+        }, delayMs);
+      });
+    },
+    // Log an error for inspection
+    logError: (c, error) => {
+      c.state.errorLog.push(error);
+      return c.state.errorLog;
+    },
+    // Get the error log
+    getErrorLog: (c) => {
+      return c.state.errorLog;
+    },
+    // Clear the error log
+    clearErrorLog: (c) => {
+      c.state.errorLog = [];
+      return true;
+    }
+  },
+  options: {
+    actionTimeout: 500
+    // 500ms timeout for actions
+  }
+});
+var customTimeoutActor = actor({
+  state: {},
+  actions: {
+    quickAction: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return "Quick action completed";
+    },
+    slowAction: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return "Slow action completed";
+    }
+  },
+  options: {
+    actionTimeout: 200
+    // 200ms timeout
+  }
+});
+
+// fixtures/driver-test-suite/inline-client.ts
+var inlineClientActor = actor({
+  onAuth: () => {
+  },
+  state: { messages: [] },
+  actions: {
+    // Action that uses client to call another actor (stateless)
+    callCounterIncrement: async (c, amount) => {
+      const client = c.client();
+      const result = await client.counter.getOrCreate(["inline-test"]).increment(amount);
+      c.state.messages.push(
+        `Called counter.increment(${amount}), result: ${result}`
+      );
+      return result;
+    },
+    // Action that uses client to get counter state (stateless)
+    getCounterState: async (c) => {
+      const client = c.client();
+      const count = await client.counter.getOrCreate(["inline-test"]).getCount();
+      c.state.messages.push(`Got counter state: ${count}`);
+      return count;
+    },
+    // Action that uses client with .connect() for stateful communication
+    connectToCounterAndIncrement: async (c, amount) => {
+      const client = c.client();
+      const handle = client.counter.getOrCreate(["inline-test-stateful"]);
+      const connection = handle.connect();
+      const events = [];
+      connection.on("newCount", (count) => {
+        events.push(count);
+      });
+      const result1 = await connection.increment(amount);
+      const result2 = await connection.increment(amount * 2);
+      await connection.dispose();
+      c.state.messages.push(
+        `Connected to counter, incremented by ${amount} and ${amount * 2}, results: ${result1}, ${result2}, events: ${JSON.stringify(events)}`
+      );
+      return { result1, result2, events };
+    },
+    // Get all messages from this actor's state
+    getMessages: (c) => {
+      return c.state.messages;
+    },
+    // Clear messages
+    clearMessages: (c) => {
+      c.state.messages = [];
+    }
+  }
+});
+
+// fixtures/driver-test-suite/lifecycle.ts
+var counterWithLifecycle = actor({
+  onAuth: () => {
+  },
+  state: {
+    count: 0,
+    events: []
+  },
+  createConnState: (c, opts, params) => ({
+    joinTime: Date.now()
+  }),
+  onStart: (c) => {
+    c.state.events.push("onStart");
+  },
+  onBeforeConnect: (c, opts, params) => {
+    if (params?.trackLifecycle) c.state.events.push("onBeforeConnect");
+  },
+  onConnect: (c, conn) => {
+    if (conn.params?.trackLifecycle) c.state.events.push("onConnect");
+  },
+  onDisconnect: (c, conn) => {
+    if (conn.params?.trackLifecycle) c.state.events.push("onDisconnect");
+  },
+  actions: {
+    getEvents: (c) => {
+      return c.state.events;
+    },
+    increment: (c, x) => {
+      c.state.count += x;
+      return c.state.count;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/metadata.ts
+var metadataActor = actor({
+  onAuth: () => {
+  },
+  state: {
+    lastMetadata: null,
+    actorName: "",
+    // Store tags and region in state for testing since they may not be
+    // available in the context in all environments
+    storedTags: {},
+    storedRegion: null
+  },
+  onStart: (c) => {
+    c.state.actorName = c.name;
+  },
+  actions: {
+    // Set up test tags - this will be called by tests to simulate tags
+    setupTestTags: (c, tags) => {
+      c.state.storedTags = tags;
+      return tags;
+    },
+    // Set up test region - this will be called by tests to simulate region
+    setupTestRegion: (c, region) => {
+      c.state.storedRegion = region;
+      return region;
+    },
+    // Get all available metadata
+    getMetadata: (c) => {
+      const metadata = {
+        name: c.name,
+        tags: c.state.storedTags,
+        region: c.state.storedRegion
+      };
+      c.state.lastMetadata = metadata;
+      return metadata;
+    },
+    // Get the actor name
+    getActorName: (c) => {
+      return c.name;
+    },
+    // Get a specific tag by key
+    getTag: (c, key) => {
+      return c.state.storedTags[key] || null;
+    },
+    // Get all tags
+    getTags: (c) => {
+      return c.state.storedTags;
+    },
+    // Get the region
+    getRegion: (c) => {
+      return c.state.storedRegion;
+    },
+    // Get the stored actor name (from onStart)
+    getStoredActorName: (c) => {
+      return c.state.actorName;
+    },
+    // Get last retrieved metadata
+    getLastMetadata: (c) => {
+      return c.state.lastMetadata;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/raw-http.ts
+import { Hono as Hono6 } from "hono";
+var rawHttpActor = actor({
+  state: {
+    requestCount: 0
+  },
+  onAuth() {
+    return {};
+  },
+  onFetch(ctx, request) {
+    const url = new URL(request.url);
+    const method = request.method;
+    ctx.state.requestCount++;
+    if (url.pathname === "/api/hello") {
+      return new Response(JSON.stringify({ message: "Hello from actor!" }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    if (url.pathname === "/api/echo" && method === "POST") {
+      return new Response(request.body, {
+        headers: request.headers
+      });
+    }
+    if (url.pathname === "/api/state") {
+      return new Response(
+        JSON.stringify({
+          requestCount: ctx.state.requestCount
+        }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    if (url.pathname === "/api/headers") {
+      const headers = Object.fromEntries(request.headers.entries());
+      return new Response(JSON.stringify(headers), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {}
+});
+var rawHttpNoHandlerActor = actor({
+  // No onFetch handler - all requests should return 404
+  onAuth() {
+    return {};
+  },
+  actions: {}
+});
+var rawHttpVoidReturnActor = actor({
+  onAuth() {
+    return {};
+  },
+  onFetch(ctx, request) {
+    return void 0;
+  },
+  actions: {}
+});
+var rawHttpHonoActor = actor({
+  onAuth() {
+    return {};
+  },
+  createVars() {
+    const router = new Hono6();
+    router.get("/", (c) => c.json({ message: "Welcome to Hono actor!" }));
+    router.get(
+      "/users",
+      (c) => c.json([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ])
+    );
+    router.get("/users/:id", (c) => {
+      const id = c.req.param("id");
+      return c.json({ id: parseInt(id), name: id === "1" ? "Alice" : "Bob" });
+    });
+    router.post("/users", async (c) => {
+      const body = await c.req.json();
+      return c.json({ id: 3, ...body }, 201);
+    });
+    router.put("/users/:id", async (c) => {
+      const id = c.req.param("id");
+      const body = await c.req.json();
+      return c.json({ id: parseInt(id), ...body });
+    });
+    router.delete("/users/:id", (c) => {
+      const id = c.req.param("id");
+      return c.json({ message: `User ${id} deleted` });
+    });
+    return { router };
+  },
+  onFetch(ctx, request) {
+    return ctx.vars.router.fetch(request);
+  },
+  actions: {}
+});
+
+// fixtures/driver-test-suite/raw-http-auth.ts
+var rawHttpAuthActor = actor({
+  state: {
+    requestCount: 0
+  },
+  onAuth: (opts, params) => {
+    const apiKey = params.apiKey;
+    if (!apiKey) {
+      throw new UserError("API key required", { code: "missing_auth" });
+    }
+    if (apiKey !== "valid-api-key") {
+      throw new UserError("Invalid API key", { code: "invalid_auth" });
+    }
+    return { userId: "user123", token: apiKey };
+  },
+  onFetch(ctx, request) {
+    const url = new URL(request.url);
+    ctx.state.requestCount++;
+    if (url.pathname === "/api/auth-info") {
+      return new Response(
+        JSON.stringify({
+          message: "Authenticated request",
+          requestCount: ctx.state.requestCount
+        }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    if (url.pathname === "/api/protected") {
+      return new Response(
+        JSON.stringify({
+          message: "This is protected content"
+        }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {
+    getRequestCount(ctx) {
+      return ctx.state.requestCount;
+    },
+    getAuthFromConnections(ctx) {
+      const firstConn = ctx.conns.values().next().value;
+      return firstConn?.auth;
+    }
+  }
+});
+var rawHttpNoAuthActor = actor({
+  state: {
+    value: 42
+  },
+  onFetch(ctx, request) {
+    return new Response(
+      JSON.stringify({
+        value: ctx.state.value
+      }),
+      {
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  },
+  actions: {
+    getValue(ctx) {
+      return ctx.state.value;
+    }
+  }
+});
+var rawHttpPublicActor = actor({
+  state: {
+    visitors: 0
+  },
+  onAuth: () => {
+    return null;
+  },
+  onFetch(ctx, request) {
+    ctx.state.visitors++;
+    return new Response(
+      JSON.stringify({
+        message: "Welcome visitor!",
+        count: ctx.state.visitors
+      }),
+      {
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  },
+  actions: {
+    getVisitorCount(ctx) {
+      return ctx.state.visitors;
+    }
+  }
+});
+var rawHttpCustomAuthActor = actor({
+  state: {
+    authorized: 0,
+    unauthorized: 0
+  },
+  onAuth: () => {
+    return {};
+  },
+  onFetch(ctx, request) {
+    const authHeader = request.headers.get("Authorization");
+    if (!authHeader || !authHeader.startsWith("Bearer ")) {
+      ctx.state.unauthorized++;
+      return new Response(JSON.stringify({ error: "Unauthorized" }), {
+        status: 401,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    const token = authHeader.substring(7);
+    if (token !== "custom-token") {
+      ctx.state.unauthorized++;
+      return new Response(JSON.stringify({ error: "Invalid token" }), {
+        status: 403,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    ctx.state.authorized++;
+    return new Response(
+      JSON.stringify({
+        message: "Authorized!",
+        authorized: ctx.state.authorized
+      }),
+      {
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  },
+  actions: {
+    getStats(ctx) {
+      return {
+        authorized: ctx.state.authorized,
+        unauthorized: ctx.state.unauthorized
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/raw-http-request-properties.ts
+var rawHttpRequestPropertiesActor = actor({
+  onAuth() {
+    return {};
+  },
+  actions: {},
+  onFetch(ctx, request) {
+    const url = new URL(request.url);
+    const method = request.method;
+    const headers = Object.fromEntries(request.headers.entries());
+    const handleBody = async () => {
+      if (!request.body) {
+        return null;
+      }
+      const contentType = request.headers.get("content-type") || "";
+      try {
+        if (contentType.includes("application/json")) {
+          const text = await request.text();
+          return text ? JSON.parse(text) : null;
+        } else {
+          const text = await request.text();
+          return text || null;
+        }
+      } catch (error) {
+        return null;
+      }
+    };
+    if (method === "HEAD") {
+      return new Response(null, {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return handleBody().then((body) => {
+      const responseData = {
+        // URL properties
+        url: request.url,
+        pathname: url.pathname,
+        search: url.search,
+        searchParams: Object.fromEntries(url.searchParams.entries()),
+        hash: url.hash,
+        // Method
+        method: request.method,
+        // Headers
+        headers,
+        // Body
+        body,
+        bodyText: typeof body === "string" ? body : body === null && request.body !== null ? "" : null,
+        // Additional properties that might be available
+        // Note: Some properties like cache, credentials, mode, etc.
+        // might not be available in all environments
+        cache: request.cache || null,
+        credentials: request.credentials || null,
+        mode: request.mode || null,
+        redirect: request.redirect || null,
+        referrer: request.referrer || null
+      };
+      return new Response(JSON.stringify(responseData), {
+        headers: { "Content-Type": "application/json" }
+      });
+    });
+  }
+});
+
+// fixtures/driver-test-suite/raw-websocket.ts
+var rawWebSocketActor = actor({
+  state: {
+    connectionCount: 0,
+    messageCount: 0
+  },
+  onAuth(params) {
+    return { connParams: params };
+  },
+  onWebSocket(ctx, websocket, opts) {
+    ctx.state.connectionCount = ctx.state.connectionCount + 1;
+    console.log(`[ACTOR] New connection, count: ${ctx.state.connectionCount}`);
+    websocket.send(
+      JSON.stringify({
+        type: "welcome",
+        connectionCount: ctx.state.connectionCount
+      })
+    );
+    console.log("[ACTOR] Sent welcome message");
+    websocket.addEventListener("message", (event) => {
+      ctx.state.messageCount = ctx.state.messageCount + 1;
+      console.log(
+        `[ACTOR] Message received, total count: ${ctx.state.messageCount}, data:`,
+        event.data
+      );
+      const data = event.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "ping") {
+            websocket.send(
+              JSON.stringify({
+                type: "pong",
+                timestamp: Date.now()
+              })
+            );
+          } else if (parsed.type === "getStats") {
+            console.log(
+              `[ACTOR] Sending stats - connections: ${ctx.state.connectionCount}, messages: ${ctx.state.messageCount}`
+            );
+            websocket.send(
+              JSON.stringify({
+                type: "stats",
+                connectionCount: ctx.state.connectionCount,
+                messageCount: ctx.state.messageCount
+              })
+            );
+          } else if (parsed.type === "getAuthData") {
+            websocket.send(
+              JSON.stringify({
+                type: "authData",
+                authData: null,
+                message: "Auth data not available in raw WebSocket handler"
+              })
+            );
+          } else if (parsed.type === "getRequestInfo") {
+            websocket.send(
+              JSON.stringify({
+                type: "requestInfo",
+                url: opts.request.url,
+                pathname: new URL(opts.request.url).pathname,
+                search: new URL(opts.request.url).search
+              })
+            );
+          } else {
+            websocket.send(data);
+          }
+        } catch {
+          websocket.send(data);
+        }
+      } else {
+        websocket.send(data);
+      }
+    });
+    websocket.addEventListener("close", () => {
+      ctx.state.connectionCount = ctx.state.connectionCount - 1;
+      console.log(
+        `[ACTOR] Connection closed, count: ${ctx.state.connectionCount}`
+      );
+    });
+  },
+  actions: {
+    getStats(ctx) {
+      return {
+        connectionCount: ctx.state.connectionCount,
+        messageCount: ctx.state.messageCount
+      };
+    }
+  }
+});
+var rawWebSocketBinaryActor = actor({
+  onAuth() {
+    return {};
+  },
+  onWebSocket(ctx, websocket, opts) {
+    websocket.addEventListener("message", (event) => {
+      const data = event.data;
+      if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+        const bytes = new Uint8Array(data);
+        const reversed = new Uint8Array(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+          reversed[i] = bytes[bytes.length - 1 - i];
+        }
+        websocket.send(reversed);
+      }
+    });
+  },
+  actions: {}
+});
+
+// fixtures/driver-test-suite/raw-websocket-auth.ts
+var rawWebSocketAuthActor = actor({
+  state: {
+    connectionCount: 0,
+    messageCount: 0
+  },
+  onAuth: (opts, params) => {
+    const apiKey = params.apiKey;
+    if (!apiKey) {
+      throw new UserError("API key required", { code: "missing_auth" });
+    }
+    if (apiKey !== "valid-api-key") {
+      throw new UserError("Invalid API key", { code: "invalid_auth" });
+    }
+    return { userId: "user123", token: apiKey };
+  },
+  onWebSocket(ctx, websocket) {
+    ctx.state.connectionCount++;
+    websocket.send(
+      JSON.stringify({
+        type: "welcome",
+        message: "Authenticated WebSocket connection",
+        connectionCount: ctx.state.connectionCount
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      ctx.state.messageCount++;
+      const data = event.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "getAuth") {
+            websocket.send(
+              JSON.stringify({
+                type: "authInfo",
+                authenticated: true
+              })
+            );
+          } else {
+            websocket.send(
+              JSON.stringify({
+                type: "echo",
+                original: parsed
+              })
+            );
+          }
+        } catch {
+          websocket.send(data);
+        }
+      }
+    });
+    websocket.addEventListener("close", () => {
+      ctx.state.connectionCount--;
+    });
+  },
+  actions: {
+    getStats(ctx) {
+      return {
+        connectionCount: ctx.state.connectionCount,
+        messageCount: ctx.state.messageCount
+      };
+    }
+  }
+});
+var rawWebSocketNoAuthActor = actor({
+  state: {
+    connections: 0
+  },
+  onWebSocket(ctx, websocket) {
+    ctx.state.connections++;
+    websocket.send(
+      JSON.stringify({
+        type: "connected",
+        connections: ctx.state.connections
+      })
+    );
+  },
+  actions: {
+    getConnectionCount(ctx) {
+      return ctx.state.connections;
+    }
+  }
+});
+var rawWebSocketPublicActor = actor({
+  state: {
+    visitors: 0
+  },
+  onAuth: () => {
+    return null;
+  },
+  onWebSocket(ctx, websocket) {
+    ctx.state.visitors++;
+    websocket.send(
+      JSON.stringify({
+        type: "welcome",
+        message: "Public WebSocket connection",
+        visitorNumber: ctx.state.visitors
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      websocket.send(event.data);
+    });
+  },
+  actions: {
+    getVisitorCount(ctx) {
+      return ctx.state.visitors;
+    }
+  }
+});
+var rawWebSocketCustomAuthActor = actor({
+  state: {
+    authorized: 0,
+    unauthorized: 0
+  },
+  onAuth: () => {
+    return {};
+  },
+  onWebSocket(ctx, websocket, opts) {
+    const url = new URL(opts.request.url);
+    const token = url.searchParams.get("token");
+    if (!token || token !== "custom-ws-token") {
+      ctx.state.unauthorized++;
+      websocket.send(
+        JSON.stringify({
+          type: "error",
+          message: "Unauthorized"
+        })
+      );
+      websocket.close(1008, "Unauthorized");
+      return;
+    }
+    ctx.state.authorized++;
+    websocket.send(
+      JSON.stringify({
+        type: "authorized",
+        message: "Welcome authenticated user!"
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      websocket.send(
+        JSON.stringify({
+          type: "echo",
+          data: event.data,
+          authenticated: true
+        })
+      );
+    });
+  },
+  actions: {
+    getStats(ctx) {
+      return {
+        authorized: ctx.state.authorized,
+        unauthorized: ctx.state.unauthorized
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/request-access.ts
+var requestAccessActor = actor({
+  onAuth: () => {
+  },
+  // Allow unauthenticated connections
+  state: {
+    // Track request info from different hooks
+    onBeforeConnectRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    createConnStateRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    onFetchRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    onWebSocketRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    }
+  },
+  createConnState: (c, { request }, params) => {
+    return {
+      trackRequest: params?.trackRequest || false,
+      requestInfo: params?.trackRequest && request ? {
+        hasRequest: true,
+        requestUrl: request.url,
+        requestMethod: request.method,
+        requestHeaders: Object.fromEntries(request.headers.entries())
+      } : null
+    };
+  },
+  onConnect: (c, conn) => {
+    if (conn.state.requestInfo) {
+      c.state.createConnStateRequest = conn.state.requestInfo;
+    }
+  },
+  onBeforeConnect: (c, { request }, params) => {
+    if (params?.trackRequest) {
+      if (request) {
+        c.state.onBeforeConnectRequest.hasRequest = true;
+        c.state.onBeforeConnectRequest.requestUrl = request.url;
+        c.state.onBeforeConnectRequest.requestMethod = request.method;
+        const headers = {};
+        request.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        c.state.onBeforeConnectRequest.requestHeaders = headers;
+      } else {
+        c.state.onBeforeConnectRequest.hasRequest = false;
+      }
+    }
+  },
+  onFetch: (c, request) => {
+    c.state.onFetchRequest.hasRequest = true;
+    c.state.onFetchRequest.requestUrl = request.url;
+    c.state.onFetchRequest.requestMethod = request.method;
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    c.state.onFetchRequest.requestHeaders = headers;
+    return new Response(
+      JSON.stringify({
+        hasRequest: true,
+        requestUrl: request.url,
+        requestMethod: request.method,
+        requestHeaders: headers
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  },
+  onWebSocket: (c, websocket, { request }) => {
+    c.state.onWebSocketRequest.hasRequest = true;
+    c.state.onWebSocketRequest.requestUrl = request.url;
+    c.state.onWebSocketRequest.requestMethod = request.method;
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    c.state.onWebSocketRequest.requestHeaders = headers;
+    websocket.send(
+      JSON.stringify({
+        hasRequest: true,
+        requestUrl: request.url,
+        requestMethod: request.method,
+        requestHeaders: headers
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      websocket.send(event.data);
+    });
+  },
+  actions: {
+    getRequestInfo: (c) => {
+      return {
+        onBeforeConnect: c.state.onBeforeConnectRequest,
+        createConnState: c.state.createConnStateRequest,
+        onFetch: c.state.onFetchRequest,
+        onWebSocket: c.state.onWebSocketRequest
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/request-access-auth.ts
+var requestAccessAuthActor = actor({
+  onAuth: ({ request, intents }, params) => {
+    if (params?.trackRequest) {
+      const headers = {};
+      request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      return {
+        hasRequest: true,
+        requestUrl: request.url,
+        requestMethod: request.method,
+        requestHeaders: headers,
+        intents: Array.from(intents)
+      };
+    }
+    return {};
+  },
+  state: {
+    authData: null
+  },
+  onConnect: (c, conn) => {
+    c.state.authData = conn.auth;
+  },
+  actions: {
+    getAuthRequestInfo: (c) => {
+      const authData = c.state.authData || {
+        hasRequest: false,
+        requestUrl: null,
+        requestMethod: null,
+        requestHeaders: {},
+        intents: []
+      };
+      return authData;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/scheduled.ts
+var scheduled = actor({
+  onAuth: () => {
+  },
+  state: {
+    lastRun: 0,
+    scheduledCount: 0,
+    taskHistory: []
+  },
+  actions: {
+    // Schedule using 'at' with specific timestamp
+    scheduleTaskAt: (c, timestamp) => {
+      c.schedule.at(timestamp, "onScheduledTask");
+      return timestamp;
+    },
+    // Schedule using 'after' with delay
+    scheduleTaskAfter: (c, delayMs) => {
+      c.schedule.after(delayMs, "onScheduledTask");
+      return Date.now() + delayMs;
+    },
+    // Schedule with a task ID for ordering tests
+    scheduleTaskAfterWithId: (c, taskId, delayMs) => {
+      c.schedule.after(delayMs, "onScheduledTaskWithId", taskId);
+      return { taskId, scheduledFor: Date.now() + delayMs };
+    },
+    // Original method for backward compatibility
+    scheduleTask: (c, delayMs) => {
+      const timestamp = Date.now() + delayMs;
+      c.schedule.at(timestamp, "onScheduledTask");
+      return timestamp;
+    },
+    // Getters for state
+    getLastRun: (c) => {
+      return c.state.lastRun;
+    },
+    getScheduledCount: (c) => {
+      return c.state.scheduledCount;
+    },
+    getTaskHistory: (c) => {
+      return c.state.taskHistory;
+    },
+    clearHistory: (c) => {
+      c.state.taskHistory = [];
+      c.state.scheduledCount = 0;
+      c.state.lastRun = 0;
+      return true;
+    },
+    // Scheduled task handlers
+    onScheduledTask: (c) => {
+      c.state.lastRun = Date.now();
+      c.state.scheduledCount++;
+      c.broadcast("scheduled", {
+        time: c.state.lastRun,
+        count: c.state.scheduledCount
+      });
+    },
+    onScheduledTaskWithId: (c, taskId) => {
+      c.state.lastRun = Date.now();
+      c.state.scheduledCount++;
+      c.state.taskHistory.push(taskId);
+      c.broadcast("scheduledWithId", {
+        taskId,
+        time: c.state.lastRun,
+        count: c.state.scheduledCount
+      });
+    }
+  }
+});
+
+// fixtures/driver-test-suite/sleep.ts
+var SLEEP_TIMEOUT = 500;
+var sleep = actor({
+  onAuth: () => {
+  },
+  state: { startCount: 0, sleepCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    triggerSleep: (c) => {
+      c.sleep();
+    },
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    },
+    setAlarm: async (c, duration) => {
+      await c.schedule.after(duration, "onAlarm");
+    },
+    onAlarm: (c) => {
+      c.log.info("alarm called");
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithLongRpc = actor({
+  onAuth: () => {
+  },
+  state: { startCount: 0, sleepCount: 0 },
+  createVars: () => ({}),
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    },
+    longRunningRpc: async (c) => {
+      c.log.info("starting long running rpc");
+      c.vars.longRunningResolve = Promise.withResolvers();
+      c.broadcast("waiting");
+      await c.vars.longRunningResolve.promise;
+      c.log.info("finished long running rpc");
+    },
+    finishLongRunningRpc: (c) => c.vars.longRunningResolve?.resolve()
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawHttp = actor({
+  onAuth: () => {
+  },
+  state: { startCount: 0, sleepCount: 0, requestCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onFetch: async (c, request) => {
+    c.state.requestCount += 1;
+    const url = new URL(request.url);
+    if (url.pathname === "/long-request") {
+      const duration = parseInt(url.searchParams.get("duration") || "1000");
+      c.log.info("starting long fetch request", { duration });
+      await new Promise((resolve) => setTimeout(resolve, duration));
+      c.log.info("finished long fetch request");
+      return new Response(JSON.stringify({ completed: true }), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        requestCount: c.state.requestCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithRawWebSocket = actor({
+  onAuth: () => {
+  },
+  state: { startCount: 0, sleepCount: 0, connectionCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  onWebSocket: (c, websocket, opts) => {
+    c.state.connectionCount += 1;
+    c.log.info("websocket connected", {
+      connectionCount: c.state.connectionCount
+    });
+    websocket.send(
+      JSON.stringify({
+        type: "connected",
+        connectionCount: c.state.connectionCount
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      const data = event.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "getCounts") {
+            websocket.send(
+              JSON.stringify({
+                type: "counts",
+                startCount: c.state.startCount,
+                sleepCount: c.state.sleepCount,
+                connectionCount: c.state.connectionCount
+              })
+            );
+          } else if (parsed.type === "keepAlive") {
+            websocket.send(JSON.stringify({ type: "ack" }));
+          }
+        } catch {
+          websocket.send(data);
+        }
+      }
+    });
+    websocket.addEventListener("close", () => {
+      c.state.connectionCount -= 1;
+      c.log.info("websocket disconnected", {
+        connectionCount: c.state.connectionCount
+      });
+    });
+  },
+  actions: {
+    getCounts: (c) => {
+      return {
+        startCount: c.state.startCount,
+        sleepCount: c.state.sleepCount,
+        connectionCount: c.state.connectionCount
+      };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT
+  }
+});
+var sleepWithNoSleepOption = actor({
+  onAuth: () => {
+  },
+  state: { startCount: 0, sleepCount: 0 },
+  onStart: (c) => {
+    c.state.startCount += 1;
+  },
+  onStop: (c) => {
+    c.state.sleepCount += 1;
+  },
+  actions: {
+    getCounts: (c) => {
+      return { startCount: c.state.startCount, sleepCount: c.state.sleepCount };
+    }
+  },
+  options: {
+    sleepTimeout: SLEEP_TIMEOUT,
+    noSleep: true
+  }
+});
+
+// fixtures/driver-test-suite/vars.ts
+var staticVarActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  connState: { hello: "world" },
+  vars: { counter: 42, name: "test-actor" },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    },
+    getName: (c) => {
+      return c.vars.name;
+    }
+  }
+});
+var nestedVarActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  connState: { hello: "world" },
+  vars: {
+    counter: 42,
+    nested: {
+      value: "original",
+      array: [1, 2, 3],
+      obj: { key: "value" }
+    }
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    },
+    modifyNested: (c) => {
+      c.vars.nested.value = "modified";
+      c.vars.nested.array.push(4);
+      c.vars.nested.obj.key = "new-value";
+      return c.vars;
+    }
+  }
+});
+var dynamicVarActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: () => {
+    return {
+      random: Math.random(),
+      computed: `Actor-${Math.floor(Math.random() * 1e3)}`
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+var uniqueVarActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: () => {
+    return {
+      id: Math.floor(Math.random() * 1e6)
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+var driverCtxActor = actor({
+  onAuth: () => {
+  },
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: (c, driverCtx) => {
+    return {
+      hasDriverCtx: Boolean(driverCtx?.isTest)
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/registry.ts
+var registry = setup({
+  use: {
+    // From counter.ts
+    counter,
+    // From lifecycle.ts
+    counterWithLifecycle,
+    // From scheduled.ts
+    scheduled,
+    // From sleep.ts
+    sleep,
+    sleepWithLongRpc,
+    sleepWithRawHttp,
+    sleepWithRawWebSocket,
+    sleepWithNoSleepOption,
+    // From error-handling.ts
+    errorHandlingActor,
+    customTimeoutActor,
+    // From inline-client.ts
+    inlineClientActor,
+    // From action-inputs.ts
+    inputActor,
+    // From action-timeout.ts
+    shortTimeoutActor,
+    longTimeoutActor,
+    defaultTimeoutActor,
+    syncTimeoutActor,
+    // From action-types.ts
+    syncActionActor,
+    asyncActionActor,
+    promiseActor,
+    // From conn-params.ts
+    counterWithParams,
+    // From conn-state.ts
+    connStateActor,
+    // From actor-conn.ts
+    connLivenessActor,
+    // From metadata.ts
+    metadataActor,
+    // From vars.ts
+    staticVarActor,
+    nestedVarActor,
+    dynamicVarActor,
+    uniqueVarActor,
+    driverCtxActor,
+    // From auth.ts
+    authActor,
+    intentAuthActor,
+    publicActor,
+    noAuthActor,
+    asyncAuthActor,
+    // From raw-http.ts
+    rawHttpActor,
+    rawHttpNoHandlerActor,
+    rawHttpVoidReturnActor,
+    rawHttpHonoActor,
+    // From raw-http-auth.ts
+    rawHttpAuthActor,
+    rawHttpNoAuthActor,
+    rawHttpPublicActor,
+    rawHttpCustomAuthActor,
+    // From raw-http-request-properties.ts
+    rawHttpRequestPropertiesActor,
+    // From raw-websocket.ts
+    rawWebSocketActor,
+    rawWebSocketBinaryActor,
+    // From raw-websocket-auth.ts
+    rawWebSocketAuthActor,
+    rawWebSocketNoAuthActor,
+    rawWebSocketPublicActor,
+    rawWebSocketCustomAuthActor,
+    // From request-access.ts
+    requestAccessActor,
+    requestAccessAuthActor,
+    // From actor-onstatechange.ts
+    onStateChangeActor
+  }
+});
+export {
+  registry
+};
+//! These configs configs hold anything that's not platform-specific about running actors.
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["src/actor/connection.ts", "src/common/versioned-data.ts", "dist/schemas/client-protocol/v1.ts", "src/schemas/client-protocol/versioned.ts", "src/actor/errors.ts", "src/common/utils.ts", "package.json", "src/utils.ts", "src/common/log-levels.ts", "src/common/logfmt.ts", "src/common/log.ts", "src/actor/log.ts", "src/actor/protocol/serde.ts", "src/serde.ts", "src/actor/utils.ts", "src/actor/config.ts", "src/actor/instance.ts", "src/inspector/actor.ts", "src/inspector/protocol/common.ts", "src/manager/protocol/query.ts", "src/actor/router-endpoints.ts", "src/actor/action.ts", "src/manager/log.ts", "src/manager/hono-websocket-adapter.ts", "src/actor/protocol/old.ts", "dist/schemas/actor-persist/v1.ts", "src/schemas/actor-persist/versioned.ts", "src/actor/context.ts", "src/actor/schedule.ts", "src/actor/definition.ts", "src/actor/generic-conn-driver.ts", "src/actor/router.ts", "src/common/router.ts", "src/inspector/utils.ts", "src/inspector/log.ts", "src/actor/mod.ts", "src/client/actor-conn.ts", "src/client/errors.ts", "src/client/log.ts", "src/client/utils.ts", "src/client/actor-handle.ts", "src/client/raw-utils.ts", "src/client/client.ts", "src/common/inline-websocket-adapter2.ts", "src/drivers/engine/actor-driver.ts", "src/registry/run-config.ts", "src/inspector/config.ts", "src/driver-helpers/utils.ts", "src/drivers/engine/keys.ts", "src/drivers/engine/kv.ts", "src/drivers/engine/log.ts", "src/drivers/engine/config.ts", "src/drivers/engine/manager-driver.ts", "src/common/websocket.ts", "src/drivers/engine/api-utils.ts", "src/drivers/engine/api-endpoints.ts", "src/drivers/engine/ws-proxy.ts", "src/drivers/engine/mod.ts", "src/drivers/file-system/actor.ts", "src/drivers/file-system/global-state.ts", "dist/schemas/file-system-driver/v1.ts", "src/schemas/file-system-driver/versioned.ts", "src/drivers/file-system/log.ts", "src/drivers/file-system/utils.ts", "src/drivers/file-system/manager.ts", "src/inline-client-driver/mod.ts", "src/common/eventsource.ts", "src/inline-client-driver/log.ts", "src/inspector/manager.ts", "src/drivers/file-system/mod.ts", "src/drivers/default.ts", "src/manager/router.ts", "src/manager/auth.ts", "src/registry/config.ts", "src/registry/log.ts", "src/registry/serve.ts", "src/registry/mod.ts", "fixtures/driver-test-suite/action-inputs.ts", "fixtures/driver-test-suite/action-timeout.ts", "fixtures/driver-test-suite/action-types.ts", "fixtures/driver-test-suite/actor-onstatechange.ts", "fixtures/driver-test-suite/auth.ts", "fixtures/driver-test-suite/conn-liveness.ts", "fixtures/driver-test-suite/conn-params.ts", "fixtures/driver-test-suite/conn-state.ts", "fixtures/driver-test-suite/counter.ts", "fixtures/driver-test-suite/error-handling.ts", "fixtures/driver-test-suite/inline-client.ts", "fixtures/driver-test-suite/lifecycle.ts", "fixtures/driver-test-suite/metadata.ts", "fixtures/driver-test-suite/raw-http.ts", "fixtures/driver-test-suite/raw-http-auth.ts", "fixtures/driver-test-suite/raw-http-request-properties.ts", "fixtures/driver-test-suite/raw-websocket.ts", "fixtures/driver-test-suite/raw-websocket-auth.ts", "fixtures/driver-test-suite/request-access.ts", "fixtures/driver-test-suite/request-access-auth.ts", "fixtures/driver-test-suite/scheduled.ts", "fixtures/driver-test-suite/sleep.ts", "fixtures/driver-test-suite/vars.ts", "fixtures/driver-test-suite/registry.ts"],
  "sourcesContent": ["const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/connection.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/connection.ts\";import * as cbor from \"cbor-x\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport { TO_CLIENT_VERSIONED } from \"@/schemas/client-protocol/versioned\";\nimport { bufferToArrayBuffer } from \"@/utils\";\nimport type { AnyDatabaseProvider } from \"./database\";\nimport { type ConnDriver, ConnectionReadyState } from \"./driver\";\nimport * as errors from \"./errors\";\nimport type { ActorInstance } from \"./instance\";\nimport { logger } from \"./log\";\nimport type { PersistedConn } from \"./persisted\";\nimport { CachedSerializer } from \"./protocol/serde\";\nimport { generateSecureToken } from \"./utils\";\n\nexport function generateConnId(): string {\n\treturn crypto.randomUUID();\n}\n\nexport function generateConnToken(): string {\n\treturn generateSecureToken(32);\n}\n\nexport type ConnId = string;\n\nexport type AnyConn = Conn<any, any, any, any, any, any, any>;\n\nexport const CONNECTION_DRIVER_WEBSOCKET = \"webSocket\";\nexport const CONNECTION_DRIVER_SSE = \"sse\";\nexport const CONNECTION_DRIVER_HTTP = \"http\";\n\nexport type ConnectionDriver =\n\t| typeof CONNECTION_DRIVER_WEBSOCKET\n\t| typeof CONNECTION_DRIVER_SSE\n\t| typeof CONNECTION_DRIVER_HTTP;\n\nexport type ConnectionStatus = \"connected\" | \"reconnecting\";\n\nexport const CONNECTION_CHECK_LIVENESS_SYMBOL = Symbol(\"checkLiveness\");\n\n/**\n * Represents a client connection to a actor.\n *\n * Manages connection-specific data and controls the connection lifecycle.\n *\n * @see {@link https://rivet.gg/docs/connections|Connection Documentation}\n */\nexport class Conn<S, CP, CS, V, I, AD, DB extends AnyDatabaseProvider> {\n\tsubscriptions: Set<string> = new Set<string>();\n\n\t#stateEnabled: boolean;\n\n\t// TODO: Remove this cyclical reference\n\t#actor: ActorInstance<S, CP, CS, V, I, AD, DB>;\n\n\t#status: ConnectionStatus = \"connected\";\n\n\t/**\n\t * The proxied state that notifies of changes automatically.\n\t *\n\t * Any data that should be stored indefinitely should be held within this object.\n\t */\n\t__persist: PersistedConn<CP, CS>;\n\n\t/**\n\t * Driver used to manage realtime connection communication.\n\t *\n\t * @protected\n\t */\n\t#driver: ConnDriver;\n\n\tpublic get params(): CP {\n\t\treturn this.__persist.params;\n\t}\n\n\tpublic get auth(): AD {\n\t\treturn this.__persist.authData as AD;\n\t}\n\n\tpublic get driver(): ConnectionDriver {\n\t\treturn this.__persist.connDriver as ConnectionDriver;\n\t}\n\n\tpublic get _stateEnabled() {\n\t\treturn this.#stateEnabled;\n\t}\n\n\t/**\n\t * Gets the current state of the connection.\n\t *\n\t * Throws an error if the state is not enabled.\n\t */\n\tpublic get state(): CS {\n\t\tthis.#validateStateEnabled();\n\t\tif (!this.__persist.state) throw new Error(\"state should exists\");\n\t\treturn this.__persist.state;\n\t}\n\n\t/**\n\t * Sets the state of the connection.\n\t *\n\t * Throws an error if the state is not enabled.\n\t */\n\tpublic set state(value: CS) {\n\t\tthis.#validateStateEnabled();\n\t\tthis.__persist.state = value;\n\t}\n\n\t/**\n\t * Unique identifier for the connection.\n\t */\n\tpublic get id(): ConnId {\n\t\treturn this.__persist.connId;\n\t}\n\n\t/**\n\t * Token used to authenticate this request.\n\t */\n\tpublic get _token(): string {\n\t\treturn this.__persist.token;\n\t}\n\n\t/**\n\t * Status of the connection.\n\t */\n\tpublic get status(): ConnectionStatus {\n\t\treturn this.#status;\n\t}\n\n\t/**\n\t * Timestamp of the last time the connection was seen, i.e. the last time the connection was active and checked for liveness.\n\t */\n\tpublic get lastSeen(): number {\n\t\treturn this.__persist.lastSeen;\n\t}\n\n\t/**\n\t * Initializes a new instance of the Connection class.\n\t *\n\t * This should only be constructed by {@link Actor}.\n\t *\n\t * @protected\n\t */\n\tpublic constructor(\n\t\tactor: ActorInstance<S, CP, CS, V, I, AD, DB>,\n\t\tpersist: PersistedConn<CP, CS>,\n\t\tdriver: ConnDriver,\n\t\tstateEnabled: boolean,\n\t) {\n\t\tthis.#actor = actor;\n\t\tthis.__persist = persist;\n\t\tthis.#driver = driver;\n\t\tthis.#stateEnabled = stateEnabled;\n\t}\n\n\t#validateStateEnabled() {\n\t\tif (!this.#stateEnabled) {\n\t\t\tthrow new errors.ConnStateNotEnabled();\n\t\t}\n\t}\n\n\t/**\n\t * Sends a WebSocket message to the client.\n\t *\n\t * @param message - The message to send.\n\t *\n\t * @protected\n\t */\n\tpublic _sendMessage(message: CachedSerializer<protocol.ToClient>) {\n\t\tthis.#driver.sendMessage?.(\n\t\t\tthis.#actor,\n\t\t\tthis,\n\t\t\tthis.__persist.connDriverState,\n\t\t\tmessage,\n\t\t);\n\t}\n\n\t/**\n\t * Sends an event with arguments to the client.\n\t *\n\t * @param eventName - The name of the event.\n\t * @param args - The arguments for the event.\n\t * @see {@link https://rivet.gg/docs/events|Events Documentation}\n\t */\n\tpublic send(eventName: string, ...args: unknown[]) {\n\t\tthis.#actor.inspector.emitter.emit(\"eventFired\", {\n\t\t\ttype: \"event\",\n\t\t\teventName,\n\t\t\targs,\n\t\t\tconnId: this.id,\n\t\t});\n\t\tthis._sendMessage(\n\t\t\tnew CachedSerializer<protocol.ToClient>(\n\t\t\t\t{\n\t\t\t\t\tbody: {\n\t\t\t\t\t\ttag: \"Event\",\n\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\tname: eventName,\n\t\t\t\t\t\t\targs: bufferToArrayBuffer(cbor.encode(args)),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t),\n\t\t);\n\t}\n\n\t/**\n\t * Disconnects the client with an optional reason.\n\t *\n\t * @param reason - The reason for disconnection.\n\t */\n\tpublic async disconnect(reason?: string) {\n\t\tthis.#status = \"reconnecting\";\n\t\tawait this.#driver.disconnect(\n\t\t\tthis.#actor,\n\t\t\tthis,\n\t\t\tthis.__persist.connDriverState,\n\t\t\treason,\n\t\t);\n\t}\n\n\t/**\n\t * This method checks the connection's liveness by querying the driver for its ready state.\n\t * If the connection is not closed, it updates the last liveness timestamp and returns `true`.\n\t * Otherwise, it returns `false`.\n\t * @internal\n\t */\n\t[CONNECTION_CHECK_LIVENESS_SYMBOL]() {\n\t\tconst readyState = this.#driver.getConnectionReadyState(this.#actor, this);\n\n\t\tconst isConnectionClosed =\n\t\t\treadyState === ConnectionReadyState.CLOSED ||\n\t\t\treadyState === ConnectionReadyState.CLOSING ||\n\t\t\treadyState === undefined;\n\n\t\tconst newLastSeen = Date.now();\n\t\tconst newStatus = isConnectionClosed ? \"reconnecting\" : \"connected\";\n\n\t\tlogger().debug(\"liveness probe for connection\", {\n\t\t\tconnId: this.id,\n\t\t\tactorId: this.#actor.id,\n\t\t\treadyState,\n\n\t\t\tstatus: this.#status,\n\t\t\tnewStatus,\n\n\t\t\tlastSeen: this.__persist.lastSeen,\n\t\t\tcurrentTs: newLastSeen,\n\t\t});\n\n\t\tif (!isConnectionClosed) {\n\t\t\tthis.__persist.lastSeen = newLastSeen;\n\t\t}\n\n\t\tthis.#status = newStatus;\n\t\treturn {\n\t\t\tstatus: this.#status,\n\t\t\tlastSeen: this.__persist.lastSeen,\n\t\t};\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/versioned-data.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/versioned-data.ts\";export interface VersionedData<T> {\n\tversion: number;\n\tdata: T;\n}\n\nexport type MigrationFn<TFrom, TTo> = (data: TFrom) => TTo;\n\nexport interface VersionedDataConfig<T> {\n\tcurrentVersion: number;\n\tmigrations: Map<number, MigrationFn<any, any>>;\n\tserializeVersion: (data: T) => Uint8Array;\n\tdeserializeVersion: (bytes: Uint8Array) => T;\n}\n\nexport class VersionedDataHandler<T> {\n\tconstructor(private config: VersionedDataConfig<T>) {}\n\n\tserializeWithEmbeddedVersion(data: T): Uint8Array {\n\t\tconst versioned: VersionedData<Uint8Array> = {\n\t\t\tversion: this.config.currentVersion,\n\t\t\tdata: this.config.serializeVersion(data),\n\t\t};\n\n\t\treturn this.embedVersion(versioned);\n\t}\n\n\tdeserializeWithEmbeddedVersion(bytes: Uint8Array): T {\n\t\tconst versioned = this.extractVersion(bytes);\n\t\treturn this.deserialize(versioned.data, versioned.version);\n\t}\n\n\tserialize(data: T, version: number): Uint8Array {\n\t\treturn this.config.serializeVersion(data);\n\t}\n\n\tdeserialize(bytes: Uint8Array, version: number): T {\n\t\tif (version === this.config.currentVersion) {\n\t\t\treturn this.config.deserializeVersion(bytes);\n\t\t}\n\n\t\tif (version > this.config.currentVersion) {\n\t\t\tthrow new Error(\n\t\t\t\t`Cannot decode data from version ${version}, current version is ${this.config.currentVersion}`,\n\t\t\t);\n\t\t}\n\n\t\tlet currentData: any = this.config.deserializeVersion(bytes);\n\t\tlet currentVersion = version;\n\n\t\twhile (currentVersion < this.config.currentVersion) {\n\t\t\tconst migration = this.config.migrations.get(currentVersion);\n\t\t\tif (!migration) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`No migration found from version ${currentVersion} to ${currentVersion + 1}`,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\tcurrentData = migration(currentData);\n\t\t\tcurrentVersion++;\n\t\t}\n\n\t\treturn currentData;\n\t}\n\n\tprivate embedVersion(data: VersionedData<Uint8Array>): Uint8Array {\n\t\tconst versionBytes = new Uint8Array(4);\n\t\tnew DataView(versionBytes.buffer).setUint32(0, data.version, true);\n\n\t\tconst result = new Uint8Array(versionBytes.length + data.data.length);\n\t\tresult.set(versionBytes);\n\t\tresult.set(data.data, versionBytes.length);\n\n\t\treturn result;\n\t}\n\n\tprivate extractVersion(bytes: Uint8Array): VersionedData<Uint8Array> {\n\t\tif (bytes.length < 4) {\n\t\t\tthrow new Error(\"Invalid versioned data: too short\");\n\t\t}\n\n\t\tconst version = new DataView(bytes.buffer, bytes.byteOffset).getUint32(\n\t\t\t0,\n\t\t\ttrue,\n\t\t);\n\t\tconst data = bytes.slice(4);\n\n\t\treturn { version, data };\n\t}\n}\n\nexport function createVersionedDataHandler<T>(\n\tconfig: VersionedDataConfig<T>,\n): VersionedDataHandler<T> {\n\treturn new VersionedDataHandler(config);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/client-protocol/v1.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/client-protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/dist/schemas/client-protocol/v1.ts\";import * as bare from \"@bare-ts/lib\"\n\nconst config = /* @__PURE__ */ bare.Config({})\n\nexport type uint = bigint\n\nexport type Init = {\n    readonly actorId: string,\n    readonly connectionId: string,\n    readonly connectionToken: string,\n}\n\nexport function readInit(bc: bare.ByteCursor): Init {\n    return {\n        actorId: bare.readString(bc),\n        connectionId: bare.readString(bc),\n        connectionToken: bare.readString(bc),\n    }\n}\n\nexport function writeInit(bc: bare.ByteCursor, x: Init): void {\n    bare.writeString(bc, x.actorId)\n    bare.writeString(bc, x.connectionId)\n    bare.writeString(bc, x.connectionToken)\n}\n\nfunction read0(bc: bare.ByteCursor): ArrayBuffer | null {\n    return bare.readBool(bc)\n        ? bare.readData(bc)\n        : null\n}\n\nfunction write0(bc: bare.ByteCursor, x: ArrayBuffer | null): void {\n    bare.writeBool(bc, x !== null)\n    if (x !== null) {\n        bare.writeData(bc, x)\n    }\n}\n\nfunction read1(bc: bare.ByteCursor): uint | null {\n    return bare.readBool(bc)\n        ? bare.readUint(bc)\n        : null\n}\n\nfunction write1(bc: bare.ByteCursor, x: uint | null): void {\n    bare.writeBool(bc, x !== null)\n    if (x !== null) {\n        bare.writeUint(bc, x)\n    }\n}\n\nexport type Error = {\n    readonly code: string,\n    readonly message: string,\n    readonly metadata: ArrayBuffer | null,\n    readonly actionId: uint | null,\n}\n\nexport function readError(bc: bare.ByteCursor): Error {\n    return {\n        code: bare.readString(bc),\n        message: bare.readString(bc),\n        metadata: read0(bc),\n        actionId: read1(bc),\n    }\n}\n\nexport function writeError(bc: bare.ByteCursor, x: Error): void {\n    bare.writeString(bc, x.code)\n    bare.writeString(bc, x.message)\n    write0(bc, x.metadata)\n    write1(bc, x.actionId)\n}\n\nexport type ActionResponse = {\n    readonly id: uint,\n    readonly output: ArrayBuffer,\n}\n\nexport function readActionResponse(bc: bare.ByteCursor): ActionResponse {\n    return {\n        id: bare.readUint(bc),\n        output: bare.readData(bc),\n    }\n}\n\nexport function writeActionResponse(bc: bare.ByteCursor, x: ActionResponse): void {\n    bare.writeUint(bc, x.id)\n    bare.writeData(bc, x.output)\n}\n\nexport type Event = {\n    readonly name: string,\n    readonly args: ArrayBuffer,\n}\n\nexport function readEvent(bc: bare.ByteCursor): Event {\n    return {\n        name: bare.readString(bc),\n        args: bare.readData(bc),\n    }\n}\n\nexport function writeEvent(bc: bare.ByteCursor, x: Event): void {\n    bare.writeString(bc, x.name)\n    bare.writeData(bc, x.args)\n}\n\nexport type ToClientBody =\n    | { readonly tag: \"Init\", readonly val: Init }\n    | { readonly tag: \"Error\", readonly val: Error }\n    | { readonly tag: \"ActionResponse\", readonly val: ActionResponse }\n    | { readonly tag: \"Event\", readonly val: Event }\n\nexport function readToClientBody(bc: bare.ByteCursor): ToClientBody {\n    const offset = bc.offset\n    const tag = bare.readU8(bc)\n    switch (tag) {\n        case 0:\n            return { tag: \"Init\", val: readInit(bc) }\n        case 1:\n            return { tag: \"Error\", val: readError(bc) }\n        case 2:\n            return { tag: \"ActionResponse\", val: readActionResponse(bc) }\n        case 3:\n            return { tag: \"Event\", val: readEvent(bc) }\n        default: {\n            bc.offset = offset\n            throw new bare.BareError(offset, \"invalid tag\")\n        }\n    }\n}\n\nexport function writeToClientBody(bc: bare.ByteCursor, x: ToClientBody): void {\n    switch (x.tag) {\n        case \"Init\": {\n            bare.writeU8(bc, 0)\n            writeInit(bc, x.val)\n            break\n        }\n        case \"Error\": {\n            bare.writeU8(bc, 1)\n            writeError(bc, x.val)\n            break\n        }\n        case \"ActionResponse\": {\n            bare.writeU8(bc, 2)\n            writeActionResponse(bc, x.val)\n            break\n        }\n        case \"Event\": {\n            bare.writeU8(bc, 3)\n            writeEvent(bc, x.val)\n            break\n        }\n    }\n}\n\nexport type ToClient = {\n    readonly body: ToClientBody,\n}\n\nexport function readToClient(bc: bare.ByteCursor): ToClient {\n    return {\n        body: readToClientBody(bc),\n    }\n}\n\nexport function writeToClient(bc: bare.ByteCursor, x: ToClient): void {\n    writeToClientBody(bc, x.body)\n}\n\nexport function encodeToClient(x: ToClient): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeToClient(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeToClient(bytes: Uint8Array): ToClient {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readToClient(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type ActionRequest = {\n    readonly id: uint,\n    readonly name: string,\n    readonly args: ArrayBuffer,\n}\n\nexport function readActionRequest(bc: bare.ByteCursor): ActionRequest {\n    return {\n        id: bare.readUint(bc),\n        name: bare.readString(bc),\n        args: bare.readData(bc),\n    }\n}\n\nexport function writeActionRequest(bc: bare.ByteCursor, x: ActionRequest): void {\n    bare.writeUint(bc, x.id)\n    bare.writeString(bc, x.name)\n    bare.writeData(bc, x.args)\n}\n\nexport type SubscriptionRequest = {\n    readonly eventName: string,\n    readonly subscribe: boolean,\n}\n\nexport function readSubscriptionRequest(bc: bare.ByteCursor): SubscriptionRequest {\n    return {\n        eventName: bare.readString(bc),\n        subscribe: bare.readBool(bc),\n    }\n}\n\nexport function writeSubscriptionRequest(bc: bare.ByteCursor, x: SubscriptionRequest): void {\n    bare.writeString(bc, x.eventName)\n    bare.writeBool(bc, x.subscribe)\n}\n\nexport type ToServerBody =\n    | { readonly tag: \"ActionRequest\", readonly val: ActionRequest }\n    | { readonly tag: \"SubscriptionRequest\", readonly val: SubscriptionRequest }\n\nexport function readToServerBody(bc: bare.ByteCursor): ToServerBody {\n    const offset = bc.offset\n    const tag = bare.readU8(bc)\n    switch (tag) {\n        case 0:\n            return { tag: \"ActionRequest\", val: readActionRequest(bc) }\n        case 1:\n            return { tag: \"SubscriptionRequest\", val: readSubscriptionRequest(bc) }\n        default: {\n            bc.offset = offset\n            throw new bare.BareError(offset, \"invalid tag\")\n        }\n    }\n}\n\nexport function writeToServerBody(bc: bare.ByteCursor, x: ToServerBody): void {\n    switch (x.tag) {\n        case \"ActionRequest\": {\n            bare.writeU8(bc, 0)\n            writeActionRequest(bc, x.val)\n            break\n        }\n        case \"SubscriptionRequest\": {\n            bare.writeU8(bc, 1)\n            writeSubscriptionRequest(bc, x.val)\n            break\n        }\n    }\n}\n\nexport type ToServer = {\n    readonly body: ToServerBody,\n}\n\nexport function readToServer(bc: bare.ByteCursor): ToServer {\n    return {\n        body: readToServerBody(bc),\n    }\n}\n\nexport function writeToServer(bc: bare.ByteCursor, x: ToServer): void {\n    writeToServerBody(bc, x.body)\n}\n\nexport function encodeToServer(x: ToServer): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeToServer(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeToServer(bytes: Uint8Array): ToServer {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readToServer(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type HttpActionRequest = {\n    readonly args: ArrayBuffer,\n}\n\nexport function readHttpActionRequest(bc: bare.ByteCursor): HttpActionRequest {\n    return {\n        args: bare.readData(bc),\n    }\n}\n\nexport function writeHttpActionRequest(bc: bare.ByteCursor, x: HttpActionRequest): void {\n    bare.writeData(bc, x.args)\n}\n\nexport function encodeHttpActionRequest(x: HttpActionRequest): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeHttpActionRequest(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeHttpActionRequest(bytes: Uint8Array): HttpActionRequest {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readHttpActionRequest(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type HttpActionResponse = {\n    readonly output: ArrayBuffer,\n}\n\nexport function readHttpActionResponse(bc: bare.ByteCursor): HttpActionResponse {\n    return {\n        output: bare.readData(bc),\n    }\n}\n\nexport function writeHttpActionResponse(bc: bare.ByteCursor, x: HttpActionResponse): void {\n    bare.writeData(bc, x.output)\n}\n\nexport function encodeHttpActionResponse(x: HttpActionResponse): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeHttpActionResponse(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeHttpActionResponse(bytes: Uint8Array): HttpActionResponse {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readHttpActionResponse(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type HttpResponseError = {\n    readonly code: string,\n    readonly message: string,\n    readonly metadata: ArrayBuffer | null,\n}\n\nexport function readHttpResponseError(bc: bare.ByteCursor): HttpResponseError {\n    return {\n        code: bare.readString(bc),\n        message: bare.readString(bc),\n        metadata: read0(bc),\n    }\n}\n\nexport function writeHttpResponseError(bc: bare.ByteCursor, x: HttpResponseError): void {\n    bare.writeString(bc, x.code)\n    bare.writeString(bc, x.message)\n    write0(bc, x.metadata)\n}\n\nexport function encodeHttpResponseError(x: HttpResponseError): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeHttpResponseError(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeHttpResponseError(bytes: Uint8Array): HttpResponseError {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readHttpResponseError(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type HttpResolveRequest = null\n\nexport type HttpResolveResponse = {\n    readonly actorId: string,\n}\n\nexport function readHttpResolveResponse(bc: bare.ByteCursor): HttpResolveResponse {\n    return {\n        actorId: bare.readString(bc),\n    }\n}\n\nexport function writeHttpResolveResponse(bc: bare.ByteCursor, x: HttpResolveResponse): void {\n    bare.writeString(bc, x.actorId)\n}\n\nexport function encodeHttpResolveResponse(x: HttpResolveResponse): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeHttpResolveResponse(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeHttpResolveResponse(bytes: Uint8Array): HttpResolveResponse {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readHttpResolveResponse(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/client-protocol/versioned.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/client-protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/schemas/client-protocol/versioned.ts\";import {\n\tcreateVersionedDataHandler,\n\ttype MigrationFn,\n} from \"@/common/versioned-data\";\nimport * as v1 from \"../../../dist/schemas/client-protocol/v1\";\n\nexport const CURRENT_VERSION = 1;\n\nconst migrations = new Map<number, MigrationFn<any, any>>();\n\nexport const TO_SERVER_VERSIONED = createVersionedDataHandler<v1.ToServer>({\n\tcurrentVersion: CURRENT_VERSION,\n\tmigrations,\n\tserializeVersion: (data) => v1.encodeToServer(data),\n\tdeserializeVersion: (bytes) => v1.decodeToServer(bytes),\n});\n\nexport const TO_CLIENT_VERSIONED = createVersionedDataHandler<v1.ToClient>({\n\tcurrentVersion: CURRENT_VERSION,\n\tmigrations,\n\tserializeVersion: (data) => v1.encodeToClient(data),\n\tdeserializeVersion: (bytes) => v1.decodeToClient(bytes),\n});\n\nexport const HTTP_ACTION_REQUEST_VERSIONED =\n\tcreateVersionedDataHandler<v1.HttpActionRequest>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeHttpActionRequest(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeHttpActionRequest(bytes),\n\t});\n\nexport const HTTP_ACTION_RESPONSE_VERSIONED =\n\tcreateVersionedDataHandler<v1.HttpActionResponse>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeHttpActionResponse(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeHttpActionResponse(bytes),\n\t});\n\nexport const HTTP_RESPONSE_ERROR_VERSIONED =\n\tcreateVersionedDataHandler<v1.HttpResponseError>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeHttpResponseError(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeHttpResponseError(bytes),\n\t});\n\nexport const HTTP_RESOLVE_REQUEST_VERSIONED =\n\tcreateVersionedDataHandler<v1.HttpResolveRequest>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (_) => new Uint8Array(),\n\t\tdeserializeVersion: (bytes) => null,\n\t});\n\nexport const HTTP_RESOLVE_RESPONSE_VERSIONED =\n\tcreateVersionedDataHandler<v1.HttpResolveResponse>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeHttpResolveResponse(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeHttpResolveResponse(bytes),\n\t});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/errors.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/errors.ts\";import type { DeconstructedError } from \"@/common/utils\";\n\nexport const INTERNAL_ERROR_CODE = \"internal_error\";\nexport const INTERNAL_ERROR_DESCRIPTION =\n\t\"Internal error. Read the server logs for more details.\";\nexport type InternalErrorMetadata = {};\n\nexport const USER_ERROR_CODE = \"user_error\";\n\ninterface ActorErrorOptions extends ErrorOptions {\n\t/** Error data can safely be serialized in a response to the client. */\n\tpublic?: boolean;\n\t/** Metadata associated with this error. This will be sent to clients. */\n\tmetadata?: unknown;\n}\n\nexport class ActorError extends Error {\n\t__type = \"ActorError\";\n\n\tpublic public: boolean;\n\tpublic metadata?: unknown;\n\tpublic statusCode = 500;\n\n\tpublic static isActorError(\n\t\terror: unknown,\n\t): error is ActorError | DeconstructedError {\n\t\treturn (\n\t\t\ttypeof error === \"object\" &&\n\t\t\t(error as ActorError | DeconstructedError).__type === \"ActorError\"\n\t\t);\n\t}\n\n\tconstructor(\n\t\tpublic readonly code: string,\n\t\tmessage: string,\n\t\topts?: ActorErrorOptions,\n\t) {\n\t\tsuper(message, { cause: opts?.cause });\n\t\tthis.public = opts?.public ?? false;\n\t\tthis.metadata = opts?.metadata;\n\n\t\t// Set status code based on error type\n\t\tif (opts?.public) {\n\t\t\tthis.statusCode = 400; // Bad request for public errors\n\t\t}\n\t}\n\n\ttoString() {\n\t\t// Force stringify to return the message\n\t\treturn this.message;\n\t}\n\n\t/**\n\t * Serialize error for HTTP response\n\t */\n\tserializeForHttp() {\n\t\treturn {\n\t\t\ttype: this.code,\n\t\t\tmessage: this.message,\n\t\t\tmetadata: this.metadata,\n\t\t};\n\t}\n}\n\nexport class InternalError extends ActorError {\n\tconstructor(message: string) {\n\t\tsuper(INTERNAL_ERROR_CODE, message);\n\t}\n}\n\nexport class Unreachable extends InternalError {\n\tconstructor(x: never) {\n\t\tsuper(`Unreachable case: ${x}`);\n\t}\n}\n\nexport class StateNotEnabled extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"state_not_enabled\",\n\t\t\t\"State not enabled. Must implement `createState` or `state` to use state. (https://www.rivet.gg/docs/actors/state/#initializing-state)\",\n\t\t);\n\t}\n}\n\nexport class ConnStateNotEnabled extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"conn_state_not_enabled\",\n\t\t\t\"Connection state not enabled. Must implement `createConnectionState` or `connectionState` to use connection state. (https://www.rivet.gg/docs/actors/connections/#connection-state)\",\n\t\t);\n\t}\n}\n\nexport class VarsNotEnabled extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"vars_not_enabled\",\n\t\t\t\"Variables not enabled. Must implement `createVars` or `vars` to use state. (https://www.rivet.gg/docs/actors/ephemeral-variables/#initializing-variables)\",\n\t\t);\n\t}\n}\n\nexport class ActionTimedOut extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"action_timed_out\",\n\t\t\t\"Action timed out. This can be increased with: `actor({ options: { action: { timeout: ... } } })`\",\n\t\t\t{ public: true },\n\t\t);\n\t}\n}\n\nexport class ActionNotFound extends ActorError {\n\tconstructor(name: string) {\n\t\tsuper(\n\t\t\t\"action_not_found\",\n\t\t\t`Action '${name}' not found. Validate the action exists on your actor.`,\n\t\t\t{ public: true },\n\t\t);\n\t}\n}\n\nexport class InvalidEncoding extends ActorError {\n\tconstructor(format?: string) {\n\t\tsuper(\n\t\t\t\"invalid_encoding\",\n\t\t\t`Invalid encoding \\`${format}\\`. (https://www.rivet.gg/docs/actors/clients/#actor-client)`,\n\t\t\t{\n\t\t\t\tpublic: true,\n\t\t\t},\n\t\t);\n\t}\n}\n\nexport class ConnNotFound extends ActorError {\n\tconstructor(id?: string) {\n\t\tsuper(\"conn_not_found\", `Connection not found for ID: ${id}`, {\n\t\t\tpublic: true,\n\t\t});\n\t}\n}\n\nexport class IncorrectConnToken extends ActorError {\n\tconstructor() {\n\t\tsuper(\"incorrect_conn_token\", \"Incorrect connection token.\", {\n\t\t\tpublic: true,\n\t\t});\n\t}\n}\n\nexport class MessageTooLong extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"message_too_long\",\n\t\t\t\"Message too long. This can be configured with: `registry.runServer({ maxIncomingMessageSize: ... })`\",\n\t\t\t{ public: true },\n\t\t);\n\t}\n}\n\nexport class MalformedMessage extends ActorError {\n\tconstructor(cause?: unknown) {\n\t\tsuper(\"malformed_message\", `Malformed message: ${cause}`, {\n\t\t\tpublic: true,\n\t\t\tcause,\n\t\t});\n\t}\n}\n\nexport interface InvalidStateTypeOptions {\n\tpath?: unknown;\n}\n\nexport class InvalidStateType extends ActorError {\n\tconstructor(opts?: InvalidStateTypeOptions) {\n\t\tlet msg = \"\";\n\t\tif (opts?.path) {\n\t\t\tmsg += `Attempted to set invalid state at path \\`${opts.path}\\`.`;\n\t\t} else {\n\t\t\tmsg += \"Attempted to set invalid state.\";\n\t\t}\n\t\tmsg +=\n\t\t\t\" Valid types include: null, undefined, boolean, string, number, BigInt, Date, RegExp, Error, typed arrays (Uint8Array, Int8Array, Float32Array, etc.), Map, Set, Array, and plain objects. (https://www.rivet.gg/docs/actors/state/#limitations)\";\n\t\tsuper(\"invalid_state_type\", msg);\n\t}\n}\n\nexport class Unsupported extends ActorError {\n\tconstructor(feature: string) {\n\t\tsuper(\"unsupported\", `Unsupported feature: ${feature}`);\n\t}\n}\n\n/**\n * Options for the UserError class.\n */\nexport interface UserErrorOptions extends ErrorOptions {\n\t/**\n\t * Machine readable code for this error. Useful for catching different types of errors in try-catch.\n\t */\n\tcode?: string;\n\n\t/**\n\t * Additional metadata related to the error. Useful for understanding context about the error.\n\t */\n\tmetadata?: unknown;\n}\n\n/** Error that can be safely returned to the user. */\nexport class UserError extends ActorError {\n\t/**\n\t * Constructs a new UserError instance.\n\t *\n\t * @param message - The error message to be displayed.\n\t * @param opts - Optional parameters for the error, including a machine-readable code and additional metadata.\n\t */\n\tconstructor(message: string, opts?: UserErrorOptions) {\n\t\tsuper(opts?.code ?? USER_ERROR_CODE, message, {\n\t\t\tpublic: true,\n\t\t\tmetadata: opts?.metadata,\n\t\t});\n\t}\n}\n\nexport class InvalidQueryJSON extends ActorError {\n\tconstructor(error?: unknown) {\n\t\tsuper(\"invalid_query_json\", `Invalid query JSON: ${error}`, {\n\t\t\tpublic: true,\n\t\t\tcause: error,\n\t\t});\n\t}\n}\n\nexport class InvalidRequest extends ActorError {\n\tconstructor(error?: unknown) {\n\t\tsuper(\"invalid_request\", `Invalid request: ${error}`, {\n\t\t\tpublic: true,\n\t\t\tcause: error,\n\t\t});\n\t}\n}\n\nexport class ActorNotFound extends ActorError {\n\tconstructor(identifier?: string) {\n\t\tsuper(\n\t\t\t\"actor_not_found\",\n\t\t\tidentifier\n\t\t\t\t? `Actor not found: ${identifier} (https://www.rivet.gg/docs/actors/clients/#actor-client)`\n\t\t\t\t: \"Actor not found (https://www.rivet.gg/docs/actors/clients/#actor-client)\",\n\t\t\t{ public: true },\n\t\t);\n\t}\n}\n\nexport class ActorAlreadyExists extends ActorError {\n\tconstructor(name: string, key: string[]) {\n\t\tsuper(\n\t\t\t\"actor_already_exists\",\n\t\t\t`Actor already exists with name '${name}' and key '${JSON.stringify(key)}' (https://www.rivet.gg/docs/actors/clients/#actor-client)`,\n\t\t\t{ public: true },\n\t\t);\n\t}\n}\n\nexport class ProxyError extends ActorError {\n\tconstructor(operation: string, error?: unknown) {\n\t\tsuper(\n\t\t\t\"proxy_error\",\n\t\t\t`Error proxying ${operation}, this is likely an internal error: ${error}`,\n\t\t\t{\n\t\t\t\tpublic: true,\n\t\t\t\tcause: error,\n\t\t\t},\n\t\t);\n\t}\n}\n\nexport class InvalidActionRequest extends ActorError {\n\tconstructor(message: string) {\n\t\tsuper(\"invalid_action_request\", message, { public: true });\n\t}\n}\n\nexport class InvalidParams extends ActorError {\n\tconstructor(message: string) {\n\t\tsuper(\"invalid_params\", message, { public: true });\n\t}\n}\n\nexport class Unauthorized extends ActorError {\n\tconstructor(message?: string) {\n\t\tsuper(\n\t\t\t\"unauthorized\",\n\t\t\tmessage ??\n\t\t\t\t\"Unauthorized. Access denied. (https://www.rivet.gg/docs/actors/authentication/)\",\n\t\t\t{\n\t\t\t\tpublic: true,\n\t\t\t},\n\t\t);\n\t\tthis.statusCode = 401;\n\t}\n}\n\nexport class Forbidden extends ActorError {\n\tconstructor(message?: string, opts?: { metadata?: unknown }) {\n\t\tsuper(\n\t\t\t\"forbidden\",\n\t\t\tmessage ??\n\t\t\t\t\"Forbidden. Access denied. (https://www.rivet.gg/docs/actors/authentication/)\",\n\t\t\t{\n\t\t\t\tpublic: true,\n\t\t\t\tmetadata: opts?.metadata,\n\t\t\t},\n\t\t);\n\t\tthis.statusCode = 403;\n\t}\n}\n\nexport class DatabaseNotEnabled extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"database_not_enabled\",\n\t\t\t\"Database not enabled. Must implement `database` to use database.\",\n\t\t);\n\t}\n}\n\nexport class FetchHandlerNotDefined extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"fetch_handler_not_defined\",\n\t\t\t\"Raw HTTP handler not defined. Actor must implement `onFetch` to handle raw HTTP requests. (https://www.rivet.gg/docs/actors/fetch-and-websocket-handler/)\",\n\t\t\t{ public: true },\n\t\t);\n\t\tthis.statusCode = 404;\n\t}\n}\n\nexport class WebSocketHandlerNotDefined extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"websocket_handler_not_defined\",\n\t\t\t\"Raw WebSocket handler not defined. Actor must implement `onWebSocket` to handle raw WebSocket connections. (https://www.rivet.gg/docs/actors/fetch-and-websocket-handler/)\",\n\t\t\t{ public: true },\n\t\t);\n\t\tthis.statusCode = 404;\n\t}\n}\n\nexport class InvalidFetchResponse extends ActorError {\n\tconstructor() {\n\t\tsuper(\n\t\t\t\"invalid_fetch_response\",\n\t\t\t\"Actor's onFetch handler must return a Response object. Returning void/undefined is not allowed. (https://www.rivet.gg/docs/actors/fetch-and-websocket-handler/)\",\n\t\t\t{ public: true },\n\t\t);\n\t\tthis.statusCode = 500;\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/utils.ts\";import type { Next } from \"hono\";\nimport type { ContentfulStatusCode } from \"hono/utils/http-status\";\nimport * as errors from \"@/actor/errors\";\nimport { getEnvUniversal } from \"@/utils\";\nimport type { Logger } from \"./log\";\n\nexport function assertUnreachable(x: never): never {\n\tthrow new Error(`Unreachable case: ${x}`);\n}\n\n/**\n * Safely stringifies an object, ensuring that the stringified object is under a certain size.\n * @param obj any object to stringify\n * @param maxSize maximum size of the stringified object in bytes\n * @returns stringified object\n */\nexport function safeStringify(obj: unknown, maxSize: number) {\n\tlet size = 0;\n\n\tfunction replacer(key: string, value: unknown) {\n\t\tif (value === null || value === undefined) return value;\n\t\tconst valueSize =\n\t\t\ttypeof value === \"string\" ? value.length : JSON.stringify(value).length;\n\t\tsize += key.length + valueSize;\n\n\t\tif (size > maxSize) {\n\t\t\tthrow new Error(`JSON object exceeds size limit of ${maxSize} bytes.`);\n\t\t}\n\n\t\treturn value;\n\t}\n\n\treturn JSON.stringify(obj, replacer);\n}\n\n// TODO: Instead of doing this, use a temp var for state and attempt to write\n// it. Roll back state if fails to serialize.\n\n/**\n * Check if a value is CBOR serializable.\n * Optionally pass an onInvalid callback to receive the path to invalid values.\n *\n * For a complete list of supported CBOR tags, see:\n * https://github.com/kriszyp/cbor-x/blob/cc1cf9df8ba72288c7842af1dd374d73e34cdbc1/README.md#list-of-supported-tags-for-decoding\n */\nexport function isCborSerializable(\n\tvalue: unknown,\n\tonInvalid?: (path: string) => void,\n\tcurrentPath = \"\",\n): boolean {\n\t// Handle primitive types directly\n\tif (value === null || value === undefined) {\n\t\treturn true;\n\t}\n\n\tif (typeof value === \"number\") {\n\t\tif (!Number.isFinite(value)) {\n\t\t\tonInvalid?.(currentPath);\n\t\t\treturn false;\n\t\t}\n\t\treturn true;\n\t}\n\n\tif (typeof value === \"boolean\" || typeof value === \"string\") {\n\t\treturn true;\n\t}\n\n\t// Handle BigInt (CBOR tags 2 and 3)\n\tif (typeof value === \"bigint\") {\n\t\treturn true;\n\t}\n\n\t// Handle Date objects (CBOR tags 0 and 1)\n\tif (value instanceof Date) {\n\t\treturn true;\n\t}\n\n\t// Handle typed arrays (CBOR tags 64-82)\n\tif (\n\t\tvalue instanceof Uint8Array ||\n\t\tvalue instanceof Uint8ClampedArray ||\n\t\tvalue instanceof Uint16Array ||\n\t\tvalue instanceof Uint32Array ||\n\t\tvalue instanceof BigUint64Array ||\n\t\tvalue instanceof Int8Array ||\n\t\tvalue instanceof Int16Array ||\n\t\tvalue instanceof Int32Array ||\n\t\tvalue instanceof BigInt64Array ||\n\t\tvalue instanceof Float32Array ||\n\t\tvalue instanceof Float64Array\n\t) {\n\t\treturn true;\n\t}\n\n\t// Handle Map (CBOR tag 259)\n\tif (value instanceof Map) {\n\t\tfor (const [key, val] of value.entries()) {\n\t\t\tconst keyPath = currentPath\n\t\t\t\t? `${currentPath}.key(${String(key)})`\n\t\t\t\t: `key(${String(key)})`;\n\t\t\tconst valPath = currentPath\n\t\t\t\t? `${currentPath}.value(${String(key)})`\n\t\t\t\t: `value(${String(key)})`;\n\t\t\tif (\n\t\t\t\t!isCborSerializable(key, onInvalid, keyPath) ||\n\t\t\t\t!isCborSerializable(val, onInvalid, valPath)\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Handle Set (CBOR tag 258)\n\tif (value instanceof Set) {\n\t\tlet index = 0;\n\t\tfor (const item of value.values()) {\n\t\t\tconst itemPath = currentPath\n\t\t\t\t? `${currentPath}.set[${index}]`\n\t\t\t\t: `set[${index}]`;\n\t\t\tif (!isCborSerializable(item, onInvalid, itemPath)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\tindex++;\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Handle RegExp (CBOR tag 27)\n\tif (value instanceof RegExp) {\n\t\treturn true;\n\t}\n\n\t// Handle Error objects (CBOR tag 27)\n\tif (value instanceof Error) {\n\t\treturn true;\n\t}\n\n\t// Handle arrays\n\tif (Array.isArray(value)) {\n\t\tfor (let i = 0; i < value.length; i++) {\n\t\t\tconst itemPath = currentPath ? `${currentPath}[${i}]` : `[${i}]`;\n\t\t\tif (!isCborSerializable(value[i], onInvalid, itemPath)) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Handle plain objects and records (CBOR tags 105, 51, 57344-57599)\n\tif (typeof value === \"object\") {\n\t\t// Allow plain objects and objects with prototypes (for records and named objects)\n\t\tconst proto = Object.getPrototypeOf(value);\n\t\tif (proto !== null && proto !== Object.prototype) {\n\t\t\t// Check if it's a known serializable object type\n\t\t\tconst protoConstructor = value.constructor;\n\t\t\tif (protoConstructor && typeof protoConstructor.name === \"string\") {\n\t\t\t\t// Allow objects with named constructors (records, named objects)\n\t\t\t\t// This includes user-defined classes and built-in objects\n\t\t\t\t// that CBOR can serialize with tag 27 or record tags\n\t\t\t}\n\t\t}\n\n\t\t// Check all properties recursively\n\t\tfor (const key in value) {\n\t\t\tconst propPath = currentPath ? `${currentPath}.${key}` : key;\n\t\t\tif (\n\t\t\t\t!isCborSerializable(\n\t\t\t\t\tvalue[key as keyof typeof value],\n\t\t\t\t\tonInvalid,\n\t\t\t\t\tpropPath,\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Not serializable\n\tonInvalid?.(currentPath);\n\treturn false;\n}\n\nexport interface DeconstructedError {\n\t__type: \"ActorError\";\n\tstatusCode: ContentfulStatusCode;\n\tpublic: boolean;\n\tcode: string;\n\tmessage: string;\n\tmetadata?: unknown;\n}\n\n/** Deconstructs error in to components that are used to build responses. */\nexport function deconstructError(\n\terror: unknown,\n\tlogger: Logger,\n\textraLog: Record<string, unknown>,\n\texposeInternalError = false,\n): DeconstructedError {\n\t// Build response error information. Only return errors if flagged as public in order to prevent leaking internal behavior.\n\t//\n\t// We log the error here instead of after generating the code & message because we need to log the original error, not the masked internal error.\n\tlet statusCode: ContentfulStatusCode;\n\tlet public_: boolean;\n\tlet code: string;\n\tlet message: string;\n\tlet metadata: unknown;\n\tif (errors.ActorError.isActorError(error) && error.public) {\n\t\t// Check if error has statusCode (could be ActorError instance or DeconstructedError)\n\t\tstatusCode = (\n\t\t\t\"statusCode\" in error && error.statusCode ? error.statusCode : 400\n\t\t) as ContentfulStatusCode;\n\t\tpublic_ = true;\n\t\tcode = error.code;\n\t\tmessage = getErrorMessage(error);\n\t\tmetadata = error.metadata;\n\n\t\tlogger.info(\"public error\", {\n\t\t\tcode,\n\t\t\tmessage,\n\t\t\tissues: \"https://github.com/rivet-gg/rivetkit/issues\",\n\t\t\tsupport: \"https://rivet.gg/discord\",\n\t\t\t...extraLog,\n\t\t});\n\t} else if (exposeInternalError) {\n\t\tif (errors.ActorError.isActorError(error)) {\n\t\t\tstatusCode = 500;\n\t\t\tpublic_ = false;\n\t\t\tcode = error.code;\n\t\t\tmessage = getErrorMessage(error);\n\t\t\tmetadata = error.metadata;\n\n\t\t\tlogger.info(\"internal error\", {\n\t\t\t\tcode,\n\t\t\t\tmessage,\n\t\t\t\tissues: \"https://github.com/rivet-gg/rivetkit/issues\",\n\t\t\t\tsupport: \"https://rivet.gg/discord\",\n\t\t\t\t...extraLog,\n\t\t\t});\n\t\t} else {\n\t\t\tstatusCode = 500;\n\t\t\tpublic_ = false;\n\t\t\tcode = errors.INTERNAL_ERROR_CODE;\n\t\t\tmessage = getErrorMessage(error);\n\n\t\t\tlogger.info(\"internal error\", {\n\t\t\t\tcode,\n\t\t\t\tmessage,\n\t\t\t\tissues: \"https://github.com/rivet-gg/rivetkit/issues\",\n\t\t\t\tsupport: \"https://rivet.gg/discord\",\n\t\t\t\t...extraLog,\n\t\t\t});\n\t\t}\n\t} else {\n\t\tstatusCode = 500;\n\t\tpublic_ = false;\n\t\tcode = errors.INTERNAL_ERROR_CODE;\n\t\tmessage = errors.INTERNAL_ERROR_DESCRIPTION;\n\t\tmetadata = {\n\t\t\t//url: `https://hub.rivet.gg/projects/${actorMetadata.project.slug}/environments/${actorMetadata.environment.slug}/actors?actorId=${actorMetadata.actor.id}`,\n\t\t} satisfies errors.InternalErrorMetadata;\n\n\t\tlogger.warn(\"internal error\", {\n\t\t\terror: getErrorMessage(error),\n\t\t\tstack: (error as Error)?.stack,\n\t\t\tissues: \"https://github.com/rivet-gg/rivetkit/issues\",\n\t\t\tsupport: \"https://rivet.gg/discord\",\n\t\t\t...extraLog,\n\t\t});\n\t}\n\n\treturn {\n\t\t__type: \"ActorError\",\n\t\tstatusCode,\n\t\tpublic: public_,\n\t\tcode,\n\t\tmessage,\n\t\tmetadata,\n\t};\n}\n\nexport function stringifyError(error: unknown): string {\n\tif (error instanceof Error) {\n\t\tif (\n\t\t\ttypeof process !== \"undefined\" &&\n\t\t\tgetEnvUniversal(\"_RIVETKIT_ERROR_STACK\") === \"1\"\n\t\t) {\n\t\t\treturn `${error.name}: ${error.message}${error.stack ? `\\n${error.stack}` : \"\"}`;\n\t\t} else {\n\t\t\treturn `${error.name}: ${error.message}`;\n\t\t}\n\t} else if (typeof error === \"string\") {\n\t\treturn error;\n\t} else if (typeof error === \"object\" && error !== null) {\n\t\ttry {\n\t\t\treturn `${JSON.stringify(error)}`;\n\t\t} catch {\n\t\t\treturn \"[cannot stringify error]\";\n\t\t}\n\t} else {\n\t\treturn `Unknown error: ${getErrorMessage(error)}`;\n\t}\n}\n\nfunction getErrorMessage(err: unknown): string {\n\tif (\n\t\terr &&\n\t\ttypeof err === \"object\" &&\n\t\t\"message\" in err &&\n\t\ttypeof err.message === \"string\"\n\t) {\n\t\treturn err.message;\n\t} else {\n\t\treturn String(err);\n\t}\n}\n\n/** Generates a `Next` handler to pass to middleware in order to be able to call arbitrary middleware. */\nexport function noopNext(): Next {\n\treturn async () => {};\n}\n", "{\n  \"name\": \"rivetkit\",\n  \"version\": \"2.0.2\",\n  \"license\": \"Apache-2.0\",\n  \"keywords\": [\n    \"rivetkit\",\n    \"stateful\",\n    \"serverless\",\n    \"actors\",\n    \"agents\",\n    \"realtime\",\n    \"websocket\",\n    \"actors\",\n    \"framework\"\n  ],\n  \"files\": [\n    \"dist\",\n    \"src\",\n    \"deno.json\",\n    \"bun.json\",\n    \"package.json\"\n  ],\n  \"type\": \"module\",\n  \"exports\": {\n    \".\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/mod.d.ts\",\n        \"default\": \"./dist/tsup/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/mod.d.cts\",\n        \"default\": \"./dist/tsup/mod.cjs\"\n      }\n    },\n    \"./client\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/client/mod.d.ts\",\n        \"default\": \"./dist/tsup/client/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/client/mod.d.cts\",\n        \"default\": \"./dist/tsup/client/mod.cjs\"\n      }\n    },\n    \"./log\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/common/log.d.ts\",\n        \"default\": \"./dist/tsup/common/log.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/common/log.d.cts\",\n        \"default\": \"./dist/tsup/common/log.cjs\"\n      }\n    },\n    \"./errors\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/actor/errors.d.ts\",\n        \"default\": \"./dist/tsup/actor/errors.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/actor/errors.d.cts\",\n        \"default\": \"./dist/tsup/actor/errors.cjs\"\n      }\n    },\n    \"./utils\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/utils.d.ts\",\n        \"default\": \"./dist/tsup/utils.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/utils.d.cts\",\n        \"default\": \"./dist/tsup/utils.cjs\"\n      }\n    },\n    \"./driver-helpers\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/driver-helpers/mod.d.ts\",\n        \"default\": \"./dist/tsup/driver-helpers/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/driver-helpers/mod.d.cts\",\n        \"default\": \"./dist/tsup/driver-helpers/mod.cjs\"\n      }\n    },\n    \"./driver-helpers/websocket\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/common/websocket.d.ts\",\n        \"default\": \"./dist/tsup/common/websocket.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/common/websocket.d.cts\",\n        \"default\": \"./dist/tsup/common/websocket.cjs\"\n      }\n    },\n    \"./driver-test-suite\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/driver-test-suite/mod.d.ts\",\n        \"default\": \"./dist/tsup/driver-test-suite/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/driver-test-suite/mod.d.cts\",\n        \"default\": \"./dist/tsup/driver-test-suite/mod.cjs\"\n      }\n    },\n    \"./topologies/coordinate\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/topologies/coordinate/mod.d.ts\",\n        \"default\": \"./dist/tsup/topologies/coordinate/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/topologies/coordinate/mod.d.cts\",\n        \"default\": \"./dist/tsup/topologies/coordinate/mod.cjs\"\n      }\n    },\n    \"./topologies/partition\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/topologies/partition/mod.d.ts\",\n        \"default\": \"./dist/tsup/topologies/partition/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/topologies/partition/mod.d.cts\",\n        \"default\": \"./dist/tsup/topologies/partition/mod.cjs\"\n      }\n    },\n    \"./test\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/test/mod.d.ts\",\n        \"default\": \"./dist/tsup/test/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/test/mod.d.cts\",\n        \"default\": \"./dist/tsup/test/mod.cjs\"\n      }\n    },\n    \"./inspector\": {\n      \"import\": {\n        \"types\": \"./dist/tsup/inspector/mod.d.ts\",\n        \"default\": \"./dist/tsup/inspector/mod.js\"\n      },\n      \"require\": {\n        \"types\": \"./dist/tsup/inspector/mod.d.cts\",\n        \"default\": \"./dist/tsup/inspector/mod.cjs\"\n      }\n    }\n  },\n  \"engines\": {\n    \"node\": \">=22.0.0\"\n  },\n  \"sideEffects\": false,\n  \"scripts\": {\n    \"dev\": \"pnpm build --watch\",\n    \"build\": \"tsup src/mod.ts src/client/mod.ts src/common/log.ts src/common/websocket.ts src/actor/errors.ts src/topologies/coordinate/mod.ts src/topologies/partition/mod.ts src/utils.ts src/driver-helpers/mod.ts src/driver-test-suite/mod.ts src/test/mod.ts src/inspector/mod.ts\",\n    \"build:schema\": \"./scripts/compile-bare.ts compile schemas/client-protocol/v1.bare -o dist/schemas/client-protocol/v1.ts && ./scripts/compile-bare.ts compile schemas/file-system-driver/v1.bare -o dist/schemas/file-system-driver/v1.ts && ./scripts/compile-bare.ts compile schemas/actor-persist/v1.bare -o dist/schemas/actor-persist/v1.ts\",\n    \"check-types\": \"tsc --noEmit\",\n    \"test\": \"vitest run\",\n    \"test:watch\": \"vitest\",\n    \"dump-openapi\": \"tsx scripts/dump-openapi.ts\"\n  },\n  \"dependencies\": {\n    \"@bare-ts/lib\": \"~0.3.0\",\n    \"@hono/standard-validator\": \"^0.1.3\",\n    \"@hono/zod-openapi\": \"^0.19.10\",\n    \"@rivetkit/engine-runner\": \"https://pkg.pr.new/rivet-gg/engine/@rivetkit/engine-runner@664a377\",\n    \"@rivetkit/fast-json-patch\": \"^3.1.2\",\n    \"cbor-x\": \"^1.6.0\",\n    \"hono\": \"^4.7.0\",\n    \"invariant\": \"^2.2.4\",\n    \"nanoevents\": \"^9.1.0\",\n    \"on-change\": \"^5.0.1\",\n    \"p-retry\": \"^6.2.1\",\n    \"zod\": \"^3.25.76\"\n  },\n  \"devDependencies\": {\n    \"@bare-ts/tools\": \"^0.13.0\",\n    \"@hono/node-server\": \"^1.18.2\",\n    \"@hono/node-ws\": \"^1.1.1\",\n    \"@rivet-gg/actor-core\": \"^25.1.0\",\n    \"@types/invariant\": \"^2\",\n    \"@types/node\": \"^22.13.1\",\n    \"@types/ws\": \"^8\",\n    \"@vitest/ui\": \"3.1.1\",\n    \"bundle-require\": \"^5.1.0\",\n    \"eventsource\": \"^3.0.5\",\n    \"tsup\": \"^8.4.0\",\n    \"tsx\": \"^4.19.4\",\n    \"typescript\": \"^5.7.3\",\n    \"vitest\": \"^3.1.1\",\n    \"ws\": \"^8.18.1\"\n  },\n  \"peerDependencies\": {\n    \"@hono/node-server\": \"^1.14.0\",\n    \"@hono/node-ws\": \"^1.1.1\",\n    \"eventsource\": \"^3.0.5\",\n    \"ws\": \"^8.0.0\"\n  },\n  \"peerDependenciesMeta\": {\n    \"@hono/node-server\": {\n      \"optional\": true\n    },\n    \"@hono/node-ws\": {\n      \"optional\": true\n    },\n    \"eventsource\": {\n      \"optional\": true\n    },\n    \"ws\": {\n      \"optional\": true\n    }\n  },\n  \"stableVersion\": \"0.8.0\"\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/utils.ts\";export { stringifyError } from \"@/common/utils\";\nexport { assertUnreachable } from \"./common/utils\";\n\nimport type { Context as HonoContext, Handler as HonoHandler } from \"hono\";\n\nimport pkgJson from \"../package.json\" with { type: \"json\" };\n\nexport const VERSION = pkgJson.version;\n\nlet _userAgent: string | undefined;\n\nexport function httpUserAgent(): string {\n\t// Return cached value if already initialized\n\tif (_userAgent !== undefined) {\n\t\treturn _userAgent;\n\t}\n\n\t// Library\n\tlet userAgent = `RivetKit/${VERSION}`;\n\n\t// Navigator\n\tconst navigatorObj = typeof navigator !== \"undefined\" ? navigator : undefined;\n\tif (navigatorObj?.userAgent) userAgent += ` ${navigatorObj.userAgent}`;\n\n\t_userAgent = userAgent;\n\n\treturn userAgent;\n}\n\nexport type UpgradeWebSocket = (\n\tcreateEvents: (c: HonoContext) => any,\n) => HonoHandler;\n\nexport function getEnvUniversal(key: string): string | undefined {\n\tif (typeof Deno !== \"undefined\") {\n\t\treturn Deno.env.get(key);\n\t} else if (typeof process !== \"undefined\") {\n\t\t// Do this after Deno since `process` is sometimes polyfilled\n\t\treturn process.env[key];\n\t}\n}\n\nexport function dbg<T>(x: T): T {\n\tconsole.trace(`=== DEBUG ===\\n${x}`);\n\treturn x;\n}\n\n/**\n * Converts various ArrayBuffer-like types to Uint8Array.\n * Handles ArrayBuffer, ArrayBufferView (including typed arrays), and passes through existing Uint8Array.\n *\n * @param data - The ArrayBuffer or ArrayBufferView to convert\n * @returns A Uint8Array view of the data\n */\nexport function toUint8Array(data: ArrayBuffer | ArrayBufferView): Uint8Array {\n\tif (data instanceof Uint8Array) {\n\t\treturn data;\n\t} else if (data instanceof ArrayBuffer) {\n\t\treturn new Uint8Array(data);\n\t} else if (ArrayBuffer.isView(data)) {\n\t\t// Handle other ArrayBufferView types (Int8Array, Uint16Array, DataView, etc.)\n\t\treturn new Uint8Array(\n\t\t\tdata.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength),\n\t\t);\n\t} else {\n\t\tthrow new TypeError(\"Input must be ArrayBuffer or ArrayBufferView\");\n\t}\n}\n\n// Long timeouts\n//\n// JavaScript timers use a signed 32-bit integer for delays, so values above 2^31-1 (~24.8 days)\n// are not reliable and may fire immediately or overflow.\n//\n// https://developer.mozilla.org/en-US/docs/Web/API/Window/setTimeout#maximum_delay_value\nconst TIMEOUT_MAX = 2147483647; // 2^31-1\n\nexport type LongTimeoutHandle = { abort: () => void };\n\nexport function setLongTimeout(\n\tlistener: () => void,\n\tafter: number,\n): LongTimeoutHandle {\n\tlet timeout: ReturnType<typeof setTimeout> | undefined;\n\n\tfunction start(remaining: number) {\n\t\tif (remaining <= TIMEOUT_MAX) {\n\t\t\ttimeout = setTimeout(listener, remaining);\n\t\t} else {\n\t\t\ttimeout = setTimeout(() => {\n\t\t\t\tstart(remaining - TIMEOUT_MAX);\n\t\t\t}, TIMEOUT_MAX);\n\t\t}\n\t}\n\n\tstart(after);\n\n\treturn {\n\t\tabort: () => {\n\t\t\tif (timeout !== undefined) clearTimeout(timeout);\n\t\t},\n\t};\n}\n\n/**\n * A tiny utility that coalesces/enqueues async operations so only the latest\n * queued task runs per cycle, while callers receive a promise that resolves\n * when the task for the cycle they joined has completed.\n */\nexport class SinglePromiseQueue {\n\t/** Next operation to execute in the queue. If attempting to enqueue another op, it will override the existing op. */\n\t#queuedOp?: () => Promise<void>;\n\n\t/** The currently running promise of #drainLoop. Do not await this, instead await `pending` to await the current cycle. */\n\trunningDrainLoop?: Promise<void>;\n\n\t/** Pending resolver fro the currently queued entry. */\n\t#pending?: PromiseWithResolvers<void>;\n\n\t/** Queue the next operation and return a promise that resolves when it flushes. */\n\tenqueue(op: () => Promise<void>): Promise<void> {\n\t\t// Replace any previously queued operation with the latest one\n\t\tthis.#queuedOp = op;\n\n\t\t// Ensure a shared resolver exists for all callers in this cycle\n\t\tif (!this.#pending) {\n\t\t\tthis.#pending = Promise.withResolvers<void>();\n\t\t}\n\n\t\tconst waitForThisCycle = this.#pending.promise;\n\n\t\t// Start runner if not already running\n\t\tif (!this.runningDrainLoop) {\n\t\t\tthis.runningDrainLoop = this.#drainLoop();\n\t\t}\n\n\t\treturn waitForThisCycle;\n\t}\n\n\t/** Drain queued operations sequentially until there is nothing left. */\n\tasync #drainLoop(): Promise<void> {\n\t\ttry {\n\t\t\twhile (this.#queuedOp) {\n\t\t\t\t// Capture current cycle resolver then reset for the next cycle\n\t\t\t\tconst resolver = this.#pending;\n\t\t\t\tthis.#pending = undefined;\n\n\t\t\t\t// Capture and clear the currently queued operation\n\t\t\t\tconst op = this.#queuedOp;\n\t\t\t\tthis.#queuedOp = undefined;\n\n\t\t\t\ttry {\n\t\t\t\t\tawait op();\n\t\t\t\t} catch {\n\t\t\t\t\t// Swallow errors: callers only await cycle completion, not success\n\t\t\t\t}\n\n\t\t\t\t// Notify all waiters for this cycle\n\t\t\t\tresolver?.resolve();\n\t\t\t}\n\t\t} finally {\n\t\t\tthis.runningDrainLoop = undefined;\n\t\t}\n\t}\n}\n\nexport function bufferToArrayBuffer(buf: Buffer | Uint8Array): ArrayBuffer {\n\treturn buf.buffer.slice(\n\t\tbuf.byteOffset,\n\t\tbuf.byteOffset + buf.byteLength,\n\t) as ArrayBuffer;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/log-levels.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/log-levels.ts\";export type LogLevel =\n\t| \"TRACE\"\n\t| \"DEBUG\"\n\t| \"INFO\"\n\t| \"WARN\"\n\t| \"ERROR\"\n\t| \"CRITICAL\";\n\nexport const LogLevels: Record<LogLevel, LevelIndex> = {\n\tTRACE: 0,\n\tDEBUG: 1,\n\tINFO: 2,\n\tWARN: 3,\n\tERROR: 4,\n\tCRITICAL: 5,\n} as const;\n\nexport const LevelNameMap: Record<number, LogLevel> = {\n\t0: \"TRACE\",\n\t1: \"DEBUG\",\n\t2: \"INFO\",\n\t3: \"WARN\",\n\t4: \"ERROR\",\n\t5: \"CRITICAL\",\n};\n\nexport type LevelIndex = number;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/logfmt.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/logfmt.ts\";import { type LogLevel, LogLevels } from \"./log-levels\";\n\nexport type LogEntry = [string, LogValue];\nexport type LogValue = string | number | bigint | boolean | null | undefined;\n\nconst LOG_LEVEL_COLORS: Record<number, string> = {\n\t[LogLevels.CRITICAL]: \"\\x1b[31m\", // Red\n\t[LogLevels.ERROR]: \"\\x1b[31m\", // Red\n\t[LogLevels.WARN]: \"\\x1b[33m\", // Yellow\n\t[LogLevels.INFO]: \"\\x1b[32m\", // Green\n\t[LogLevels.DEBUG]: \"\\x1b[36m\", // Cyan\n\t[LogLevels.TRACE]: \"\\x1b[36m\", // Cyan\n};\n\nconst RESET_COLOR = \"\\x1b[0m\";\n\n/**\n * Serializes logfmt line using orderer parameters.\n *\n * We use varargs because it's ordered & it has less overhead than an object.\n *\n * ## Styling Methodology\n *\n * The three things you need to know for every log line is the level, the\n * message, and who called it. These properties are highlighted in different colros\n * and sorted in th eorder that you usually read them.\n *\n * Once you've found a log line you care about, then you want to find the\n * property you need to see. The property names are bolded and the default color\n * while the rest of the data is dim. This lets you scan to find the property\n * name quickly then look closer to read the data associated with the\n * property.\n */\nexport function stringify(...data: LogEntry[]) {\n\tlet line = \"\";\n\n\tfor (let i = 0; i < data.length; i++) {\n\t\tconst [key, valueRaw] = data[i];\n\n\t\tlet isNull = false;\n\t\tlet valueString: string;\n\t\tif (valueRaw == null) {\n\t\t\tisNull = true;\n\t\t\tvalueString = \"\";\n\t\t} else {\n\t\t\tvalueString = valueRaw.toString();\n\t\t}\n\n\t\t// Clip value unless specifically the error message\n\t\tif (valueString.length > 512 && key !== \"msg\" && key !== \"error\")\n\t\t\tvalueString = `${valueString.slice(0, 512)}...`;\n\n\t\tconst needsQuoting =\n\t\t\tvalueString.indexOf(\" \") > -1 || valueString.indexOf(\"=\") > -1;\n\t\tconst needsEscaping =\n\t\t\tvalueString.indexOf('\"') > -1 || valueString.indexOf(\"\\\\\") > -1;\n\n\t\tvalueString = valueString.replace(/\\n/g, \"\\\\n\");\n\t\tif (needsEscaping) valueString = valueString.replace(/[\"\\\\]/g, \"\\\\$&\");\n\t\tif (needsQuoting || needsEscaping) valueString = `\"${valueString}\"`;\n\t\tif (valueString === \"\" && !isNull) valueString = '\"\"';\n\n\t\tif (LOGGER_CONFIG.enableColor) {\n\t\t\t// With color\n\n\t\t\t// Special message colors\n\t\t\tlet color = \"\\x1b[2m\";\n\t\t\tif (key === \"level\") {\n\t\t\t\tconst level = LogLevels[valueString as LogLevel];\n\t\t\t\tconst levelColor = LOG_LEVEL_COLORS[level];\n\t\t\t\tif (levelColor) {\n\t\t\t\t\tcolor = levelColor;\n\t\t\t\t}\n\t\t\t} else if (key === \"msg\") {\n\t\t\t\tcolor = \"\\x1b[32m\";\n\t\t\t} else if (key === \"trace\") {\n\t\t\t\tcolor = \"\\x1b[34m\";\n\t\t\t}\n\n\t\t\t// Format line\n\t\t\tline += `\\x1b[0m\\x1b[1m${key}\\x1b[0m\\x1b[2m=\\x1b[0m${color}${valueString}${RESET_COLOR}`;\n\t\t} else {\n\t\t\t// No color\n\t\t\tline += `${key}=${valueString}`;\n\t\t}\n\n\t\tif (i !== data.length - 1) {\n\t\t\tline += \" \";\n\t\t}\n\t}\n\n\treturn line;\n}\n\nexport function formatTimestamp(date: Date): string {\n\tconst year = date.getUTCFullYear();\n\tconst month = String(date.getUTCMonth() + 1).padStart(2, \"0\");\n\tconst day = String(date.getUTCDate()).padStart(2, \"0\");\n\tconst hours = String(date.getUTCHours()).padStart(2, \"0\");\n\tconst minutes = String(date.getUTCMinutes()).padStart(2, \"0\");\n\tconst seconds = String(date.getUTCSeconds()).padStart(2, \"0\");\n\tconst milliseconds = String(date.getUTCMilliseconds()).padStart(3, \"0\");\n\n\treturn `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}Z`;\n}\n\nexport function castToLogValue(v: unknown): LogValue {\n\tif (\n\t\ttypeof v === \"string\" ||\n\t\ttypeof v === \"number\" ||\n\t\ttypeof v === \"bigint\" ||\n\t\ttypeof v === \"boolean\" ||\n\t\tv === null ||\n\t\tv === undefined\n\t) {\n\t\treturn v;\n\t}\n\tif (v instanceof Error) {\n\t\t//args.push(...errorToLogEntries(k, v));\n\t\treturn String(v);\n\t}\n\ttry {\n\t\treturn JSON.stringify(v);\n\t} catch {\n\t\treturn \"[cannot stringify]\";\n\t}\n}\n\n// MARK: Config\ninterface GlobalLoggerConfig {\n\tenableColor: boolean;\n\tenableSpreadObject: boolean;\n\tenableErrorStack: boolean;\n}\n\nexport const LOGGER_CONFIG: GlobalLoggerConfig = {\n\tenableColor: false,\n\tenableSpreadObject: false,\n\tenableErrorStack: false,\n};\n\n// MARK: Utils\n/**\n * Converts an object in to an easier to read KV of entries.\n */\nexport function spreadObjectToLogEntries(\n\tbase: string,\n\tdata: unknown,\n): LogEntry[] {\n\tif (\n\t\tLOGGER_CONFIG.enableSpreadObject &&\n\t\ttypeof data === \"object\" &&\n\t\t!Array.isArray(data) &&\n\t\tdata !== null &&\n\t\tObject.keys(data).length !== 0 &&\n\t\tObject.keys(data).length < 16\n\t) {\n\t\tconst logData: LogEntry[] = [];\n\t\tfor (const key in data) {\n\t\t\t// logData.push([`${base}.${key}`, JSON.stringify((data as any)[key])]);\n\n\t\t\tlogData.push(\n\t\t\t\t...spreadObjectToLogEntries(\n\t\t\t\t\t`${base}.${key}`,\n\t\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: FIXME\n\t\t\t\t\t(data as any)[key],\n\t\t\t\t),\n\t\t\t);\n\t\t}\n\t\treturn logData;\n\t}\n\n\treturn [[base, JSON.stringify(data)]];\n}\n\nexport function errorToLogEntries(base: string, error: unknown): LogEntry[] {\n\tif (error instanceof Error) {\n\t\treturn [\n\t\t\t//[`${base}.name`, error.name],\n\t\t\t[`${base}.message`, error.message],\n\t\t\t...(LOGGER_CONFIG.enableErrorStack && error.stack\n\t\t\t\t? [[`${base}.stack`, formatStackTrace(error.stack)] as LogEntry]\n\t\t\t\t: []),\n\t\t\t...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : []),\n\t\t];\n\t}\n\treturn [[base, `${error}`]];\n}\n\n// export function errorToLogEntries(base: string, error: unknown): LogEntry[] {\n// \tif (error instanceof RuntimeError) {\n// \t\treturn [\n// \t\t\t[`${base}.code`, error.code],\n// \t\t\t[`${base}.description`, error.errorConfig?.description],\n// \t\t\t[`${base}.module`, error.moduleName],\n// \t\t\t...(error.trace ? [[`${base}.trace`, stringifyTrace(error.trace)] as LogEntry] : []),\n// \t\t\t...(LOGGER_CONFIG.enableErrorStack && error.stack\n// \t\t\t\t? [[`${base}.stack`, formatStackTrace(error.stack)] as LogEntry]\n// \t\t\t\t: []),\n// \t\t\t...(error.meta ? [[`${base}.meta`, JSON.stringify(error.meta)] as LogEntry] : []),\n// \t\t\t...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : []),\n// \t\t];\n// \t} else if (error instanceof Error) {\n// \t\treturn [\n// \t\t\t[`${base}.name`, error.name],\n// \t\t\t[`${base}.message`, error.message],\n// \t\t\t...(LOGGER_CONFIG.enableErrorStack && error.stack\n// \t\t\t\t? [[`${base}.stack`, formatStackTrace(error.stack)] as LogEntry]\n// \t\t\t\t: []),\n// \t\t\t...(error.cause ? errorToLogEntries(`${base}.cause`, error.cause) : []),\n// \t\t];\n// \t} else {\n// \t\treturn [\n// \t\t\t[base, `${error}`],\n// \t\t];\n// \t}\n// }\n\n/**\n * Formats a JS stack trace in to a legible one-liner.\n */\nfunction formatStackTrace(stackTrace: string): string {\n\tconst regex = /at (.+?)$/gm;\n\tconst matches = [...stackTrace.matchAll(regex)];\n\t// Reverse array since the stack goes from top level -> bottom level\n\tmatches.reverse();\n\treturn matches.map((match) => match[1].trim()).join(\" > \");\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/log.ts\";import { getEnvUniversal } from \"@/utils\";\nimport {\n\ttype LevelIndex,\n\tLevelNameMap,\n\ttype LogLevel,\n\tLogLevels,\n} from \"./log-levels\";\nimport {\n\tcastToLogValue,\n\tformatTimestamp,\n\ttype LogEntry,\n\tstringify,\n} from \"./logfmt\";\n\ninterface LogRecord {\n\targs: unknown[];\n\tdatetime: Date;\n\tlevel: number;\n\tlevelName: string;\n\tloggerName: string;\n\tmsg: string;\n}\n\nexport class Logger {\n\tname: string;\n\tlevel: LogLevel;\n\n\tconstructor(name: string, level: LogLevel) {\n\t\tthis.name = name;\n\t\tthis.level = level;\n\t}\n\n\tlog(level: LevelIndex, message: string, ...args: unknown[]): void {\n\t\tconst record: LogRecord = {\n\t\t\tmsg: message,\n\t\t\targs,\n\t\t\tlevel,\n\t\t\tloggerName: this.name,\n\t\t\tdatetime: new Date(),\n\t\t\tlevelName: LevelNameMap[level],\n\t\t};\n\n\t\tif (this.#shouldLog(level)) {\n\t\t\tthis.#logRecord(record);\n\t\t}\n\t}\n\n\t#shouldLog(level: LevelIndex): boolean {\n\t\treturn level >= LogLevels[this.level];\n\t}\n\n\t#logRecord(record: LogRecord): void {\n\t\tconsole.log(formatter(record));\n\t}\n\n\ttrace(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.TRACE, message, ...args);\n\t}\n\n\tdebug(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.DEBUG, message, ...args);\n\t}\n\n\tinfo(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.INFO, message, ...args);\n\t}\n\n\twarn(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.WARN, message, ...args);\n\t}\n\n\terror(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.ERROR, message, ...args);\n\t}\n\n\tcritical(message: string, ...args: unknown[]): void {\n\t\tthis.log(LogLevels.CRITICAL, message, ...args);\n\t}\n}\n\nconst loggers: Record<string, Logger> = {};\n\nexport function getLogger(name = \"default\"): Logger {\n\tconst defaultLogLevelEnv: LogLevel | undefined = getEnvUniversal(\n\t\t\"_LOG_LEVEL\",\n\t) as LogLevel | undefined;\n\n\tconst defaultLogLevel: LogLevel = defaultLogLevelEnv ?? \"INFO\";\n\tif (!loggers[name]) {\n\t\tloggers[name] = new Logger(name, defaultLogLevel);\n\t}\n\treturn loggers[name];\n}\n\nfunction formatter(log: LogRecord): string {\n\tconst args: LogEntry[] = [];\n\tfor (let i = 0; i < log.args.length; i++) {\n\t\tconst logArg = log.args[i];\n\t\tif (logArg && typeof logArg === \"object\") {\n\t\t\t// Spread object\n\t\t\tfor (const k in logArg) {\n\t\t\t\t// biome-ignore lint/suspicious/noExplicitAny: Unknown type\n\t\t\t\tconst v = (logArg as any)[k];\n\n\t\t\t\tpushArg(k, v, args);\n\t\t\t}\n\t\t} else {\n\t\t\tpushArg(`arg${i}`, logArg, args);\n\t\t}\n\t}\n\n\tconst logTs = getEnvUniversal(\"_LOG_TIMESTAMP\") === \"1\";\n\tconst logTarget = getEnvUniversal(\"_LOG_TARGET\") === \"1\";\n\n\treturn stringify(\n\t\t...(logTs ? [[\"ts\", formatTimestamp(new Date())] as LogEntry] : []),\n\t\t[\"level\", LevelNameMap[log.level]],\n\t\t...(logTarget ? [[\"target\", log.loggerName] as LogEntry] : []),\n\t\t[\"msg\", log.msg],\n\t\t...args,\n\t);\n}\n\nfunction pushArg(k: string, v: unknown, args: LogEntry[]) {\n\targs.push([k, castToLogValue(v)]);\n}\n\n// function getEnv(name: string): string | undefined {\n// \tif (typeof window !== \"undefined\" && window.localStorage) {\n// \t\treturn window.localStorage.getItem(name) || undefined;\n// \t}\n// \treturn undefined;\n// \t// TODO(ACTR-9): Add back env config once node compat layer works\n// \t//return crossGetEnv(name);\n// }\n\nexport function setupLogging() {\n\t// Do nothing for now\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/log.ts\";import { getLogger } from \"@/common//log\";\n\n/** Logger for this library. */\nexport const RUNTIME_LOGGER_NAME = \"actor-runtime\";\n\n/** Logger used for logs from the actor instance itself. */\nexport const ACTOR_LOGGER_NAME = \"actor\";\n\nexport function logger() {\n\treturn getLogger(RUNTIME_LOGGER_NAME);\n}\n\nexport function instanceLogger() {\n\treturn getLogger(ACTOR_LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol/serde.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol/serde.ts\";import * as cbor from \"cbor-x\";\nimport { z } from \"zod\";\nimport * as errors from \"@/actor/errors\";\nimport type { VersionedDataHandler } from \"@/common/versioned-data\";\nimport { serializeWithEncoding } from \"@/serde\";\nimport { logger } from \"../log\";\nimport { assertUnreachable } from \"../utils\";\n\n/** Data that can be deserialized. */\nexport type InputData = string | Buffer | Blob | ArrayBufferLike | Uint8Array;\n\n/** Data that's been serialized. */\nexport type OutputData = string | Uint8Array;\n\nexport const EncodingSchema = z.enum([\"json\", \"cbor\", \"bare\"]);\n\n/**\n * Encoding used to communicate between the client & actor.\n */\nexport type Encoding = z.infer<typeof EncodingSchema>;\n\n/**\n * Helper class that helps serialize data without re-serializing for the same encoding.\n */\nexport class CachedSerializer<T> {\n\t#data: T;\n\t#cache = new Map<Encoding, OutputData>();\n\t#versionedDataHandler: VersionedDataHandler<T>;\n\n\tconstructor(data: T, versionedDataHandler: VersionedDataHandler<T>) {\n\t\tthis.#data = data;\n\t\tthis.#versionedDataHandler = versionedDataHandler;\n\t}\n\n\tpublic get rawData(): T {\n\t\treturn this.#data;\n\t}\n\n\tpublic serialize(encoding: Encoding): OutputData {\n\t\tconst cached = this.#cache.get(encoding);\n\t\tif (cached) {\n\t\t\treturn cached;\n\t\t} else {\n\t\t\tconst serialized = serializeWithEncoding(\n\t\t\t\tencoding,\n\t\t\t\tthis.#data,\n\t\t\t\tthis.#versionedDataHandler,\n\t\t\t);\n\t\t\tthis.#cache.set(encoding, serialized);\n\t\t\treturn serialized;\n\t\t}\n\t}\n}\n\n///**\n// * Use `CachedSerializer` if serializing the same data repeatedly.\n// */\n//export function serialize<T>(value: T, encoding: Encoding): OutputData {\n//\tif (encoding === \"json\") {\n//\t\treturn JSON.stringify(value);\n//\t} else if (encoding === \"cbor\") {\n//\t\t// TODO: Remove this hack, but cbor-x can't handle anything extra in data structures\n//\t\tconst cleanValue = JSON.parse(JSON.stringify(value));\n//\t\treturn cbor.encode(cleanValue);\n//\t} else {\n//\t\tassertUnreachable(encoding);\n//\t}\n//}\n//\n//export async function deserialize(data: InputData, encoding: Encoding) {\n//\tif (encoding === \"json\") {\n//\t\tif (typeof data !== \"string\") {\n//\t\t\tlogger().warn(\"received non-string for json parse\");\n//\t\t\tthrow new errors.MalformedMessage();\n//\t\t} else {\n//\t\t\treturn JSON.parse(data);\n//\t\t}\n//\t} else if (encoding === \"cbor\") {\n//\t\tif (data instanceof Blob) {\n//\t\t\tconst arrayBuffer = await data.arrayBuffer();\n//\t\t\treturn cbor.decode(new Uint8Array(arrayBuffer));\n//\t\t} else if (data instanceof Uint8Array) {\n//\t\t\treturn cbor.decode(data);\n//\t\t} else if (\n//\t\t\tdata instanceof ArrayBuffer ||\n//\t\t\tdata instanceof SharedArrayBuffer\n//\t\t) {\n//\t\t\treturn cbor.decode(new Uint8Array(data));\n//\t\t} else {\n//\t\t\tlogger().warn(\"received non-binary type for cbor parse\");\n//\t\t\tthrow new errors.MalformedMessage();\n//\t\t}\n//\t} else {\n//\t\tassertUnreachable(encoding);\n//\t}\n//}\n\n// TODO: Encode base 128\nfunction base64EncodeUint8Array(uint8Array: Uint8Array): string {\n\tlet binary = \"\";\n\tconst len = uint8Array.byteLength;\n\tfor (let i = 0; i < len; i++) {\n\t\tbinary += String.fromCharCode(uint8Array[i]);\n\t}\n\treturn btoa(binary);\n}\n\nfunction base64EncodeArrayBuffer(arrayBuffer: ArrayBuffer): string {\n\tconst uint8Array = new Uint8Array(arrayBuffer);\n\treturn base64EncodeUint8Array(uint8Array);\n}\n\n/** Converts data that was encoded to a string. Some formats (like SSE) don't support raw binary data. */\nexport function encodeDataToString(message: OutputData): string {\n\tif (typeof message === \"string\") {\n\t\treturn message;\n\t} else if (message instanceof ArrayBuffer) {\n\t\treturn base64EncodeArrayBuffer(message);\n\t} else if (message instanceof Uint8Array) {\n\t\treturn base64EncodeUint8Array(message);\n\t} else {\n\t\tassertUnreachable(message);\n\t}\n}\n\n/** Stringifies with compat for values that BARE & CBOR supports. */\nexport function jsonStringifyCompat(input: any): string {\n\treturn JSON.stringify(input, (_key, value) =>\n\t\ttypeof value === \"bigint\" ? value.toString() : value,\n\t);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/serde.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/serde.ts\";import * as cbor from \"cbor-x\";\nimport invariant from \"invariant\";\nimport { assertUnreachable } from \"@/common/utils\";\nimport type { VersionedDataHandler } from \"@/common/versioned-data\";\nimport type { Encoding } from \"@/mod\";\nimport { jsonStringifyCompat } from \"./actor/protocol/serde\";\n\nexport function encodingIsBinary(encoding: Encoding): boolean {\n\tif (encoding === \"json\") {\n\t\treturn false;\n\t} else if (encoding === \"cbor\" || encoding === \"bare\") {\n\t\treturn true;\n\t} else {\n\t\tassertUnreachable(encoding);\n\t}\n}\n\nexport function contentTypeForEncoding(encoding: Encoding): string {\n\tif (encoding === \"json\") {\n\t\treturn \"application/json\";\n\t} else if (encoding === \"cbor\" || encoding === \"bare\") {\n\t\treturn \"application/octet-stream\";\n\t} else {\n\t\tassertUnreachable(encoding);\n\t}\n}\n\nexport function wsBinaryTypeForEncoding(\n\tencoding: Encoding,\n): \"arraybuffer\" | \"blob\" {\n\tif (encoding === \"json\") {\n\t\treturn \"blob\";\n\t} else if (encoding === \"cbor\" || encoding === \"bare\") {\n\t\treturn \"arraybuffer\";\n\t} else {\n\t\tassertUnreachable(encoding);\n\t}\n}\n\nexport function serializeWithEncoding<T>(\n\tencoding: Encoding,\n\tvalue: T,\n\tversionedDataHandler: VersionedDataHandler<T>,\n): Uint8Array | string {\n\tif (encoding === \"json\") {\n\t\treturn jsonStringifyCompat(value);\n\t} else if (encoding === \"cbor\") {\n\t\treturn cbor.encode(value);\n\t} else if (encoding === \"bare\") {\n\t\treturn versionedDataHandler.serializeWithEmbeddedVersion(value);\n\t} else {\n\t\tassertUnreachable(encoding);\n\t}\n}\n\nexport function deserializeWithEncoding<T>(\n\tencoding: Encoding,\n\tbuffer: Uint8Array | string,\n\tversionedDataHandler: VersionedDataHandler<T>,\n): T {\n\tif (encoding === \"json\") {\n\t\tif (typeof buffer === \"string\") {\n\t\t\treturn JSON.parse(buffer);\n\t\t} else {\n\t\t\tconst decoder = new TextDecoder(\"utf-8\");\n\t\t\tconst jsonString = decoder.decode(buffer);\n\t\t\treturn JSON.parse(jsonString);\n\t\t}\n\t} else if (encoding === \"cbor\") {\n\t\tinvariant(\n\t\t\ttypeof buffer !== \"string\",\n\t\t\t\"buffer cannot be string for cbor encoding\",\n\t\t);\n\t\treturn cbor.decode(buffer);\n\t} else if (encoding === \"bare\") {\n\t\tinvariant(\n\t\t\ttypeof buffer !== \"string\",\n\t\t\t\"buffer cannot be string for bare encoding\",\n\t\t);\n\t\treturn versionedDataHandler.deserializeWithEmbeddedVersion(buffer);\n\t} else {\n\t\tassertUnreachable(encoding);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/utils.ts\";import * as errors from \"./errors\";\nimport { logger } from \"./log\";\n\nexport function assertUnreachable(x: never): never {\n\tlogger().error(\"unreachable\", { value: `${x}`, stack: new Error().stack });\n\tthrow new errors.Unreachable(x);\n}\n\nexport const throttle = <\n\t// biome-ignore lint/suspicious/noExplicitAny: we want to allow any function\n\tFn extends (...args: any) => any,\n>(\n\tfn: Fn,\n\tdelay: number,\n) => {\n\tlet lastRan = false;\n\tlet lastArgs: Parameters<Fn> | null = null;\n\n\treturn (...args: Parameters<Fn>) => {\n\t\tif (!lastRan) {\n\t\t\tfn.apply(this, args);\n\t\t\tlastRan = true;\n\t\t\tconst timer = () =>\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tlastRan = false;\n\t\t\t\t\tif (lastArgs) {\n\t\t\t\t\t\tfn.apply(this, lastArgs);\n\t\t\t\t\t\tlastRan = true;\n\t\t\t\t\t\tlastArgs = null;\n\t\t\t\t\t\ttimer();\n\t\t\t\t\t}\n\t\t\t\t}, delay);\n\t\t\ttimer();\n\t\t} else lastArgs = args;\n\t};\n};\n\nexport class DeadlineError extends Error {\n\tconstructor() {\n\t\tsuper(\"Promise did not complete before deadline.\");\n\t}\n}\n\nexport function deadline<T>(promise: Promise<T>, timeout: number): Promise<T> {\n\tconst controller = new AbortController();\n\tconst signal = controller.signal;\n\n\t// Set a timeout to abort the operation\n\tconst timeoutId = setTimeout(() => controller.abort(), timeout);\n\n\treturn Promise.race<T>([\n\t\tpromise,\n\t\tnew Promise<T>((_, reject) => {\n\t\t\tsignal.addEventListener(\"abort\", () => reject(new DeadlineError()));\n\t\t}),\n\t]).finally(() => {\n\t\tclearTimeout(timeoutId);\n\t});\n}\n\nexport class Lock<T> {\n\tprivate _locked = false;\n\tprivate _waiting: Array<() => void> = [];\n\n\tconstructor(private _value: T) {}\n\n\tasync lock(fn: (value: T) => Promise<void>): Promise<void> {\n\t\tif (this._locked) {\n\t\t\tawait new Promise<void>((resolve) => this._waiting.push(resolve));\n\t\t}\n\t\tthis._locked = true;\n\n\t\ttry {\n\t\t\tawait fn(this._value);\n\t\t} finally {\n\t\t\tthis._locked = false;\n\t\t\tconst next = this._waiting.shift();\n\t\t\tif (next) next();\n\t\t}\n\t}\n}\n\nexport function generateSecureToken(length = 32) {\n\tconst array = new Uint8Array(length);\n\tcrypto.getRandomValues(array);\n\treturn btoa(String.fromCharCode(...array));\n}\n\nexport function generateRandomString(length = 32) {\n\tconst characters =\n\t\t\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\";\n\tlet result = \"\";\n\tfor (let i = 0; i < length; i++) {\n\t\tconst randomIndex = Math.floor(Math.random() * characters.length);\n\t\tresult += characters[randomIndex];\n\t}\n\treturn result;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/config.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/config.ts\";import { z } from \"zod\";\nimport type { UniversalWebSocket } from \"@/common/websocket-interface\";\nimport type { ActionContext } from \"./action\";\nimport type { Conn } from \"./connection\";\nimport type { ActorContext } from \"./context\";\nimport type { AnyDatabaseProvider } from \"./database\";\n\nexport type InitContext = ActorContext<\n\tundefined,\n\tundefined,\n\tundefined,\n\tundefined,\n\tundefined,\n\tundefined,\n\tundefined\n>;\n\nexport interface ActorTypes<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n> {\n\tstate?: TState;\n\tconnParams?: TConnParams;\n\tconnState?: TConnState;\n\tvars?: TVars;\n\tinput?: TInput;\n\tauthData?: TAuthData;\n\tdatabase?: TDatabase;\n}\n\n// This schema is used to validate the input at runtime. The generic types are defined below in `ActorConfig`.\n//\n// We don't use Zod generics with `z.custom` because:\n// (a) there seems to be a weird bug in either Zod, tsup, or TSC that causese external packages to have different types from `z.infer` than from within the same package and\n// (b) it makes the type definitions incredibly difficult to read as opposed to vanilla TypeScript.\nexport const ActorConfigSchema = z\n\t.object({\n\t\tonAuth: z.function().optional(),\n\t\tonCreate: z.function().optional(),\n\t\tonStart: z.function().optional(),\n\t\tonStop: z.function().optional(),\n\t\tonStateChange: z.function().optional(),\n\t\tonBeforeConnect: z.function().optional(),\n\t\tonConnect: z.function().optional(),\n\t\tonDisconnect: z.function().optional(),\n\t\tonBeforeActionResponse: z.function().optional(),\n\t\tonFetch: z.function().optional(),\n\t\tonWebSocket: z.function().optional(),\n\t\tactions: z.record(z.function()).default({}),\n\t\tstate: z.any().optional(),\n\t\tcreateState: z.function().optional(),\n\t\tconnState: z.any().optional(),\n\t\tcreateConnState: z.function().optional(),\n\t\tvars: z.any().optional(),\n\t\tdb: z.any().optional(),\n\t\tcreateVars: z.function().optional(),\n\t\toptions: z\n\t\t\t.object({\n\t\t\t\tcreateVarsTimeout: z.number().positive().default(5000),\n\t\t\t\tcreateConnStateTimeout: z.number().positive().default(5000),\n\t\t\t\tonConnectTimeout: z.number().positive().default(5000),\n\t\t\t\t// This must be less than ACTOR_STOP_THRESHOLD_MS\n\t\t\t\tonStopTimeout: z.number().positive().default(5000),\n\t\t\t\tstateSaveInterval: z.number().positive().default(10_000),\n\t\t\t\tactionTimeout: z.number().positive().default(60_000),\n\t\t\t\t// Max time to wait for waitUntil background promises during shutdown\n\t\t\t\twaitUntilTimeout: z.number().positive().default(15_000),\n\t\t\t\tconnectionLivenessTimeout: z.number().positive().default(2500),\n\t\t\t\tconnectionLivenessInterval: z.number().positive().default(5000),\n\t\t\t\tnoSleep: z.boolean().default(false),\n\t\t\t\tsleepTimeout: z.number().positive().default(30_000),\n\t\t\t})\n\t\t\t.strict()\n\t\t\t.default({}),\n\t})\n\t.strict()\n\t.refine(\n\t\t(data) => !(data.state !== undefined && data.createState !== undefined),\n\t\t{\n\t\t\tmessage: \"Cannot define both 'state' and 'createState'\",\n\t\t\tpath: [\"state\"],\n\t\t},\n\t)\n\t.refine(\n\t\t(data) =>\n\t\t\t!(data.connState !== undefined && data.createConnState !== undefined),\n\t\t{\n\t\t\tmessage: \"Cannot define both 'connState' and 'createConnState'\",\n\t\t\tpath: [\"connState\"],\n\t\t},\n\t)\n\t.refine(\n\t\t(data) => !(data.vars !== undefined && data.createVars !== undefined),\n\t\t{\n\t\t\tmessage: \"Cannot define both 'vars' and 'createVars'\",\n\t\t\tpath: [\"vars\"],\n\t\t},\n\t);\n\nexport interface OnConnectOptions {\n\t/**\n\t * The request object associated with the connection.\n\t *\n\t * @experimental\n\t */\n\trequest?: Request;\n}\n\n// Creates state config\n//\n// This must have only one or the other or else TState will not be able to be inferred\n//\n// Data returned from this handler will be available on `c.state`.\ntype CreateState<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase,\n> =\n\t| { state: TState }\n\t| {\n\t\t\tcreateState: (c: InitContext, input: TInput) => TState | Promise<TState>;\n\t  }\n\t| Record<never, never>;\n\n// Creates connection state config\n//\n// This must have only one or the other or else TState will not be able to be inferred\n//\n// Data returned from this handler will be available on `c.conn.state`.\ntype CreateConnState<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase,\n> =\n\t| { connState: TConnState }\n\t| {\n\t\t\tcreateConnState: (\n\t\t\t\tc: InitContext,\n\t\t\t\topts: OnConnectOptions,\n\t\t\t\tparams: TConnParams,\n\t\t\t) => TConnState | Promise<TConnState>;\n\t  }\n\t| Record<never, never>;\n\n// Creates vars config\n//\n// This must have only one or the other or else TState will not be able to be inferred\n/**\n * @experimental\n */\ntype CreateVars<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase,\n> =\n\t| {\n\t\t\t/**\n\t\t\t * @experimental\n\t\t\t */\n\t\t\tvars: TVars;\n\t  }\n\t| {\n\t\t\t/**\n\t\t\t * @experimental\n\t\t\t */\n\t\t\tcreateVars: (c: InitContext, driverCtx: any) => TVars | Promise<TVars>;\n\t  }\n\t| Record<never, never>;\n\n// Creates auth config\n//\n// This must have only one or the other or else TAuthData will not be able to be inferred\ntype OnAuth<TConnParams, TAuthData> =\n\t| {\n\t\t\t/**\n\t\t\t * Called on the HTTP server before clients can interact with the actor.\n\t\t\t *\n\t\t\t * Only called for public endpoints. Calls to actors from within the backend\n\t\t\t * do not trigger this handler.\n\t\t\t *\n\t\t\t * Data returned from this handler will be available on `c.conn.auth`.\n\t\t\t *\n\t\t\t * This function is required for any public HTTP endpoint access. Use this hook\n\t\t\t * to validate client credentials and return authentication data that will be\n\t\t\t * available on connections. This runs on the HTTP server (not the actor)\n\t\t\t * in order to reduce load on the actor & prevent denial of server attacks\n\t\t\t * against individual actors.\n\t\t\t *\n\t\t\t * If you need access to actor state for authentication, use onBeforeConnect\n\t\t\t * with an empty onAuth function instead.\n\t\t\t *\n\t\t\t * You can also provide your own authentication middleware on your router if you\n\t\t\t * choose, then use onAuth to pass the authentication data (e.g. user ID) to the\n\t\t\t * actor itself.\n\t\t\t *\n\t\t\t * @param opts Authentication options including request and intent\n\t\t\t * @returns Authentication data to attach to connections (must be serializable)\n\t\t\t * @throws Throw an error to deny access to the actor\n\t\t\t */\n\t\t\tonAuth: (\n\t\t\t\topts: OnAuthOptions,\n\t\t\t\tparams: TConnParams,\n\t\t\t) => TAuthData | Promise<TAuthData>;\n\t  }\n\t| Record<never, never>;\n\nexport interface Actions<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n> {\n\t[Action: string]: (\n\t\tc: ActionContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\t...args: any[]\n\t) => any;\n}\n\n//export type ActorConfig<TState, TConnParams, TConnState, TVars, TInput, TAuthData> = BaseActorConfig<TState, TConnParams, TConnState, TVars, TInput, TAuthData> &\n//\tActorConfigLifecycle<TState, TConnParams, TConnState, TVars, TInput, TAuthData> &\n//\tCreateState<TState, TConnParams, TConnState, TVars, TInput, TAuthData> &\n//\tCreateConnState<TState, TConnParams, TConnState, TVars, TInput, TAuthData>;\n\n/**\n * @experimental\n */\nexport type AuthIntent = \"get\" | \"create\" | \"connect\" | \"action\" | \"message\";\n\nexport interface OnAuthOptions {\n\trequest: Request;\n\t/**\n\t * @experimental\n\t */\n\tintents: Set<AuthIntent>;\n}\n\ninterface BaseActorConfig<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n\tTActions extends Actions<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>,\n> {\n\t/**\n\t * Called when the actor is first initialized.\n\t *\n\t * Use this hook to initialize your actor's state.\n\t * This is called before any other lifecycle hooks.\n\t */\n\tonCreate?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tinput: TInput,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called when the actor is started and ready to receive connections and action.\n\t *\n\t * Use this hook to initialize resources needed for the actor's operation\n\t * (timers, external connections, etc.)\n\t *\n\t * @returns Void or a Promise that resolves when startup is complete\n\t */\n\tonStart?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called when the actor is stopping or sleeping.\n\t *\n\t * Use this hook to clean up resources, save state, or perform\n\t * any shutdown operations before the actor sleeps or stops.\n\t *\n\t * Not supported on all platforms.\n\t *\n\t * @returns Void or a Promise that resolves when shutdown is complete\n\t */\n\tonStop?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called when the actor's state changes.\n\t *\n\t * Use this hook to react to state changes, such as updating\n\t * external systems or triggering events.\n\t *\n\t * Note: State changes made within this hook will NOT trigger\n\t * another onStateChange call, preventing infinite recursion.\n\t *\n\t * @param newState The updated state\n\t */\n\tonStateChange?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tnewState: TState,\n\t) => void;\n\n\t/**\n\t * Called before a client connects to the actor.\n\t *\n\t * Unlike onAuth, this handler is still called for both internal and\n\t * public clients.\n\t *\n\t * Use this hook to determine if a connection should be accepted\n\t * and to initialize connection-specific state. Unlike onAuth, this runs\n\t * on the actor and has access to actor state, but uses slightly\n\t * more resources on the actor rather than authenticating with onAuth.\n\t *\n\t * For authentication without actor state access, prefer onAuth.\n\t *\n\t * For authentication with actor state, use onBeforeConnect with an empty\n\t * onAuth handler.\n\t *\n\t * @param opts Connection parameters including client-provided data\n\t * @returns The initial connection state or a Promise that resolves to it\n\t * @throws Throw an error to reject the connection\n\t */\n\tonBeforeConnect?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\topts: OnConnectOptions,\n\t\tparams: TConnParams,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called when a client successfully connects to the actor.\n\t *\n\t * Use this hook to perform actions when a connection is established,\n\t * such as sending initial data or updating the actor's state.\n\t *\n\t * @param conn The connection object\n\t * @returns Void or a Promise that resolves when connection handling is complete\n\t */\n\tonConnect?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tconn: Conn<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called when a client disconnects from the actor.\n\t *\n\t * Use this hook to clean up resources associated with the connection\n\t * or update the actor's state.\n\t *\n\t * @param conn The connection that is being closed\n\t * @returns Void or a Promise that resolves when disconnect handling is complete\n\t */\n\tonDisconnect?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tconn: Conn<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) => void | Promise<void>;\n\n\t/**\n\t * Called before sending an action response to the client.\n\t *\n\t * Use this hook to modify or transform the output of an action before it's sent\n\t * to the client. This is useful for formatting responses, adding metadata,\n\t * or applying transformations to the output.\n\t *\n\t * @param name The name of the action that was called\n\t * @param args The arguments that were passed to the action\n\t * @param output The output that will be sent to the client\n\t * @returns The modified output to send to the client\n\t */\n\tonBeforeActionResponse?: <Out>(\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tname: string,\n\t\targs: unknown[],\n\t\toutput: Out,\n\t) => Out | Promise<Out>;\n\n\t/**\n\t * Called when a raw HTTP request is made to the actor.\n\t *\n\t * This handler receives raw HTTP requests made to `/actors/{actorName}/http/*` endpoints.\n\t * Use this hook to handle custom HTTP patterns, REST APIs, or other HTTP-based protocols.\n\t *\n\t * @param request The raw HTTP request object\n\t * @returns A Response object to send back, or void to continue with default routing\n\t */\n\tonFetch?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\trequest: Request,\n\t\topts: { auth: TAuthData },\n\t) => Response | Promise<Response>;\n\n\t/**\n\t * Called when a raw WebSocket connection is established to the actor.\n\t *\n\t * This handler receives WebSocket connections made to `/actors/{actorName}/websocket/*` endpoints.\n\t * Use this hook to handle custom WebSocket protocols, binary streams, or other WebSocket-based communication.\n\t *\n\t * @param websocket The raw WebSocket connection\n\t * @param request The original HTTP upgrade request\n\t */\n\tonWebSocket?: (\n\t\tc: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\twebsocket: UniversalWebSocket,\n\t\topts: { request: Request; auth: TAuthData },\n\t) => void | Promise<void>;\n\n\tactions: TActions;\n}\n\ntype ActorDatabaseConfig<TDatabase extends AnyDatabaseProvider> =\n\t| {\n\t\t\t/**\n\t\t\t * @experimental\n\t\t\t */\n\t\t\tdb: TDatabase;\n\t  }\n\t| Record<never, never>;\n\n// 1. Infer schema\n// 2. Omit keys that we'll manually define (because of generics)\n// 3. Define our own types that have generic constraints\nexport type ActorConfig<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n> = Omit<\n\tz.infer<typeof ActorConfigSchema>,\n\t| \"actions\"\n\t| \"onAuth\"\n\t| \"onCreate\"\n\t| \"onStart\"\n\t| \"onStateChange\"\n\t| \"onBeforeConnect\"\n\t| \"onConnect\"\n\t| \"onDisconnect\"\n\t| \"onBeforeActionResponse\"\n\t| \"onFetch\"\n\t| \"onWebSocket\"\n\t| \"state\"\n\t| \"createState\"\n\t| \"connState\"\n\t| \"createConnState\"\n\t| \"vars\"\n\t| \"createVars\"\n\t| \"db\"\n> &\n\tBaseActorConfig<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase,\n\t\tActions<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>\n\t> &\n\tOnAuth<TConnParams, TAuthData> &\n\tCreateState<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tCreateConnState<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tCreateVars<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tActorDatabaseConfig<TDatabase>;\n\n// See description on `ActorConfig`\nexport type ActorConfigInput<\n\tTState = undefined,\n\tTConnParams = undefined,\n\tTConnState = undefined,\n\tTVars = undefined,\n\tTInput = undefined,\n\tTAuthData = undefined,\n\tTDatabase extends AnyDatabaseProvider = undefined,\n\tTActions extends Actions<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> = Record<never, never>,\n> = {\n\ttypes?: ActorTypes<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>;\n} & Omit<\n\tz.input<typeof ActorConfigSchema>,\n\t| \"actions\"\n\t| \"onAuth\"\n\t| \"onCreate\"\n\t| \"onStart\"\n\t| \"onStop\"\n\t| \"onStateChange\"\n\t| \"onBeforeConnect\"\n\t| \"onConnect\"\n\t| \"onDisconnect\"\n\t| \"onBeforeActionResponse\"\n\t| \"onFetch\"\n\t| \"onWebSocket\"\n\t| \"state\"\n\t| \"createState\"\n\t| \"connState\"\n\t| \"createConnState\"\n\t| \"vars\"\n\t| \"createVars\"\n\t| \"db\"\n> &\n\tBaseActorConfig<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase,\n\t\tTActions\n\t> &\n\tOnAuth<TConnParams, TAuthData> &\n\tCreateState<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tCreateConnState<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tCreateVars<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t> &\n\tActorDatabaseConfig<TDatabase>;\n\n// For testing type definitions:\nexport function test<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n\tTActions extends Actions<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>,\n>(\n\tinput: ActorConfigInput<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase,\n\t\tTActions\n\t>,\n): ActorConfig<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase\n> {\n\tconst config = ActorConfigSchema.parse(input) as ActorConfig<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>;\n\treturn config;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/instance.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/instance.ts\";import * as cbor from \"cbor-x\";\nimport invariant from \"invariant\";\nimport onChange from \"on-change\";\nimport type { ActorKey } from \"@/actor/mod\";\nimport type { Client } from \"@/client/client\";\nimport type { Logger } from \"@/common/log\";\nimport { isCborSerializable, stringifyError } from \"@/common/utils\";\nimport type { UniversalWebSocket } from \"@/common/websocket-interface\";\nimport { ActorInspector } from \"@/inspector/actor\";\nimport type { Registry } from \"@/mod\";\nimport type * as bareSchema from \"@/schemas/actor-persist/mod\";\nimport { PERSISTED_ACTOR_VERSIONED } from \"@/schemas/actor-persist/versioned\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport { TO_CLIENT_VERSIONED } from \"@/schemas/client-protocol/versioned\";\nimport { bufferToArrayBuffer, SinglePromiseQueue } from \"@/utils\";\nimport type { ActionContext } from \"./action\";\nimport type { ActorConfig, OnConnectOptions } from \"./config\";\nimport {\n\tCONNECTION_CHECK_LIVENESS_SYMBOL,\n\tConn,\n\ttype ConnectionDriver,\n\ttype ConnId,\n} from \"./connection\";\nimport { ActorContext } from \"./context\";\nimport type { AnyDatabaseProvider, InferDatabaseClient } from \"./database\";\nimport type { ActorDriver, ConnDriver, ConnectionDriversMap } from \"./driver\";\nimport * as errors from \"./errors\";\nimport { instanceLogger, logger } from \"./log\";\nimport type {\n\tPersistedActor,\n\tPersistedConn,\n\tPersistedScheduleEvent,\n} from \"./persisted\";\nimport { processMessage } from \"./protocol/old\";\nimport { CachedSerializer } from \"./protocol/serde\";\nimport { Schedule } from \"./schedule\";\nimport { DeadlineError, deadline } from \"./utils\";\n\n/**\n * Options for the `_saveState` method.\n */\nexport interface SaveStateOptions {\n\t/**\n\t * Forces the state to be saved immediately. This function will return when the state has saved successfully.\n\t */\n\timmediate?: boolean;\n\t/** Bypass ready check for stopping. */\n\tallowStoppingState?: boolean;\n}\n\n/** Actor type alias with all `any` types. Used for `extends` in classes referencing this actor. */\nexport type AnyActorInstance = ActorInstance<\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany,\n\t// biome-ignore lint/suspicious/noExplicitAny: Needs to be used in `extends`\n\tany\n>;\n\nexport type ExtractActorState<A extends AnyActorInstance> =\n\tA extends ActorInstance<\n\t\tinfer State,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany\n\t>\n\t\t? State\n\t\t: never;\n\nexport type ExtractActorConnParams<A extends AnyActorInstance> =\n\tA extends ActorInstance<\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\tinfer ConnParams,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany\n\t>\n\t\t? ConnParams\n\t\t: never;\n\nexport type ExtractActorConnState<A extends AnyActorInstance> =\n\tA extends ActorInstance<\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\tinfer ConnState,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany,\n\t\t// biome-ignore lint/suspicious/noExplicitAny: Must be used for `extends`\n\t\tany\n\t>\n\t\t? ConnState\n\t\t: never;\n\nexport class ActorInstance<\n\tS,\n\tCP,\n\tCS,\n\tV,\n\tI,\n\tAD,\n\tDB extends AnyDatabaseProvider,\n> {\n\t// Shared actor context for this instance\n\tactorContext: ActorContext<S, CP, CS, V, I, AD, DB>;\n\t#sleepCalled = false;\n\t#stopCalled = false;\n\n\tget isStopping() {\n\t\treturn this.#stopCalled || this.#sleepCalled;\n\t}\n\n\t#persistChanged = false;\n\t#isInOnStateChange = false;\n\n\t/**\n\t * The proxied state that notifies of changes automatically.\n\t *\n\t * Any data that should be stored indefinitely should be held within this object.\n\t */\n\t#persist!: PersistedActor<S, CP, CS, I>;\n\n\t/** Raw state without the proxy wrapper */\n\t#persistRaw!: PersistedActor<S, CP, CS, I>;\n\n\t#persistWriteQueue = new SinglePromiseQueue();\n\t#alarmWriteQueue = new SinglePromiseQueue();\n\n\t#lastSaveTime = 0;\n\t#pendingSaveTimeout?: NodeJS.Timeout;\n\n\t#vars?: V;\n\n\t#backgroundPromises: Promise<void>[] = [];\n\t#abortController = new AbortController();\n\t#config: ActorConfig<S, CP, CS, V, I, AD, DB>;\n\t#connectionDrivers!: ConnectionDriversMap;\n\t#actorDriver!: ActorDriver;\n\t#inlineClient!: Client<Registry<any>>;\n\t#actorId!: string;\n\t#name!: string;\n\t#key!: ActorKey;\n\t#region!: string;\n\t#ready = false;\n\n\t#connections = new Map<ConnId, Conn<S, CP, CS, V, I, AD, DB>>();\n\t#subscriptionIndex = new Map<string, Set<Conn<S, CP, CS, V, I, AD, DB>>>();\n\t#checkConnLivenessInterval?: NodeJS.Timeout;\n\n\t#sleepTimeout?: NodeJS.Timeout;\n\n\t// Track active raw requests so sleep logic can account for them\n\t#activeRawFetchCount = 0;\n\t#activeRawWebSockets = new Set<UniversalWebSocket>();\n\n\t#schedule!: Schedule;\n\t#db!: InferDatabaseClient<DB>;\n\n\t#inspector = new ActorInspector(() => {\n\t\treturn {\n\t\t\tisDbEnabled: async () => {\n\t\t\t\treturn this.#db !== undefined;\n\t\t\t},\n\t\t\tgetDb: async () => {\n\t\t\t\treturn this.db;\n\t\t\t},\n\t\t\tisStateEnabled: async () => {\n\t\t\t\treturn this.stateEnabled;\n\t\t\t},\n\t\t\tgetState: async () => {\n\t\t\t\tthis.#validateStateEnabled();\n\n\t\t\t\t// Must return from `#persistRaw` in order to not return the `onchange` proxy\n\t\t\t\treturn this.#persistRaw.state as Record<string, any> as unknown;\n\t\t\t},\n\t\t\tgetRpcs: async () => {\n\t\t\t\treturn Object.keys(this.#config.actions);\n\t\t\t},\n\t\t\tgetConnections: async () => {\n\t\t\t\treturn Array.from(this.#connections.entries()).map(([id, conn]) => ({\n\t\t\t\t\tid,\n\t\t\t\t\tstateEnabled: conn._stateEnabled,\n\t\t\t\t\tparams: conn.params as {},\n\t\t\t\t\tstate: conn._stateEnabled ? conn.state : undefined,\n\t\t\t\t\tauth: conn.auth as {},\n\t\t\t\t}));\n\t\t\t},\n\t\t\tsetState: async (state: unknown) => {\n\t\t\t\tthis.#validateStateEnabled();\n\n\t\t\t\t// Must set on `#persist` instead of `#persistRaw` in order to ensure that the `Proxy` is correctly configured\n\t\t\t\t//\n\t\t\t\t// We have to use `...` so `on-change` recognizes the changes to `state` (i.e. set #persistChanged` to true). This is because:\n\t\t\t\t// 1. In `getState`, we returned the value from `persistRaw`, which does not have the Proxy to monitor state changes\n\t\t\t\t// 2. If we were to assign `state` to `#persist.s`, `on-change` would assume nothing changed since `state` is still === `#persist.s` since we returned a reference in `getState`\n\t\t\t\tthis.#persist.state = { ...(state as S) };\n\t\t\t\tawait this.saveState({ immediate: true });\n\t\t\t},\n\t\t};\n\t});\n\n\tget id() {\n\t\treturn this.#actorId;\n\t}\n\n\tget inlineClient(): Client<Registry<any>> {\n\t\treturn this.#inlineClient;\n\t}\n\n\tget inspector() {\n\t\treturn this.#inspector;\n\t}\n\n\tget #sleepingSupported(): boolean {\n\t\treturn this.#actorDriver.sleep !== undefined;\n\t}\n\n\t/**\n\t * This constructor should never be used directly.\n\t *\n\t * Constructed in {@link ActorInstance.start}.\n\t *\n\t * @private\n\t */\n\tconstructor(config: ActorConfig<S, CP, CS, V, I, AD, DB>) {\n\t\tthis.#config = config;\n\t\tthis.actorContext = new ActorContext(this);\n\t}\n\n\tasync start(\n\t\tconnectionDrivers: ConnectionDriversMap,\n\t\tactorDriver: ActorDriver,\n\t\tinlineClient: Client<Registry<any>>,\n\t\tactorId: string,\n\t\tname: string,\n\t\tkey: ActorKey,\n\t\tregion: string,\n\t) {\n\t\tthis.#connectionDrivers = connectionDrivers;\n\t\tthis.#actorDriver = actorDriver;\n\t\tthis.#inlineClient = inlineClient;\n\t\tthis.#actorId = actorId;\n\t\tthis.#name = name;\n\t\tthis.#key = key;\n\t\tthis.#region = region;\n\t\tthis.#schedule = new Schedule(this);\n\n\t\t// Initialize server\n\t\t//\n\t\t// Store the promise so network requests can await initialization\n\t\tawait this.#initialize();\n\n\t\t// TODO: Exit process if this errors\n\t\tif (this.#varsEnabled) {\n\t\t\tlet vars: V | undefined;\n\t\t\tif (\"createVars\" in this.#config) {\n\t\t\t\tconst dataOrPromise = this.#config.createVars(\n\t\t\t\t\tthis.actorContext as unknown as ActorContext<\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tany\n\t\t\t\t\t>,\n\t\t\t\t\tthis.#actorDriver.getContext(this.#actorId),\n\t\t\t\t);\n\t\t\t\tif (dataOrPromise instanceof Promise) {\n\t\t\t\t\tvars = await deadline(\n\t\t\t\t\t\tdataOrPromise,\n\t\t\t\t\t\tthis.#config.options.createVarsTimeout,\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\tvars = dataOrPromise;\n\t\t\t\t}\n\t\t\t} else if (\"vars\" in this.#config) {\n\t\t\t\tvars = structuredClone(this.#config.vars);\n\t\t\t} else {\n\t\t\t\tthrow new Error(\"Could not variables from 'createVars' or 'vars'\");\n\t\t\t}\n\t\t\tthis.#vars = vars;\n\t\t}\n\n\t\t// TODO: Exit process if this errors\n\t\tlogger().info(\"actor starting\");\n\t\tif (this.#config.onStart) {\n\t\t\tconst result = this.#config.onStart(this.actorContext);\n\t\t\tif (result instanceof Promise) {\n\t\t\t\tawait result;\n\t\t\t}\n\t\t}\n\n\t\t// Setup Database\n\t\tif (\"db\" in this.#config && this.#config.db) {\n\t\t\tconst client = await this.#config.db.createClient({\n\t\t\t\tgetDatabase: () => actorDriver.getDatabase(this.#actorId),\n\t\t\t});\n\t\t\tlogger().info(\"database migration starting\");\n\t\t\tawait this.#config.db.onMigrate?.(client);\n\t\t\tlogger().info(\"database migration complete\");\n\t\t\tthis.#db = client;\n\t\t}\n\n\t\t// Set alarm for next scheduled event if any exist after finishing initiation sequence\n\t\tif (this.#persist.scheduledEvents.length > 0) {\n\t\t\tawait this.#queueSetAlarm(this.#persist.scheduledEvents[0].timestamp);\n\t\t}\n\n\t\tlogger().info(\"actor ready\");\n\t\tthis.#ready = true;\n\n\t\t// Must be called after setting `#ready` or else it will not schedule sleep\n\t\tthis.#resetSleepTimer();\n\n\t\t// Start conn liveness interval\n\t\t//\n\t\t// Check for liveness immediately since we may have connections that\n\t\t// were in `reconnecting` state when the actor went to sleep that we\n\t\t// need to purge.\n\t\t//\n\t\t// We don't use alarms for connection liveness since alarms require\n\t\t// durability & are expensive. Connection liveness is safe to assume\n\t\t// it only needs to be ran while the actor is awake and does not need\n\t\t// to manually wake the actor. The only case this is not true is if the\n\t\t// connection liveness timeout is greater than the actor sleep timeout\n\t\t// OR if the actor is manually put to sleep. In this case, the connections\n\t\t// will be stuck in a `reconnecting` state until the actor is awaken again.\n\t\tthis.#checkConnLivenessInterval = setInterval(\n\t\t\tthis.#checkConnectionsLiveness.bind(this),\n\t\t\tthis.#config.options.connectionLivenessInterval,\n\t\t);\n\t\tthis.#checkConnectionsLiveness();\n\t}\n\n\tasync #scheduleEventInner(newEvent: PersistedScheduleEvent) {\n\t\tthis.actorContext.log.info(\"scheduling event\", newEvent);\n\n\t\t// Insert event in to index\n\t\tconst insertIndex = this.#persist.scheduledEvents.findIndex(\n\t\t\t(x) => x.timestamp > newEvent.timestamp,\n\t\t);\n\t\tif (insertIndex === -1) {\n\t\t\tthis.#persist.scheduledEvents.push(newEvent);\n\t\t} else {\n\t\t\tthis.#persist.scheduledEvents.splice(insertIndex, 0, newEvent);\n\t\t}\n\n\t\t// Update alarm if:\n\t\t// - this is the newest event (i.e. at beginning of array) or\n\t\t// - this is the only event (i.e. the only event in the array)\n\t\tif (insertIndex === 0 || this.#persist.scheduledEvents.length === 1) {\n\t\t\tthis.actorContext.log.info(\"setting alarm\", {\n\t\t\t\ttimestamp: newEvent.timestamp,\n\t\t\t\teventCount: this.#persist.scheduledEvents.length,\n\t\t\t});\n\t\t\tawait this.#queueSetAlarm(newEvent.timestamp);\n\t\t}\n\t}\n\n\tasync _onAlarm() {\n\t\tconst now = Date.now();\n\t\tthis.actorContext.log.debug(\"alarm triggered\", {\n\t\t\tnow,\n\t\t\tevents: this.#persist.scheduledEvents.length,\n\t\t});\n\n\t\t// Update sleep\n\t\t//\n\t\t// Do this before any async logic\n\t\tthis.#resetSleepTimer();\n\n\t\t// Remove events from schedule that we're about to run\n\t\tconst runIndex = this.#persist.scheduledEvents.findIndex(\n\t\t\t(x) => x.timestamp <= now,\n\t\t);\n\t\tif (runIndex === -1) {\n\t\t\t// No events are due yet. This will happen if timers fire slightly early.\n\t\t\t// Ensure we reschedule the alarm for the next upcoming event to avoid losing it.\n\t\t\tlogger().warn(\"no events are due yet, time may have broken\");\n\t\t\tif (this.#persist.scheduledEvents.length > 0) {\n\t\t\t\tconst nextTs = this.#persist.scheduledEvents[0].timestamp;\n\t\t\t\tthis.actorContext.log.warn(\n\t\t\t\t\t\"alarm fired early, rescheduling for next event\",\n\t\t\t\t\t{\n\t\t\t\t\t\tnow,\n\t\t\t\t\t\tnextTs,\n\t\t\t\t\t\tdelta: nextTs - now,\n\t\t\t\t\t},\n\t\t\t\t);\n\t\t\t\tawait this.#queueSetAlarm(nextTs);\n\t\t\t}\n\t\t\tthis.actorContext.log.debug(\"no events to run\", { now });\n\t\t\treturn;\n\t\t}\n\t\tconst scheduleEvents = this.#persist.scheduledEvents.splice(\n\t\t\t0,\n\t\t\trunIndex + 1,\n\t\t);\n\t\tthis.actorContext.log.debug(\"running events\", {\n\t\t\tcount: scheduleEvents.length,\n\t\t});\n\n\t\t// Set alarm for next event\n\t\tif (this.#persist.scheduledEvents.length > 0) {\n\t\t\tconst nextTs = this.#persist.scheduledEvents[0].timestamp;\n\t\t\tthis.actorContext.log.info(\"setting next alarm\", {\n\t\t\t\tnextTs,\n\t\t\t\tremainingEvents: this.#persist.scheduledEvents.length,\n\t\t\t});\n\t\t\tawait this.#queueSetAlarm(nextTs);\n\t\t}\n\n\t\t// Iterate by event key in order to ensure we call the events in order\n\t\tfor (const event of scheduleEvents) {\n\t\t\ttry {\n\t\t\t\tthis.actorContext.log.info(\"running action for event\", {\n\t\t\t\t\tevent: event.eventId,\n\t\t\t\t\ttimestamp: event.timestamp,\n\t\t\t\t\taction: event.kind.generic.actionName,\n\t\t\t\t});\n\n\t\t\t\t// Look up function\n\t\t\t\tconst fn: unknown = this.#config.actions[event.kind.generic.actionName];\n\n\t\t\t\tif (!fn)\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`Missing action for alarm ${event.kind.generic.actionName}`,\n\t\t\t\t\t);\n\t\t\t\tif (typeof fn !== \"function\")\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t`Alarm function lookup for ${event.kind.generic.actionName} returned ${typeof fn}`,\n\t\t\t\t\t);\n\n\t\t\t\t// Call function\n\t\t\t\ttry {\n\t\t\t\t\tconst args = event.kind.generic.args\n\t\t\t\t\t\t? cbor.decode(new Uint8Array(event.kind.generic.args))\n\t\t\t\t\t\t: [];\n\t\t\t\t\tawait fn.call(undefined, this.actorContext, ...args);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tthis.actorContext.log.error(\"error while running event\", {\n\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t\tevent: event.eventId,\n\t\t\t\t\t\ttimestamp: event.timestamp,\n\t\t\t\t\t\taction: event.kind.generic.actionName,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tthis.actorContext.log.error(\"internal error while running event\", {\n\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t...event,\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\tasync scheduleEvent(\n\t\ttimestamp: number,\n\t\taction: string,\n\t\targs: unknown[],\n\t): Promise<void> {\n\t\treturn this.#scheduleEventInner({\n\t\t\teventId: crypto.randomUUID(),\n\t\t\ttimestamp,\n\t\t\tkind: {\n\t\t\t\tgeneric: {\n\t\t\t\t\tactionName: action,\n\t\t\t\t\targs: bufferToArrayBuffer(cbor.encode(args)),\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t}\n\n\tget stateEnabled() {\n\t\treturn \"createState\" in this.#config || \"state\" in this.#config;\n\t}\n\n\t#validateStateEnabled() {\n\t\tif (!this.stateEnabled) {\n\t\t\tthrow new errors.StateNotEnabled();\n\t\t}\n\t}\n\n\tget #connStateEnabled() {\n\t\treturn \"createConnState\" in this.#config || \"connState\" in this.#config;\n\t}\n\n\tget #varsEnabled() {\n\t\treturn \"createVars\" in this.#config || \"vars\" in this.#config;\n\t}\n\n\t#validateVarsEnabled() {\n\t\tif (!this.#varsEnabled) {\n\t\t\tthrow new errors.VarsNotEnabled();\n\t\t}\n\t}\n\n\t/** Promise used to wait for a save to complete. This is required since you cannot await `#saveStateThrottled`. */\n\t#onPersistSavedPromise?: PromiseWithResolvers<void>;\n\n\t/** Throttled save state method. Used to write to KV at a reasonable cadence. */\n\t#savePersistThrottled() {\n\t\tconst now = Date.now();\n\t\tconst timeSinceLastSave = now - this.#lastSaveTime;\n\t\tconst saveInterval = this.#config.options.stateSaveInterval;\n\n\t\t// If we're within the throttle window and not already scheduled, schedule the next save.\n\t\tif (timeSinceLastSave < saveInterval) {\n\t\t\tif (this.#pendingSaveTimeout === undefined) {\n\t\t\t\tthis.#pendingSaveTimeout = setTimeout(() => {\n\t\t\t\t\tthis.#pendingSaveTimeout = undefined;\n\t\t\t\t\tthis.#savePersistInner();\n\t\t\t\t}, saveInterval - timeSinceLastSave);\n\t\t\t}\n\t\t} else {\n\t\t\t// If we're outside the throttle window, save immediately\n\t\t\tthis.#savePersistInner();\n\t\t}\n\t}\n\n\t/** Saves the state to KV. You probably want to use #saveStateThrottled instead except for a few edge cases. */\n\tasync #savePersistInner() {\n\t\ttry {\n\t\t\tthis.#lastSaveTime = Date.now();\n\n\t\t\tif (this.#persistChanged) {\n\t\t\t\tconst finished = this.#persistWriteQueue.enqueue(async () => {\n\t\t\t\t\tlogger().debug(\"saving persist\");\n\n\t\t\t\t\t// There might be more changes while we're writing, so we set this\n\t\t\t\t\t// before writing to KV in order to avoid a race condition.\n\t\t\t\t\tthis.#persistChanged = false;\n\n\t\t\t\t\t// Convert to BARE types and write to KV\n\t\t\t\t\tconst bareData = this.#convertToBarePersisted(this.#persistRaw);\n\t\t\t\t\tawait this.#actorDriver.writePersistedData(\n\t\t\t\t\t\tthis.#actorId,\n\t\t\t\t\t\tPERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData),\n\t\t\t\t\t);\n\n\t\t\t\t\tlogger().debug(\"persist saved\");\n\t\t\t\t});\n\n\t\t\t\tawait finished;\n\t\t\t}\n\n\t\t\tthis.#onPersistSavedPromise?.resolve();\n\t\t} catch (error) {\n\t\t\tthis.#onPersistSavedPromise?.reject(error);\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync #queueSetAlarm(timestamp: number): Promise<void> {\n\t\tawait this.#alarmWriteQueue.enqueue(async () => {\n\t\t\tawait this.#actorDriver.setAlarm(this, timestamp);\n\t\t});\n\t}\n\n\t/**\n\t * Creates proxy for `#persist` that handles automatically flagging when state needs to be updated.\n\t */\n\t#setPersist(target: PersistedActor<S, CP, CS, I>) {\n\t\t// Set raw persist object\n\t\tthis.#persistRaw = target;\n\n\t\t// TODO: Only validate this for conn state\n\t\t// TODO: Allow disabling in production\n\t\t// If this can't be proxied, return raw value\n\t\tif (target === null || typeof target !== \"object\") {\n\t\t\tlet invalidPath = \"\";\n\t\t\tif (\n\t\t\t\t!isCborSerializable(\n\t\t\t\t\ttarget,\n\t\t\t\t\t(path) => {\n\t\t\t\t\t\tinvalidPath = path;\n\t\t\t\t\t},\n\t\t\t\t\t\"\",\n\t\t\t\t)\n\t\t\t) {\n\t\t\t\tthrow new errors.InvalidStateType({ path: invalidPath });\n\t\t\t}\n\t\t\treturn target;\n\t\t}\n\n\t\t// Unsubscribe from old state\n\t\tif (this.#persist) {\n\t\t\tonChange.unsubscribe(this.#persist);\n\t\t}\n\n\t\t// Listen for changes to the object in order to automatically write state\n\t\tthis.#persist = onChange(\n\t\t\ttarget,\n\t\t\t// biome-ignore lint/suspicious/noExplicitAny: Don't know types in proxy\n\t\t\t(path: string, value: any, _previousValue: any, _applyData: any) => {\n\t\t\t\tif (path !== \"state\" && !path.startsWith(\"state.\")) {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tlet invalidPath = \"\";\n\t\t\t\tif (\n\t\t\t\t\t!isCborSerializable(\n\t\t\t\t\t\tvalue,\n\t\t\t\t\t\t(invalidPathPart) => {\n\t\t\t\t\t\t\tinvalidPath = invalidPathPart;\n\t\t\t\t\t\t},\n\t\t\t\t\t\t\"\",\n\t\t\t\t\t)\n\t\t\t\t) {\n\t\t\t\t\tthrow new errors.InvalidStateType({\n\t\t\t\t\t\tpath: path + (invalidPath ? `.${invalidPath}` : \"\"),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t\tthis.#persistChanged = true;\n\n\t\t\t\t// Inform the inspector about state changes\n\t\t\t\tthis.inspector.emitter.emit(\"stateUpdated\", this.#persist.state);\n\n\t\t\t\t// Call onStateChange if it exists\n\t\t\t\t// Skip if we're already inside onStateChange to prevent infinite recursion\n\t\t\t\tif (this.#config.onStateChange && this.#ready && !this.#isInOnStateChange) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#isInOnStateChange = true;\n\t\t\t\t\t\tthis.#config.onStateChange(\n\t\t\t\t\t\t\tthis.actorContext,\n\t\t\t\t\t\t\tthis.#persistRaw.state,\n\t\t\t\t\t\t);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in `_onStateChange`\", {\n\t\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t\t});\n\t\t\t\t\t} finally {\n\t\t\t\t\t\tthis.#isInOnStateChange = false;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\t// State will be flushed at the end of the action\n\t\t\t},\n\t\t\t{ ignoreDetached: true },\n\t\t);\n\t}\n\n\tasync #initialize() {\n\t\t// Read initial state\n\t\tconst persistDataBuffer = await this.#actorDriver.readPersistedData(\n\t\t\tthis.#actorId,\n\t\t);\n\t\tinvariant(\n\t\t\tpersistDataBuffer !== undefined,\n\t\t\t\"persist data has not been set, it should be set when initialized\",\n\t\t);\n\t\tconst bareData =\n\t\t\tPERSISTED_ACTOR_VERSIONED.deserializeWithEmbeddedVersion(\n\t\t\t\tpersistDataBuffer,\n\t\t\t);\n\t\tconst persistData = this.#convertFromBarePersisted(bareData);\n\n\t\tif (persistData.hasInitiated) {\n\t\t\tlogger().info(\"actor restoring\", {\n\t\t\t\tconnections: persistData.connections.length,\n\t\t\t});\n\n\t\t\t// Set initial state\n\t\t\tthis.#setPersist(persistData);\n\n\t\t\t// Load connections\n\t\t\tfor (const connPersist of this.#persist.connections) {\n\t\t\t\t// Create connections\n\t\t\t\tconst driver = this.__getConnDriver(connPersist.connDriver);\n\t\t\t\tconst conn = new Conn<S, CP, CS, V, I, AD, DB>(\n\t\t\t\t\tthis,\n\t\t\t\t\tconnPersist,\n\t\t\t\t\tdriver,\n\t\t\t\t\tthis.#connStateEnabled,\n\t\t\t\t);\n\t\t\t\tthis.#connections.set(conn.id, conn);\n\n\t\t\t\t// Register event subscriptions\n\t\t\t\tfor (const sub of connPersist.subscriptions) {\n\t\t\t\t\tthis.#addSubscription(sub.eventName, conn, true);\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tlogger().info(\"actor creating\");\n\n\t\t\t// Initialize actor state\n\t\t\tlet stateData: unknown;\n\t\t\tif (this.stateEnabled) {\n\t\t\t\tlogger().info(\"actor state initializing\");\n\n\t\t\t\tif (\"createState\" in this.#config) {\n\t\t\t\t\tthis.#config.createState;\n\n\t\t\t\t\t// Convert state to undefined since state is not defined yet here\n\t\t\t\t\tstateData = await this.#config.createState(\n\t\t\t\t\t\tthis.actorContext as unknown as ActorContext<\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined,\n\t\t\t\t\t\t\tundefined\n\t\t\t\t\t\t>,\n\t\t\t\t\t\tpersistData.input!,\n\t\t\t\t\t);\n\t\t\t\t} else if (\"state\" in this.#config) {\n\t\t\t\t\tstateData = structuredClone(this.#config.state);\n\t\t\t\t} else {\n\t\t\t\t\tthrow new Error(\"Both 'createState' or 'state' were not defined\");\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tlogger().debug(\"state not enabled\");\n\t\t\t}\n\n\t\t\t// Save state and mark as initialized\n\t\t\tpersistData.state = stateData as S;\n\t\t\tpersistData.hasInitiated = true;\n\n\t\t\t// Update state\n\t\t\tlogger().debug(\"writing state\");\n\t\t\tconst bareData = this.#convertToBarePersisted(persistData);\n\t\t\tawait this.#actorDriver.writePersistedData(\n\t\t\t\tthis.#actorId,\n\t\t\t\tPERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(bareData),\n\t\t\t);\n\n\t\t\tthis.#setPersist(persistData);\n\n\t\t\t// Notify creation\n\t\t\tif (this.#config.onCreate) {\n\t\t\t\tawait this.#config.onCreate(this.actorContext, persistData.input!);\n\t\t\t}\n\t\t}\n\t}\n\n\t__getConnForId(id: string): Conn<S, CP, CS, V, I, AD, DB> | undefined {\n\t\treturn this.#connections.get(id);\n\t}\n\n\t/**\n\t * Removes a connection and cleans up its resources.\n\t */\n\t__removeConn(conn: Conn<S, CP, CS, V, I, AD, DB> | undefined) {\n\t\tif (!conn) {\n\t\t\tlogger().warn(\"`conn` does not exist\");\n\t\t\treturn;\n\t\t}\n\n\t\t// Remove from persist & save immediately\n\t\tconst connIdx = this.#persist.connections.findIndex(\n\t\t\t(c) => c.connId === conn.id,\n\t\t);\n\t\tif (connIdx !== -1) {\n\t\t\tthis.#persist.connections.splice(connIdx, 1);\n\t\t\tthis.saveState({ immediate: true, allowStoppingState: true });\n\t\t} else {\n\t\t\tlogger().warn(\"could not find persisted connection to remove\", {\n\t\t\t\tconnId: conn.id,\n\t\t\t});\n\t\t}\n\n\t\t// Remove from state\n\t\tthis.#connections.delete(conn.id);\n\n\t\t// Remove subscriptions\n\t\tfor (const eventName of [...conn.subscriptions.values()]) {\n\t\t\tthis.#removeSubscription(eventName, conn, true);\n\t\t}\n\n\t\tthis.inspector.emitter.emit(\"connectionUpdated\");\n\t\tif (this.#config.onDisconnect) {\n\t\t\ttry {\n\t\t\t\tconst result = this.#config.onDisconnect(this.actorContext, conn);\n\t\t\t\tif (result instanceof Promise) {\n\t\t\t\t\t// Handle promise but don't await it to prevent blocking\n\t\t\t\t\tresult.catch((error) => {\n\t\t\t\t\t\tlogger().error(\"error in `onDisconnect`\", {\n\t\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"error in `onDisconnect`\", {\n\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\n\t\t// Update sleep\n\t\tthis.#resetSleepTimer();\n\t}\n\n\tasync prepareConn(\n\t\t// biome-ignore lint/suspicious/noExplicitAny: TypeScript bug with ExtractActorConnParams<this>,\n\t\tparams: any,\n\t\trequest?: Request,\n\t): Promise<CS> {\n\t\t// Authenticate connection\n\t\tlet connState: CS | undefined;\n\n\t\tconst onBeforeConnectOpts = {\n\t\t\trequest,\n\t\t} satisfies OnConnectOptions;\n\n\t\tif (this.#config.onBeforeConnect) {\n\t\t\tawait this.#config.onBeforeConnect(\n\t\t\t\tthis.actorContext,\n\t\t\t\tonBeforeConnectOpts,\n\t\t\t\tparams,\n\t\t\t);\n\t\t}\n\n\t\tif (this.#connStateEnabled) {\n\t\t\tif (\"createConnState\" in this.#config) {\n\t\t\t\tconst dataOrPromise = this.#config.createConnState(\n\t\t\t\t\tthis.actorContext as unknown as ActorContext<\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined,\n\t\t\t\t\t\tundefined\n\t\t\t\t\t>,\n\t\t\t\t\tonBeforeConnectOpts,\n\t\t\t\t\tparams,\n\t\t\t\t);\n\t\t\t\tif (dataOrPromise instanceof Promise) {\n\t\t\t\t\tconnState = await deadline(\n\t\t\t\t\t\tdataOrPromise,\n\t\t\t\t\t\tthis.#config.options.createConnStateTimeout,\n\t\t\t\t\t);\n\t\t\t\t} else {\n\t\t\t\t\tconnState = dataOrPromise;\n\t\t\t\t}\n\t\t\t} else if (\"connState\" in this.#config) {\n\t\t\t\tconnState = structuredClone(this.#config.connState);\n\t\t\t} else {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t\"Could not create connection state from 'createConnState' or 'connState'\",\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\treturn connState as CS;\n\t}\n\n\t__getConnDriver(driverId: ConnectionDriver): ConnDriver {\n\t\t// Get driver\n\t\tconst driver = this.#connectionDrivers[driverId];\n\t\tif (!driver) throw new Error(`No connection driver: ${driverId}`);\n\t\treturn driver;\n\t}\n\n\t/**\n\t * Called after establishing a connection handshake.\n\t */\n\tasync createConn(\n\t\tconnectionId: string,\n\t\tconnectionToken: string,\n\t\tparams: CP,\n\t\tstate: CS,\n\t\tdriverId: ConnectionDriver,\n\t\tdriverState: unknown,\n\t\tauthData: unknown,\n\t): Promise<Conn<S, CP, CS, V, I, AD, DB>> {\n\t\tthis.#assertReady();\n\n\t\tif (this.#connections.has(connectionId)) {\n\t\t\tthrow new Error(`Connection already exists: ${connectionId}`);\n\t\t}\n\n\t\t// Create connection\n\t\tconst driver = this.__getConnDriver(driverId);\n\t\tconst persist: PersistedConn<CP, CS> = {\n\t\t\tconnId: connectionId,\n\t\t\ttoken: connectionToken,\n\t\t\tconnDriver: driverId,\n\t\t\tconnDriverState: driverState,\n\t\t\tparams: params,\n\t\t\tstate: state,\n\t\t\tauthData: authData,\n\t\t\tlastSeen: Date.now(),\n\t\t\tsubscriptions: [],\n\t\t};\n\t\tconst conn = new Conn<S, CP, CS, V, I, AD, DB>(\n\t\t\tthis,\n\t\t\tpersist,\n\t\t\tdriver,\n\t\t\tthis.#connStateEnabled,\n\t\t);\n\t\tthis.#connections.set(conn.id, conn);\n\n\t\t// Update sleep\n\t\t//\n\t\t// Do this immediately after adding connection & before any async logic in order to avoid race conditions with sleep timeouts\n\t\tthis.#resetSleepTimer();\n\n\t\t// Add to persistence & save immediately\n\t\tthis.#persist.connections.push(persist);\n\t\tthis.saveState({ immediate: true });\n\n\t\t// Handle connection\n\t\tif (this.#config.onConnect) {\n\t\t\ttry {\n\t\t\t\tconst result = this.#config.onConnect(this.actorContext, conn);\n\t\t\t\tif (result instanceof Promise) {\n\t\t\t\t\tdeadline(result, this.#config.options.onConnectTimeout).catch(\n\t\t\t\t\t\t(error) => {\n\t\t\t\t\t\t\tlogger().error(\"error in `onConnect`, closing socket\", {\n\t\t\t\t\t\t\t\terror,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tconn?.disconnect(\"`onConnect` failed\");\n\t\t\t\t\t\t},\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"error in `onConnect`\", {\n\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t});\n\t\t\t\tconn?.disconnect(\"`onConnect` failed\");\n\t\t\t}\n\t\t}\n\n\t\tthis.inspector.emitter.emit(\"connectionUpdated\");\n\n\t\t// Send init message\n\t\tconn._sendMessage(\n\t\t\tnew CachedSerializer<protocol.ToClient>(\n\t\t\t\t{\n\t\t\t\t\tbody: {\n\t\t\t\t\t\ttag: \"Init\",\n\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\tactorId: this.id,\n\t\t\t\t\t\t\tconnectionId: conn.id,\n\t\t\t\t\t\t\tconnectionToken: conn._token,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t),\n\t\t);\n\n\t\treturn conn;\n\t}\n\n\t// MARK: Messages\n\tasync processMessage(\n\t\tmessage: protocol.ToServer,\n\t\tconn: Conn<S, CP, CS, V, I, AD, DB>,\n\t) {\n\t\tawait processMessage(message, this, conn, {\n\t\t\tonExecuteAction: async (ctx, name, args) => {\n\t\t\t\tthis.inspector.emitter.emit(\"eventFired\", {\n\t\t\t\t\ttype: \"action\",\n\t\t\t\t\tname,\n\t\t\t\t\targs,\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\treturn await this.executeAction(ctx, name, args);\n\t\t\t},\n\t\t\tonSubscribe: async (eventName, conn) => {\n\t\t\t\tthis.inspector.emitter.emit(\"eventFired\", {\n\t\t\t\t\ttype: \"subscribe\",\n\t\t\t\t\teventName,\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\tthis.#addSubscription(eventName, conn, false);\n\t\t\t},\n\t\t\tonUnsubscribe: async (eventName, conn) => {\n\t\t\t\tthis.inspector.emitter.emit(\"eventFired\", {\n\t\t\t\t\ttype: \"unsubscribe\",\n\t\t\t\t\teventName,\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\tthis.#removeSubscription(eventName, conn, false);\n\t\t\t},\n\t\t});\n\t}\n\n\t// MARK: Events\n\t#addSubscription(\n\t\teventName: string,\n\t\tconnection: Conn<S, CP, CS, V, I, AD, DB>,\n\t\tfromPersist: boolean,\n\t) {\n\t\tif (connection.subscriptions.has(eventName)) {\n\t\t\tlogger().debug(\"connection already has subscription\", { eventName });\n\t\t\treturn;\n\t\t}\n\n\t\t// Persist subscriptions & save immediately\n\t\t//\n\t\t// Don't update persistence if already restoring from persistence\n\t\tif (!fromPersist) {\n\t\t\tconnection.__persist.subscriptions.push({ eventName: eventName });\n\t\t\tthis.saveState({ immediate: true });\n\t\t}\n\n\t\t// Update subscriptions\n\t\tconnection.subscriptions.add(eventName);\n\n\t\t// Update subscription index\n\t\tlet subscribers = this.#subscriptionIndex.get(eventName);\n\t\tif (!subscribers) {\n\t\t\tsubscribers = new Set();\n\t\t\tthis.#subscriptionIndex.set(eventName, subscribers);\n\t\t}\n\t\tsubscribers.add(connection);\n\t}\n\n\t#removeSubscription(\n\t\teventName: string,\n\t\tconnection: Conn<S, CP, CS, V, I, AD, DB>,\n\t\tfromRemoveConn: boolean,\n\t) {\n\t\tif (!connection.subscriptions.has(eventName)) {\n\t\t\tlogger().warn(\"connection does not have subscription\", { eventName });\n\t\t\treturn;\n\t\t}\n\n\t\t// Persist subscriptions & save immediately\n\t\t//\n\t\t// Don't update the connection itself if the connection is already being removed\n\t\tif (!fromRemoveConn) {\n\t\t\tconnection.subscriptions.delete(eventName);\n\n\t\t\tconst subIdx = connection.__persist.subscriptions.findIndex(\n\t\t\t\t(s) => s.eventName === eventName,\n\t\t\t);\n\t\t\tif (subIdx !== -1) {\n\t\t\t\tconnection.__persist.subscriptions.splice(subIdx, 1);\n\t\t\t} else {\n\t\t\t\tlogger().warn(\"subscription does not exist with name\", { eventName });\n\t\t\t}\n\n\t\t\tthis.saveState({ immediate: true });\n\t\t}\n\n\t\t// Update scriptions index\n\t\tconst subscribers = this.#subscriptionIndex.get(eventName);\n\t\tif (subscribers) {\n\t\t\tsubscribers.delete(connection);\n\t\t\tif (subscribers.size === 0) {\n\t\t\t\tthis.#subscriptionIndex.delete(eventName);\n\t\t\t}\n\t\t}\n\t}\n\n\t#assertReady(allowStoppingState: boolean = false) {\n\t\tif (!this.#ready) throw new errors.InternalError(\"Actor not ready\");\n\t\tif (!allowStoppingState && this.#sleepCalled)\n\t\t\tthrow new errors.InternalError(\"Actor is going to sleep\");\n\t\tif (!allowStoppingState && this.#stopCalled)\n\t\t\tthrow new errors.InternalError(\"Actor is stopping\");\n\t}\n\n\t/**\n\t * Check the liveness of all connections.\n\t * Sets up a recurring check based on the configured interval.\n\t */\n\t#checkConnectionsLiveness() {\n\t\tlogger().debug(\"checking connections liveness\");\n\n\t\tfor (const conn of this.#connections.values()) {\n\t\t\tconst liveness = conn[CONNECTION_CHECK_LIVENESS_SYMBOL]();\n\t\t\tif (liveness.status === \"connected\") {\n\t\t\t\tlogger().debug(\"connection is alive\", { connId: conn.id });\n\t\t\t} else {\n\t\t\t\tconst lastSeen = liveness.lastSeen;\n\t\t\t\tconst sinceLastSeen = Date.now() - lastSeen;\n\t\t\t\tif (sinceLastSeen < this.#config.options.connectionLivenessTimeout) {\n\t\t\t\t\tlogger().debug(\"connection might be alive, will check later\", {\n\t\t\t\t\t\tconnId: conn.id,\n\t\t\t\t\t\tlastSeen,\n\t\t\t\t\t\tsinceLastSeen,\n\t\t\t\t\t});\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\t// Connection is dead, remove it\n\t\t\t\tlogger().warn(\"connection is dead, removing\", {\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t\tlastSeen,\n\t\t\t\t});\n\n\t\t\t\t// TODO: Do we need to force disconnect the connection here?\n\n\t\t\t\tthis.__removeConn(conn);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Check if the actor is ready to handle requests.\n\t */\n\tisReady(): boolean {\n\t\treturn this.#ready;\n\t}\n\n\t/**\n\t * Execute an action call from a client.\n\t *\n\t * This method handles:\n\t * 1. Validating the action name\n\t * 2. Executing the action function\n\t * 3. Processing the result through onBeforeActionResponse (if configured)\n\t * 4. Handling timeouts and errors\n\t * 5. Saving state changes\n\t *\n\t * @param ctx The action context\n\t * @param actionName The name of the action being called\n\t * @param args The arguments passed to the action\n\t * @returns The result of the action call\n\t * @throws {ActionNotFound} If the action doesn't exist\n\t * @throws {ActionTimedOut} If the action times out\n\t * @internal\n\t */\n\tasync executeAction(\n\t\tctx: ActionContext<S, CP, CS, V, I, AD, DB>,\n\t\tactionName: string,\n\t\targs: unknown[],\n\t): Promise<unknown> {\n\t\tinvariant(this.#ready, \"executing action before ready\");\n\n\t\t// Prevent calling private or reserved methods\n\t\tif (!(actionName in this.#config.actions)) {\n\t\t\tlogger().warn(\"action does not exist\", { actionName });\n\t\t\tthrow new errors.ActionNotFound(actionName);\n\t\t}\n\n\t\t// Check if the method exists on this object\n\t\tconst actionFunction = this.#config.actions[actionName];\n\t\tif (typeof actionFunction !== \"function\") {\n\t\t\tlogger().warn(\"action is not a function\", {\n\t\t\t\tactionName: actionName,\n\t\t\t\ttype: typeof actionFunction,\n\t\t\t});\n\t\t\tthrow new errors.ActionNotFound(actionName);\n\t\t}\n\n\t\t// TODO: pass abortable to the action to decide when to abort\n\t\t// TODO: Manually call abortable for better error handling\n\t\t// Call the function on this object with those arguments\n\t\ttry {\n\t\t\t// Log when we start executing the action\n\t\t\tlogger().debug(\"executing action\", { actionName: actionName, args });\n\n\t\t\tconst outputOrPromise = actionFunction.call(undefined, ctx, ...args);\n\t\t\tlet output: unknown;\n\t\t\tif (outputOrPromise instanceof Promise) {\n\t\t\t\t// Log that we're waiting for an async action\n\t\t\t\tlogger().debug(\"awaiting async action\", { actionName: actionName });\n\n\t\t\t\toutput = await deadline(\n\t\t\t\t\toutputOrPromise,\n\t\t\t\t\tthis.#config.options.actionTimeout,\n\t\t\t\t);\n\n\t\t\t\t// Log that async action completed\n\t\t\t\tlogger().debug(\"async action completed\", { actionName: actionName });\n\t\t\t} else {\n\t\t\t\toutput = outputOrPromise;\n\t\t\t}\n\n\t\t\t// Process the output through onBeforeActionResponse if configured\n\t\t\tif (this.#config.onBeforeActionResponse) {\n\t\t\t\ttry {\n\t\t\t\t\tconst processedOutput = this.#config.onBeforeActionResponse(\n\t\t\t\t\t\tthis.actorContext,\n\t\t\t\t\t\tactionName,\n\t\t\t\t\t\targs,\n\t\t\t\t\t\toutput,\n\t\t\t\t\t);\n\t\t\t\t\tif (processedOutput instanceof Promise) {\n\t\t\t\t\t\tlogger().debug(\"awaiting onBeforeActionResponse\", {\n\t\t\t\t\t\t\tactionName: actionName,\n\t\t\t\t\t\t});\n\t\t\t\t\t\toutput = await processedOutput;\n\t\t\t\t\t\tlogger().debug(\"onBeforeActionResponse completed\", {\n\t\t\t\t\t\t\tactionName: actionName,\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\toutput = processedOutput;\n\t\t\t\t\t}\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger().error(\"error in `onBeforeActionResponse`\", {\n\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Log the output before returning\n\t\t\tlogger().debug(\"action completed\", {\n\t\t\t\tactionName: actionName,\n\t\t\t\toutputType: typeof output,\n\t\t\t\tisPromise: output instanceof Promise,\n\t\t\t});\n\n\t\t\t// This output *might* reference a part of the state (using onChange), but\n\t\t\t// that's OK since this value always gets serialized and sent over the\n\t\t\t// network.\n\t\t\treturn output;\n\t\t} catch (error) {\n\t\t\tif (error instanceof DeadlineError) {\n\t\t\t\tthrow new errors.ActionTimedOut();\n\t\t\t}\n\t\t\tlogger().error(\"action error\", {\n\t\t\t\tactionName: actionName,\n\t\t\t\terror: stringifyError(error),\n\t\t\t});\n\t\t\tthrow error;\n\t\t} finally {\n\t\t\tthis.#savePersistThrottled();\n\t\t}\n\t}\n\n\t/**\n\t * Returns a list of action methods available on this actor.\n\t */\n\tget actions(): string[] {\n\t\treturn Object.keys(this.#config.actions);\n\t}\n\n\t/**\n\t * Handles raw HTTP requests to the actor.\n\t */\n\tasync handleFetch(request: Request, opts: { auth: AD }): Promise<Response> {\n\t\tthis.#assertReady();\n\n\t\tif (!this.#config.onFetch) {\n\t\t\tthrow new errors.FetchHandlerNotDefined();\n\t\t}\n\n\t\t// Track active raw fetch while handler runs\n\t\tthis.#activeRawFetchCount++;\n\t\tthis.#resetSleepTimer();\n\n\t\ttry {\n\t\t\tconst response = await this.#config.onFetch(\n\t\t\t\tthis.actorContext,\n\t\t\t\trequest,\n\t\t\t\topts,\n\t\t\t);\n\t\t\tif (!response) {\n\t\t\t\tthrow new errors.InvalidFetchResponse();\n\t\t\t}\n\t\t\treturn response;\n\t\t} catch (error) {\n\t\t\tlogger().error(\"onFetch error\", {\n\t\t\t\terror: stringifyError(error),\n\t\t\t});\n\t\t\tthrow error;\n\t\t} finally {\n\t\t\t// Decrement active raw fetch counter and re-evaluate sleep\n\t\t\tthis.#activeRawFetchCount = Math.max(0, this.#activeRawFetchCount - 1);\n\t\t\tthis.#resetSleepTimer();\n\t\t\tthis.#savePersistThrottled();\n\t\t}\n\t}\n\n\t/**\n\t * Handles raw WebSocket connections to the actor.\n\t */\n\tasync handleWebSocket(\n\t\twebsocket: UniversalWebSocket,\n\t\topts: { request: Request; auth: AD },\n\t): Promise<void> {\n\t\tthis.#assertReady();\n\n\t\tif (!this.#config.onWebSocket) {\n\t\t\tthrow new errors.InternalError(\"onWebSocket handler not defined\");\n\t\t}\n\n\t\ttry {\n\t\t\t// Set up state tracking to detect changes during WebSocket handling\n\t\t\tconst stateBeforeHandler = this.#persistChanged;\n\n\t\t\t// Track active websocket until it fully closes\n\t\t\tthis.#activeRawWebSockets.add(websocket);\n\t\t\tthis.#resetSleepTimer();\n\n\t\t\t// Track socket close\n\t\t\tconst onSocketClosed = () => {\n\t\t\t\t// Remove listener and socket from tracking\n\t\t\t\ttry {\n\t\t\t\t\twebsocket.removeEventListener(\"close\", onSocketClosed);\n\t\t\t\t\twebsocket.removeEventListener(\"error\", onSocketClosed);\n\t\t\t\t} catch {}\n\t\t\t\tthis.#activeRawWebSockets.delete(websocket);\n\t\t\t\tthis.#resetSleepTimer();\n\t\t\t};\n\t\t\ttry {\n\t\t\t\twebsocket.addEventListener(\"close\", onSocketClosed);\n\t\t\t\twebsocket.addEventListener(\"error\", onSocketClosed);\n\t\t\t} catch {}\n\n\t\t\t// Handle WebSocket\n\t\t\tawait this.#config.onWebSocket(this.actorContext, websocket, opts);\n\n\t\t\t// If state changed during the handler, save it\n\t\t\tif (this.#persistChanged && !stateBeforeHandler) {\n\t\t\t\tawait this.saveState({ immediate: true });\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tlogger().error(\"onWebSocket error\", {\n\t\t\t\terror: stringifyError(error),\n\t\t\t});\n\t\t\tthrow error;\n\t\t} finally {\n\t\t\tthis.#savePersistThrottled();\n\t\t}\n\t}\n\n\t// MARK: Lifecycle hooks\n\n\t// MARK: Exposed methods\n\t/**\n\t * Gets the logger instance.\n\t */\n\tget log(): Logger {\n\t\treturn instanceLogger();\n\t}\n\n\t/**\n\t * Gets the name.\n\t */\n\tget name(): string {\n\t\treturn this.#name;\n\t}\n\n\t/**\n\t * Gets the key.\n\t */\n\tget key(): ActorKey {\n\t\treturn this.#key;\n\t}\n\n\t/**\n\t * Gets the region.\n\t */\n\tget region(): string {\n\t\treturn this.#region;\n\t}\n\n\t/**\n\t * Gets the scheduler.\n\t */\n\tget schedule(): Schedule {\n\t\treturn this.#schedule;\n\t}\n\n\t/**\n\t * Gets the map of connections.\n\t */\n\tget conns(): Map<ConnId, Conn<S, CP, CS, V, I, AD, DB>> {\n\t\treturn this.#connections;\n\t}\n\n\t/**\n\t * Gets the current state.\n\t *\n\t * Changing properties of this value will automatically be persisted.\n\t */\n\tget state(): S {\n\t\tthis.#validateStateEnabled();\n\t\treturn this.#persist.state;\n\t}\n\n\t/**\n\t * Gets the database.\n\t * @experimental\n\t * @throws {DatabaseNotEnabled} If the database is not enabled.\n\t */\n\tget db(): InferDatabaseClient<DB> {\n\t\tif (!this.#db) {\n\t\t\tthrow new errors.DatabaseNotEnabled();\n\t\t}\n\t\treturn this.#db;\n\t}\n\n\t/**\n\t * Sets the current state.\n\t *\n\t * This property will automatically be persisted.\n\t */\n\tset state(value: S) {\n\t\tthis.#validateStateEnabled();\n\t\tthis.#persist.state = value;\n\t}\n\n\tget vars(): V {\n\t\tthis.#validateVarsEnabled();\n\t\tinvariant(this.#vars !== undefined, \"vars not enabled\");\n\t\treturn this.#vars;\n\t}\n\n\t/**\n\t * Broadcasts an event to all connected clients.\n\t * @param name - The name of the event.\n\t * @param args - The arguments to send with the event.\n\t */\n\t_broadcast<Args extends Array<unknown>>(name: string, ...args: Args) {\n\t\tthis.#assertReady();\n\n\t\tthis.inspector.emitter.emit(\"eventFired\", {\n\t\t\ttype: \"broadcast\",\n\t\t\teventName: name,\n\t\t\targs,\n\t\t});\n\n\t\t// Send to all connected clients\n\t\tconst subscriptions = this.#subscriptionIndex.get(name);\n\t\tif (!subscriptions) return;\n\n\t\tconst toClientSerializer = new CachedSerializer<protocol.ToClient>(\n\t\t\t{\n\t\t\t\tbody: {\n\t\t\t\t\ttag: \"Event\",\n\t\t\t\t\tval: {\n\t\t\t\t\t\tname,\n\t\t\t\t\t\targs: bufferToArrayBuffer(cbor.encode(args)),\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\tTO_CLIENT_VERSIONED,\n\t\t);\n\n\t\t// Send message to clients\n\t\tfor (const connection of subscriptions) {\n\t\t\tconnection._sendMessage(toClientSerializer);\n\t\t}\n\t}\n\n\t/**\n\t * Prevents the actor from sleeping until promise is complete.\n\t *\n\t * This allows the actor runtime to ensure that a promise completes while\n\t * returning from an action request early.\n\t *\n\t * @param promise - The promise to run in the background.\n\t */\n\t_waitUntil(promise: Promise<void>) {\n\t\tthis.#assertReady();\n\n\t\t// TODO: Should we force save the state?\n\t\t// Add logging to promise and make it non-failable\n\t\tconst nonfailablePromise = promise\n\t\t\t.then(() => {\n\t\t\t\tlogger().debug(\"wait until promise complete\");\n\t\t\t})\n\t\t\t.catch((error) => {\n\t\t\t\tlogger().error(\"wait until promise failed\", {\n\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t});\n\t\t\t});\n\t\tthis.#backgroundPromises.push(nonfailablePromise);\n\t}\n\n\t/**\n\t * Forces the state to get saved.\n\t *\n\t * This is helpful if running a long task that may fail later or when\n\t * running a background job that updates the state.\n\t *\n\t * @param opts - Options for saving the state.\n\t */\n\tasync saveState(opts: SaveStateOptions) {\n\t\tthis.#assertReady(opts.allowStoppingState);\n\n\t\tif (this.#persistChanged) {\n\t\t\tif (opts.immediate) {\n\t\t\t\t// Save immediately\n\t\t\t\tawait this.#savePersistInner();\n\t\t\t} else {\n\t\t\t\t// Create callback\n\t\t\t\tif (!this.#onPersistSavedPromise) {\n\t\t\t\t\tthis.#onPersistSavedPromise = Promise.withResolvers();\n\t\t\t\t}\n\n\t\t\t\t// Save state throttled\n\t\t\t\tthis.#savePersistThrottled();\n\n\t\t\t\t// Wait for save\n\t\t\t\tawait this.#onPersistSavedPromise.promise;\n\t\t\t}\n\t\t}\n\t}\n\n\t// MARK: Sleep\n\t/**\n\t * Reset timer from the last actor interaction that allows it to be put to sleep.\n\t *\n\t * This should be called any time a sleep-related event happens:\n\t * - Connection opens (will clear timer)\n\t * - Connection closes (will schedule timer if there are no open connections)\n\t * - Alarm triggers (will reset timer)\n\t *\n\t * We don't need to call this on events like individual action calls, since there will always be a connection open for these.\n\t **/\n\t#resetSleepTimer() {\n\t\tif (this.#config.options.noSleep || !this.#sleepingSupported) return;\n\n\t\tconst canSleep = this.#canSleep();\n\n\t\tlogger().debug(\"resetting sleep timer\", {\n\t\t\tcanSleep,\n\t\t\texistingTimeout: !!this.#sleepTimeout,\n\t\t});\n\n\t\tif (this.#sleepTimeout) {\n\t\t\tclearTimeout(this.#sleepTimeout);\n\t\t\tthis.#sleepTimeout = undefined;\n\t\t}\n\n\t\t// Don't set a new timer if already sleeping\n\t\tif (this.#sleepCalled) return;\n\n\t\tif (canSleep) {\n\t\t\tthis.#sleepTimeout = setTimeout(() => {\n\t\t\t\tthis._sleep().catch((error) => {\n\t\t\t\t\tlogger().error(\"error during sleep\", {\n\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t});\n\t\t\t\t});\n\t\t\t}, this.#config.options.sleepTimeout);\n\t\t}\n\t}\n\n\t/** If this actor can be put in a sleeping state. */\n\t#canSleep(): boolean {\n\t\tif (!this.#ready) return false;\n\n\t\t// Check for active conns. This will also cover active actions, since all actions have a connection.\n\t\tfor (const conn of this.#connections.values()) {\n\t\t\tif (conn.status === \"connected\") return false;\n\t\t}\n\n\t\t// Do not sleep if raw fetches are in-flight\n\t\tif (this.#activeRawFetchCount > 0) return false;\n\n\t\t// Do not sleep if there are raw websockets open\n\t\tif (this.#activeRawWebSockets.size > 0) return false;\n\n\t\treturn true;\n\t}\n\n\t/** Puts an actor to sleep. This should just start the sleep sequence, most shutdown logic should be in _stop (which is called by the ActorDriver when sleeping). */\n\tasync _sleep() {\n\t\tconst sleep = this.#actorDriver.sleep?.bind(\n\t\t\tthis.#actorDriver,\n\t\t\tthis.#actorId,\n\t\t);\n\t\tinvariant(this.#sleepingSupported, \"sleeping not supported\");\n\t\tinvariant(sleep, \"no sleep on driver\");\n\n\t\tif (this.#sleepCalled) {\n\t\t\tlogger().warn(\"already sleeping actor\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#sleepCalled = true;\n\n\t\tlogger().info(\"actor sleeping\");\n\n\t\t// Schedule sleep to happen on the next tick. This allows for any action that calls _sleep to complete.\n\t\tsetImmediate(async () => {\n\t\t\t// The actor driver should call stop when ready to stop\n\t\t\t//\n\t\t\t// This will call _stop once Pegboard responds with the new status\n\t\t\tawait sleep();\n\t\t});\n\t}\n\n\t// MARK: Stop\n\tasync _stop() {\n\t\tif (this.#stopCalled) {\n\t\t\tlogger().warn(\"already stopping actor\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#stopCalled = true;\n\n\t\tlogger().info(\"actor stopping\");\n\n\t\t// Abort any listeners waiting for shutdown\n\t\ttry {\n\t\t\tthis.#abortController.abort();\n\t\t} catch {}\n\n\t\t// Call onStop lifecycle hook if defined\n\t\tif (this.#config.onStop) {\n\t\t\ttry {\n\t\t\t\tlogger().debug(\"calling onStop\");\n\t\t\t\tconst result = this.#config.onStop(this.actorContext);\n\t\t\t\tif (result instanceof Promise) {\n\t\t\t\t\tawait deadline(result, this.#config.options.onStopTimeout);\n\t\t\t\t}\n\t\t\t\tlogger().debug(\"onStop completed\");\n\t\t\t} catch (error) {\n\t\t\t\tif (error instanceof DeadlineError) {\n\t\t\t\t\tlogger().error(\"onStop timed out\");\n\t\t\t\t} else {\n\t\t\t\t\tlogger().error(\"error in onStop\", {\n\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Disconnect existing connections\n\t\tconst promises: Promise<unknown>[] = [];\n\t\tfor (const connection of this.#connections.values()) {\n\t\t\tpromises.push(connection.disconnect());\n\n\t\t\t// TODO: Figure out how to abort HTTP requests on shutdown\n\t\t}\n\n\t\t// Wait for any background tasks to finish, with timeout\n\t\tawait this.#waitBackgroundPromises(this.#config.options.waitUntilTimeout);\n\n\t\t// Clear timeouts\n\t\tif (this.#pendingSaveTimeout) clearTimeout(this.#pendingSaveTimeout);\n\t\tif (this.#sleepTimeout) clearTimeout(this.#sleepTimeout);\n\t\tif (this.#checkConnLivenessInterval)\n\t\t\tclearInterval(this.#checkConnLivenessInterval);\n\n\t\t// Write state\n\t\tawait this.saveState({ immediate: true, allowStoppingState: true });\n\n\t\t// Await all `close` event listeners with 1.5 second timeout\n\t\tconst res = Promise.race([\n\t\t\tPromise.all(promises).then(() => false),\n\t\t\tnew Promise<boolean>((res) =>\n\t\t\t\tglobalThis.setTimeout(() => res(true), 1500),\n\t\t\t),\n\t\t]);\n\n\t\tif (await res) {\n\t\t\tlogger().warn(\n\t\t\t\t\"timed out waiting for connections to close, shutting down anyway\",\n\t\t\t);\n\t\t}\n\n\t\t// Wait for queues to finish\n\t\tif (this.#persistWriteQueue.runningDrainLoop)\n\t\t\tawait this.#persistWriteQueue.runningDrainLoop;\n\t\tif (this.#alarmWriteQueue.runningDrainLoop)\n\t\t\tawait this.#alarmWriteQueue.runningDrainLoop;\n\t}\n\n\t/** Abort signal that fires when the actor is stopping. */\n\tget abortSignal(): AbortSignal {\n\t\treturn this.#abortController.signal;\n\t}\n\n\t/** Wait for background waitUntil promises with a timeout. */\n\tasync #waitBackgroundPromises(timeoutMs: number) {\n\t\tconst pending = this.#backgroundPromises;\n\t\tif (pending.length === 0) {\n\t\t\tlogger().debug(\"no background promises\");\n\t\t\treturn;\n\t\t}\n\n\t\t// Race promises with timeout to determine if pending promises settled fast enough\n\t\tconst timedOut = await Promise.race([\n\t\t\tPromise.allSettled(pending).then(() => false),\n\t\t\tnew Promise<true>((resolve) =>\n\t\t\t\tsetTimeout(() => resolve(true), timeoutMs),\n\t\t\t),\n\t\t]);\n\n\t\tif (timedOut) {\n\t\t\tlogger().error(\n\t\t\t\t\"timed out waiting for background tasks, background promises may have leaked\",\n\t\t\t\t{\n\t\t\t\t\tcount: pending.length,\n\t\t\t\t\ttimeoutMs,\n\t\t\t\t},\n\t\t\t);\n\t\t} else {\n\t\t\tlogger().debug(\"background promises finished\");\n\t\t}\n\t}\n\n\t// MARK: BARE Conversion Helpers\n\t#convertToBarePersisted(\n\t\tpersist: PersistedActor<S, CP, CS, I>,\n\t): bareSchema.PersistedActor {\n\t\treturn {\n\t\t\tinput:\n\t\t\t\tpersist.input !== undefined\n\t\t\t\t\t? bufferToArrayBuffer(cbor.encode(persist.input))\n\t\t\t\t\t: null,\n\t\t\thasInitialized: persist.hasInitiated,\n\t\t\tstate: bufferToArrayBuffer(cbor.encode(persist.state)),\n\t\t\tconnections: persist.connections.map((conn) => ({\n\t\t\t\tid: conn.connId,\n\t\t\t\ttoken: conn.token,\n\t\t\t\tdriver: conn.connDriver as string,\n\t\t\t\tdriverState: bufferToArrayBuffer(\n\t\t\t\t\tcbor.encode(conn.connDriverState || {}),\n\t\t\t\t),\n\t\t\t\tparameters: bufferToArrayBuffer(cbor.encode(conn.params || {})),\n\t\t\t\tstate: bufferToArrayBuffer(cbor.encode(conn.state || {})),\n\t\t\t\tauth:\n\t\t\t\t\tconn.authData !== undefined\n\t\t\t\t\t\t? bufferToArrayBuffer(cbor.encode(conn.authData))\n\t\t\t\t\t\t: null,\n\t\t\t\tsubscriptions: conn.subscriptions.map((sub) => ({\n\t\t\t\t\teventName: sub.eventName,\n\t\t\t\t})),\n\t\t\t\tlastSeen: BigInt(conn.lastSeen),\n\t\t\t})),\n\t\t\tscheduledEvents: persist.scheduledEvents.map((event) => ({\n\t\t\t\teventId: event.eventId,\n\t\t\t\ttimestamp: BigInt(event.timestamp),\n\t\t\t\tkind: {\n\t\t\t\t\ttag: \"GenericPersistedScheduleEvent\" as const,\n\t\t\t\t\tval: {\n\t\t\t\t\t\taction: event.kind.generic.actionName,\n\t\t\t\t\t\targs: event.kind.generic.args ?? null,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t})),\n\t\t};\n\t}\n\n\t#convertFromBarePersisted(\n\t\tbareData: bareSchema.PersistedActor,\n\t): PersistedActor<S, CP, CS, I> {\n\t\treturn {\n\t\t\tinput: bareData.input\n\t\t\t\t? cbor.decode(new Uint8Array(bareData.input))\n\t\t\t\t: undefined,\n\t\t\thasInitiated: bareData.hasInitialized,\n\t\t\tstate: cbor.decode(new Uint8Array(bareData.state)),\n\t\t\tconnections: bareData.connections.map((conn) => ({\n\t\t\t\tconnId: conn.id,\n\t\t\t\ttoken: conn.token,\n\t\t\t\tconnDriver: conn.driver as ConnectionDriver,\n\t\t\t\tconnDriverState: cbor.decode(new Uint8Array(conn.driverState)),\n\t\t\t\tparams: cbor.decode(new Uint8Array(conn.parameters)),\n\t\t\t\tstate: cbor.decode(new Uint8Array(conn.state)),\n\t\t\t\tauthData: conn.auth\n\t\t\t\t\t? cbor.decode(new Uint8Array(conn.auth))\n\t\t\t\t\t: undefined,\n\t\t\t\tsubscriptions: conn.subscriptions.map((sub) => ({\n\t\t\t\t\teventName: sub.eventName,\n\t\t\t\t})),\n\t\t\t\tlastSeen: Number(conn.lastSeen),\n\t\t\t})),\n\t\t\tscheduledEvents: bareData.scheduledEvents.map((event) => ({\n\t\t\t\teventId: event.eventId,\n\t\t\t\ttimestamp: Number(event.timestamp),\n\t\t\t\tkind: {\n\t\t\t\t\tgeneric: {\n\t\t\t\t\t\tactionName: event.kind.val.action,\n\t\t\t\t\t\targs: event.kind.val.args,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t})),\n\t\t};\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/actor.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/actor.ts\";import { sValidator } from \"@hono/standard-validator\";\nimport jsonPatch from \"@rivetkit/fast-json-patch\";\nimport { Hono } from \"hono\";\nimport { streamSSE } from \"hono/streaming\";\nimport { createNanoEvents, type Unsubscribe } from \"nanoevents\";\nimport z from \"zod/v4\";\nimport type {\n\tAnyDatabaseProvider,\n\tInferDatabaseClient,\n} from \"@/actor/database\";\nimport {\n\tColumnsSchema,\n\ttype Connection,\n\tForeignKeysSchema,\n\tPatchSchema,\n\ttype RealtimeEvent,\n\ttype RecordedRealtimeEvent,\n\tTablesSchema,\n} from \"./protocol/common\";\n\nexport type ActorInspectorRouterEnv = {\n\tVariables: {\n\t\tinspector: ActorInspector;\n\t};\n};\n\n/**\n * Create a router for the Actor Inspector.\n * @internal\n */\nexport function createActorInspectorRouter() {\n\treturn new Hono<ActorInspectorRouterEnv>()\n\t\t.get(\"/ping\", (c) => {\n\t\t\treturn c.json({ message: \"pong\" }, 200);\n\t\t})\n\t\t.get(\"/state\", async (c) => {\n\t\t\tif (await c.var.inspector.accessors.isStateEnabled()) {\n\t\t\t\treturn c.json(\n\t\t\t\t\t{\n\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\tstate: await c.var.inspector.accessors.getState(),\n\t\t\t\t\t},\n\t\t\t\t\t200,\n\t\t\t\t);\n\t\t\t}\n\t\t\treturn c.json({ enabled: false, state: null }, 200);\n\t\t})\n\t\t.patch(\n\t\t\t\"/state\",\n\t\t\tsValidator(\n\t\t\t\t\"json\",\n\t\t\t\tz.object({ patch: PatchSchema }).or(z.object({ replace: z.any() })),\n\t\t\t),\n\t\t\tasync (c) => {\n\t\t\t\tif (!(await c.var.inspector.accessors.isStateEnabled())) {\n\t\t\t\t\treturn c.json({ enabled: false }, 200);\n\t\t\t\t}\n\n\t\t\t\tconst body = c.req.valid(\"json\");\n\t\t\t\tif (\"replace\" in body) {\n\t\t\t\t\tawait c.var.inspector.accessors.setState(body.replace);\n\t\t\t\t\treturn c.json(\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tenabled: true,\n\t\t\t\t\t\t\tstate: await c.var.inspector.accessors.getState(),\n\t\t\t\t\t\t},\n\t\t\t\t\t\t200,\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t\tconst state = await c.var.inspector.accessors.getState();\n\n\t\t\t\tconst { newDocument: newState } = jsonPatch.applyPatch(\n\t\t\t\t\tstate,\n\t\t\t\t\tbody.patch,\n\t\t\t\t);\n\t\t\t\tawait c.var.inspector.accessors.setState(newState);\n\n\t\t\t\treturn c.json(\n\t\t\t\t\t{ enabled: true, state: await c.var.inspector.accessors.getState() },\n\t\t\t\t\t200,\n\t\t\t\t);\n\t\t\t},\n\t\t)\n\t\t.get(\"/state/stream\", async (c) => {\n\t\t\tif (!(await c.var.inspector.accessors.isStateEnabled())) {\n\t\t\t\treturn c.json({ enabled: false }, 200);\n\t\t\t}\n\n\t\t\tlet id = 0;\n\t\t\tlet unsub: Unsubscribe;\n\t\t\treturn streamSSE(\n\t\t\t\tc,\n\t\t\t\tasync (stream) => {\n\t\t\t\t\tunsub = c.var.inspector.emitter.on(\"stateUpdated\", async (state) => {\n\t\t\t\t\t\tstream.writeSSE({\n\t\t\t\t\t\t\tdata: JSON.stringify(state) || \"\",\n\t\t\t\t\t\t\tevent: \"state-update\",\n\t\t\t\t\t\t\tid: String(id++),\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\n\t\t\t\t\tconst { promise } = Promise.withResolvers<void>();\n\n\t\t\t\t\treturn promise;\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tunsub?.();\n\t\t\t\t},\n\t\t\t);\n\t\t})\n\t\t.get(\"/connections\", async (c) => {\n\t\t\tconst connections = await c.var.inspector.accessors.getConnections();\n\t\t\treturn c.json({ connections }, 200);\n\t\t})\n\t\t.get(\"/connections/stream\", async (c) => {\n\t\t\tlet id = 0;\n\t\t\tlet unsub: Unsubscribe;\n\t\t\treturn streamSSE(\n\t\t\t\tc,\n\t\t\t\tasync (stream) => {\n\t\t\t\t\tunsub = c.var.inspector.emitter.on(\"connectionUpdated\", async () => {\n\t\t\t\t\t\tstream.writeSSE({\n\t\t\t\t\t\t\tdata: JSON.stringify(\n\t\t\t\t\t\t\t\tawait c.var.inspector.accessors.getConnections(),\n\t\t\t\t\t\t\t),\n\t\t\t\t\t\t\tevent: \"connection-update\",\n\t\t\t\t\t\t\tid: String(id++),\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\n\t\t\t\t\tconst { promise } = Promise.withResolvers<void>();\n\n\t\t\t\t\treturn promise;\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tunsub?.();\n\t\t\t\t},\n\t\t\t);\n\t\t})\n\t\t.get(\"/events\", async (c) => {\n\t\t\tconst events = c.var.inspector.lastRealtimeEvents;\n\t\t\treturn c.json({ events }, 200);\n\t\t})\n\t\t.post(\"/events/clear\", async (c) => {\n\t\t\tc.var.inspector.lastRealtimeEvents.length = 0; // Clear the events\n\t\t\treturn c.json({ message: \"Events cleared\" }, 200);\n\t\t})\n\t\t.get(\"/events/stream\", async (c) => {\n\t\t\tlet id = 0;\n\t\t\tlet unsub: Unsubscribe;\n\t\t\treturn streamSSE(\n\t\t\t\tc,\n\t\t\t\tasync (stream) => {\n\t\t\t\t\tunsub = c.var.inspector.emitter.on(\"eventFired\", () => {\n\t\t\t\t\t\tstream.writeSSE({\n\t\t\t\t\t\t\tdata: JSON.stringify(c.var.inspector.lastRealtimeEvents),\n\t\t\t\t\t\t\tevent: \"realtime-event\",\n\t\t\t\t\t\t\tid: String(id++),\n\t\t\t\t\t\t});\n\t\t\t\t\t});\n\n\t\t\t\t\tconst { promise } = Promise.withResolvers<void>();\n\n\t\t\t\t\treturn promise;\n\t\t\t\t},\n\t\t\t\tasync () => {\n\t\t\t\t\tunsub?.();\n\t\t\t\t},\n\t\t\t);\n\t\t})\n\t\t.get(\"/rpcs\", async (c) => {\n\t\t\tconst rpcs = await c.var.inspector.accessors.getRpcs();\n\t\t\treturn c.json({ rpcs }, 200);\n\t\t})\n\t\t.get(\"/db\", async (c) => {\n\t\t\tif (!(await c.var.inspector.accessors.isDbEnabled())) {\n\t\t\t\treturn c.json({ enabled: false, db: null }, 200);\n\t\t\t}\n\n\t\t\t// Access the SQLite database\n\t\t\tconst db = await c.var.inspector.accessors.getDb();\n\n\t\t\t// Get list of tables\n\t\t\tconst rows = await db.execute(`PRAGMA table_list`);\n\t\t\tconst tables = TablesSchema.parse(rows).filter(\n\t\t\t\t(table) => table.schema !== \"temp\" && !table.name.startsWith(\"sqlite_\"),\n\t\t\t);\n\t\t\t// Get columns for each table\n\t\t\tconst tablesInfo = await Promise.all(\n\t\t\t\ttables.map((table) => db.execute(`PRAGMA table_info(${table.name})`)),\n\t\t\t);\n\t\t\tconst columns = tablesInfo.map((def) => ColumnsSchema.parse(def));\n\n\t\t\t// Get foreign keys for each table\n\t\t\tconst foreignKeysList = await Promise.all(\n\t\t\t\ttables.map((table) =>\n\t\t\t\t\tdb.execute(`PRAGMA foreign_key_list(${table.name})`),\n\t\t\t\t),\n\t\t\t);\n\t\t\tconst foreignKeys = foreignKeysList.map((def) =>\n\t\t\t\tForeignKeysSchema.parse(def),\n\t\t\t);\n\n\t\t\t// Get record counts for each table\n\t\t\tconst countInfo = await Promise.all(\n\t\t\t\ttables.map((table) =>\n\t\t\t\t\tdb.execute(`SELECT COUNT(*) as count FROM ${table.name}`),\n\t\t\t\t),\n\t\t\t);\n\t\t\tconst counts = countInfo.map((def) => {\n\t\t\t\treturn def[0].count || 0;\n\t\t\t});\n\n\t\t\treturn c.json(\n\t\t\t\t{\n\t\t\t\t\tenabled: true,\n\t\t\t\t\tdb: tablesInfo.map((_, index) => {\n\t\t\t\t\t\treturn {\n\t\t\t\t\t\t\ttable: tables[index],\n\t\t\t\t\t\t\tcolumns: columns[index],\n\t\t\t\t\t\t\tforeignKeys: foreignKeys[index],\n\t\t\t\t\t\t\trecords: counts[index],\n\t\t\t\t\t\t};\n\t\t\t\t\t}),\n\t\t\t\t},\n\t\t\t\t200,\n\t\t\t);\n\t\t})\n\t\t.post(\n\t\t\t\"/db\",\n\t\t\tsValidator(\n\t\t\t\t\"json\",\n\t\t\t\tz.object({ query: z.string(), params: z.array(z.any()).optional() }),\n\t\t\t),\n\t\t\tasync (c) => {\n\t\t\t\tif (!(await c.var.inspector.accessors.isDbEnabled())) {\n\t\t\t\t\treturn c.json({ enabled: false }, 200);\n\t\t\t\t}\n\t\t\t\tconst db = await c.var.inspector.accessors.getDb();\n\n\t\t\t\ttry {\n\t\t\t\t\tconst result = (await db.execute(\n\t\t\t\t\t\tc.req.valid(\"json\").query,\n\t\t\t\t\t\t...(c.req.valid(\"json\").params || []),\n\t\t\t\t\t)) as unknown;\n\t\t\t\t\treturn c.json({ result }, 200);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tc;\n\t\t\t\t\treturn c.json({ error: (error as Error).message }, 500);\n\t\t\t\t}\n\t\t\t},\n\t\t);\n}\n\ninterface ActorInspectorAccessors {\n\tisStateEnabled: () => Promise<boolean>;\n\tgetState: () => Promise<unknown>;\n\tsetState: (state: unknown) => Promise<void>;\n\tisDbEnabled: () => Promise<boolean>;\n\tgetDb: () => Promise<InferDatabaseClient<AnyDatabaseProvider>>;\n\tgetRpcs: () => Promise<string[]>;\n\tgetConnections: () => Promise<Connection[]>;\n}\n\ninterface ActorInspectorEmitterEvents {\n\tstateUpdated: (state: unknown) => void;\n\tconnectionUpdated: () => void;\n\teventFired: (event: RealtimeEvent) => void;\n}\n\n/**\n * Provides a unified interface for inspecting actor external and internal state.\n */\nexport class ActorInspector {\n\tpublic readonly accessors: ActorInspectorAccessors;\n\tpublic readonly emitter = createNanoEvents<ActorInspectorEmitterEvents>();\n\n\t#lastRealtimeEvents: RecordedRealtimeEvent[] = [];\n\n\tget lastRealtimeEvents() {\n\t\treturn this.#lastRealtimeEvents;\n\t}\n\n\tconstructor(accessors: () => ActorInspectorAccessors) {\n\t\tthis.accessors = accessors();\n\t\tthis.emitter.on(\"eventFired\", (event) => {\n\t\t\tthis.#lastRealtimeEvents.push({\n\t\t\t\tid: crypto.randomUUID(),\n\t\t\t\ttimestamp: Date.now(),\n\t\t\t\t...event,\n\t\t\t});\n\t\t\t// keep the last 100 events\n\t\t\tif (this.#lastRealtimeEvents.length > 100) {\n\t\t\t\tthis.#lastRealtimeEvents = this.#lastRealtimeEvents.slice(-100);\n\t\t\t}\n\t\t});\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/protocol/common.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/protocol/common.ts\";import z from \"zod/v4\";\nimport { ActorKeySchema, MAX_ACTOR_KEY_SIZE } from \"@/manager/protocol/query\";\n\nexport const ActorId = z.string().brand(\"ActorId\");\nexport type ActorId = z.infer<typeof ActorId>;\n\nexport enum ActorFeature {\n\tLogs = \"logs\",\n\tConfig = \"config\",\n\tConnections = \"connections\",\n\tState = \"state\",\n\tConsole = \"console\",\n\tRuntime = \"runtime\",\n\tMetrics = \"metrics\",\n\tEventsMonitoring = \"events-monitoring\",\n\tDatabase = \"database\",\n}\n\nexport const ActorLogEntry = z.object({\n\tlevel: z.string(),\n\tmessage: z.string(),\n\ttimestamp: z.string(),\n\tmetadata: z.record(z.string(), z.any()).optional(),\n});\n\nexport const ActorSchema = z.object({\n\tid: ActorId,\n\tname: z.string(),\n\tkey: z.array(z.string()),\n\ttags: z.record(z.string(), z.string()).optional(),\n\tregion: z.string().optional(),\n\tcreatedAt: z.string().optional(),\n\tstartedAt: z.string().optional(),\n\tdestroyedAt: z.string().optional(),\n\tfeatures: z.array(z.enum(ActorFeature)).optional(),\n});\n\nexport type Actor = z.infer<typeof ActorSchema>;\nexport type ActorLogEntry = z.infer<typeof ActorLogEntry>;\n\n// MARK: State\n\nexport const OperationSchema = z.discriminatedUnion(\"op\", [\n\tz.object({\n\t\top: z.literal(\"remove\"),\n\t\tpath: z.string(),\n\t}),\n\tz.object({\n\t\top: z.literal(\"add\"),\n\t\tpath: z.string(),\n\t\tvalue: z.unknown(),\n\t}),\n\tz.object({\n\t\top: z.literal(\"replace\"),\n\t\tpath: z.string(),\n\t\tvalue: z.unknown(),\n\t}),\n\tz.object({\n\t\top: z.literal(\"move\"),\n\t\tpath: z.string(),\n\t\tfrom: z.string(),\n\t}),\n\tz.object({\n\t\top: z.literal(\"copy\"),\n\t\tpath: z.string(),\n\t\tfrom: z.string(),\n\t}),\n\tz.object({\n\t\top: z.literal(\"test\"),\n\t\tpath: z.string(),\n\t\tvalue: z.unknown(),\n\t}),\n]);\nexport type Operation = z.infer<typeof OperationSchema>;\n\nexport const PatchSchema = z.array(OperationSchema);\nexport type Patch = z.infer<typeof PatchSchema>;\n\n// MARK: Connections\n\nexport const ConnectionSchema = z.object({\n\tparams: z.record(z.string(), z.any()).optional(),\n\tid: z.string(),\n\tstateEnabled: z.boolean().optional(),\n\tstate: z.any().optional(),\n\tauth: z.record(z.string(), z.any()).optional(),\n});\nexport type Connection = z.infer<typeof ConnectionSchema>;\n\n// MARK: Realtime Events\n\nexport const RealtimeEventSchema = z.discriminatedUnion(\"type\", [\n\tz.object({\n\t\ttype: z.literal(\"action\"),\n\t\tname: z.string(),\n\t\targs: z.array(z.any()),\n\t\tconnId: z.string(),\n\t}),\n\tz.object({\n\t\ttype: z.literal(\"broadcast\"),\n\t\teventName: z.string(),\n\t\targs: z.array(z.any()),\n\t}),\n\tz.object({\n\t\ttype: z.literal(\"subscribe\"),\n\t\teventName: z.string(),\n\t\tconnId: z.string(),\n\t}),\n\tz.object({\n\t\ttype: z.literal(\"unsubscribe\"),\n\t\teventName: z.string(),\n\t\tconnId: z.string(),\n\t}),\n\tz.object({\n\t\ttype: z.literal(\"event\"),\n\t\teventName: z.string(),\n\t\targs: z.array(z.any()),\n\t\tconnId: z.string(),\n\t}),\n]);\nexport type RealtimeEvent = z.infer<typeof RealtimeEventSchema>;\nexport const RecordedRealtimeEventSchema = RealtimeEventSchema.and(\n\tz.object({\n\t\tid: z.string(),\n\t\ttimestamp: z.number(),\n\t}),\n);\nexport type RecordedRealtimeEvent = z.infer<typeof RecordedRealtimeEventSchema>;\n\n// MARK: Database\n\nexport const DatabaseQuerySchema = z.object({\n\tsql: z.string(),\n\targs: z.array(z.string().or(z.number())),\n});\nexport type DatabaseQuery = z.infer<typeof DatabaseQuerySchema>;\n\nexport const TableSchema = z.object({\n\tschema: z.string(),\n\tname: z.string(),\n\ttype: z.enum([\"table\", \"view\"]),\n});\nexport type Table = z.infer<typeof TableSchema>;\n\nexport const TablesSchema = z.array(TableSchema);\nexport type Tables = z.infer<typeof TablesSchema>;\n\nexport const ColumnSchema = z.object({\n\tcid: z.number(),\n\tname: z.string(),\n\ttype: z\n\t\t.string()\n\t\t.toLowerCase()\n\t\t.transform((val) => {\n\t\t\treturn z\n\t\t\t\t.enum([\"integer\", \"text\", \"real\", \"blob\", \"numeric\", \"serial\"])\n\t\t\t\t.parse(val);\n\t\t}),\n\tnotnull: z.coerce.boolean(),\n\tdflt_value: z.string().nullable(),\n\tpk: z.coerce.boolean().nullable(),\n});\nexport type Column = z.infer<typeof ColumnSchema>;\n\nexport const ColumnsSchema = z.array(ColumnSchema);\nexport type Columns = z.infer<typeof ColumnsSchema>;\n\nexport const ForeignKeySchema = z.object({\n\tid: z.number(),\n\ttable: z.string(),\n\tfrom: z.string(),\n\tto: z.string(),\n});\nexport type ForeignKey = z.infer<typeof ForeignKeySchema>;\n\nexport const ForeignKeysSchema = z.array(ForeignKeySchema);\nexport type ForeignKeys = z.infer<typeof ForeignKeysSchema>;\n\n// MARK: Builds\n\nexport const BuildSchema = z.object({\n\tname: z.string(),\n\tcreatedAt: z.string().optional(),\n\ttags: z.record(z.string(), z.string()).optional(),\n});\nexport type Build = z.infer<typeof BuildSchema>;\nexport const BuildsSchema = z.array(BuildSchema);\nexport type Builds = z.infer<typeof BuildsSchema>;\n\nexport const CreateActorSchema = z.object({\n\tname: z.string(),\n\t// FIXME: Replace with ActorKeySchema when ready\n\tkey: z.array(z.string().max(MAX_ACTOR_KEY_SIZE)),\n\tinput: z.any(),\n});\nexport type CreateActor = z.infer<typeof CreateActorSchema>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/protocol/query.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/manager/protocol/query.ts\";import { z } from \"zod\";\nimport { EncodingSchema } from \"@/actor/protocol/serde\";\nimport {\n\tHEADER_ACTOR_ID,\n\tHEADER_ACTOR_QUERY,\n\tHEADER_CONN_ID,\n\tHEADER_CONN_PARAMS,\n\tHEADER_CONN_TOKEN,\n\tHEADER_ENCODING,\n} from \"@/actor/router-endpoints\";\n\n// Maximum size of a key component in bytes\n// Set to 128 bytes to allow for separators and escape characters in the full key\n// Cloudflare's maximum key size is 512 bytes, so we need to be significantly smaller\nexport const MAX_ACTOR_KEY_SIZE = 128;\n\nexport const ActorKeySchema = z.array(z.string().max(MAX_ACTOR_KEY_SIZE));\n\nexport type ActorKey = z.infer<typeof ActorKeySchema>;\n\nexport const CreateRequestSchema = z.object({\n\tname: z.string(),\n\tkey: ActorKeySchema,\n\tinput: z.unknown().optional(),\n\tregion: z.string().optional(),\n});\n\nexport const GetForKeyRequestSchema = z.object({\n\tname: z.string(),\n\tkey: ActorKeySchema,\n});\n\nexport const GetOrCreateRequestSchema = z.object({\n\tname: z.string(),\n\tkey: ActorKeySchema,\n\tinput: z.unknown().optional(),\n\tregion: z.string().optional(),\n});\n\nexport const ActorQuerySchema = z.union([\n\tz.object({\n\t\tgetForId: z.object({\n\t\t\tname: z.string(),\n\t\t\tactorId: z.string(),\n\t\t}),\n\t}),\n\tz.object({\n\t\tgetForKey: GetForKeyRequestSchema,\n\t}),\n\tz.object({\n\t\tgetOrCreateForKey: GetOrCreateRequestSchema,\n\t}),\n\tz.object({\n\t\tcreate: CreateRequestSchema,\n\t}),\n]);\n\nexport const ConnectRequestSchema = z.object({\n\tquery: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),\n\tencoding: EncodingSchema.describe(HEADER_ENCODING),\n\tconnParams: z.string().optional().describe(HEADER_CONN_PARAMS),\n});\n\nexport const ConnectWebSocketRequestSchema = z.object({\n\tquery: ActorQuerySchema.describe(\"query\"),\n\tencoding: EncodingSchema.describe(\"encoding\"),\n\tconnParams: z.unknown().optional().describe(\"conn_params\"),\n});\n\nexport const ConnMessageRequestSchema = z.object({\n\tactorId: z.string().describe(HEADER_ACTOR_ID),\n\tconnId: z.string().describe(HEADER_CONN_ID),\n\tencoding: EncodingSchema.describe(HEADER_ENCODING),\n\tconnToken: z.string().describe(HEADER_CONN_TOKEN),\n});\n\nexport const ResolveRequestSchema = z.object({\n\tquery: ActorQuerySchema.describe(HEADER_ACTOR_QUERY),\n\tconnParams: z.string().optional().describe(HEADER_CONN_PARAMS),\n});\n\nexport type ActorQuery = z.infer<typeof ActorQuerySchema>;\nexport type GetForKeyRequest = z.infer<typeof GetForKeyRequestSchema>;\nexport type GetOrCreateRequest = z.infer<typeof GetOrCreateRequestSchema>;\nexport type ConnectQuery = z.infer<typeof ConnectRequestSchema>;\n/**\n * Interface representing a request to create a actor.\n */\nexport type CreateRequest = z.infer<typeof CreateRequestSchema>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/router-endpoints.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/router-endpoints.ts\";import * as cbor from \"cbor-x\";\nimport type { Context as HonoContext, HonoRequest } from \"hono\";\nimport { type SSEStreamingApi, streamSSE } from \"hono/streaming\";\nimport type { WSContext } from \"hono/ws\";\nimport { ActionContext } from \"@/actor/action\";\nimport type { AnyConn } from \"@/actor/connection\";\nimport {\n\tCONNECTION_DRIVER_HTTP,\n\tCONNECTION_DRIVER_SSE,\n\tCONNECTION_DRIVER_WEBSOCKET,\n\tgenerateConnId,\n\tgenerateConnToken,\n} from \"@/actor/connection\";\nimport * as errors from \"@/actor/errors\";\nimport type { AnyActorInstance } from \"@/actor/instance\";\nimport type { InputData } from \"@/actor/protocol/serde\";\nimport { type Encoding, EncodingSchema } from \"@/actor/protocol/serde\";\nimport type { UpgradeWebSocketArgs } from \"@/common/inline-websocket-adapter2\";\nimport { deconstructError, stringifyError } from \"@/common/utils\";\nimport type { UniversalWebSocket } from \"@/common/websocket-interface\";\nimport { HonoWebSocketAdapter } from \"@/manager/hono-websocket-adapter\";\nimport type { RunConfig } from \"@/registry/run-config\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport {\n\tHTTP_ACTION_REQUEST_VERSIONED,\n\tHTTP_ACTION_RESPONSE_VERSIONED,\n\tTO_SERVER_VERSIONED,\n} from \"@/schemas/client-protocol/versioned\";\nimport {\n\tcontentTypeForEncoding,\n\tdeserializeWithEncoding,\n\tserializeWithEncoding,\n} from \"@/serde\";\nimport { bufferToArrayBuffer } from \"@/utils\";\nimport type { ActorDriver } from \"./driver\";\nimport type {\n\tGenericHttpDriverState,\n\tGenericSseDriverState,\n\tGenericWebSocketDriverState,\n} from \"./generic-conn-driver\";\nimport { logger } from \"./log\";\nimport { parseMessage } from \"./protocol/old\";\n\nexport interface ConnectWebSocketOpts {\n\treq?: HonoRequest;\n\tencoding: Encoding;\n\tactorId: string;\n\tparams: unknown;\n\tauthData: unknown;\n}\n\nexport interface ConnectWebSocketOutput {\n\tonOpen: (ws: WSContext) => void;\n\tonMessage: (message: protocol.ToServer) => void;\n\tonClose: () => void;\n}\n\nexport interface ConnectSseOpts {\n\treq?: HonoRequest;\n\tencoding: Encoding;\n\tparams: unknown;\n\tactorId: string;\n\tauthData: unknown;\n}\n\nexport interface ConnectSseOutput {\n\tonOpen: (stream: SSEStreamingApi) => void;\n\tonClose: () => Promise<void>;\n}\n\nexport interface ActionOpts {\n\treq?: HonoRequest;\n\tparams: unknown;\n\tactionName: string;\n\tactionArgs: unknown[];\n\tactorId: string;\n\tauthData: unknown;\n}\n\nexport interface ActionOutput {\n\toutput: unknown;\n}\n\nexport interface ConnsMessageOpts {\n\treq?: HonoRequest;\n\tconnId: string;\n\tconnToken: string;\n\tmessage: protocol.ToServer;\n\tactorId: string;\n}\n\nexport interface FetchOpts {\n\trequest: Request;\n\tactorId: string;\n\tauthData: unknown;\n}\n\nexport interface WebSocketOpts {\n\trequest: Request;\n\twebsocket: UniversalWebSocket;\n\tactorId: string;\n\tauthData: unknown;\n}\n\n/**\n * Creates a WebSocket connection handler\n */\nexport async function handleWebSocketConnect(\n\treq: Request | undefined,\n\trunConfig: RunConfig,\n\tactorDriver: ActorDriver,\n\tactorId: string,\n\tencoding: Encoding,\n\tparameters: unknown,\n\tauthData: unknown,\n): Promise<UpgradeWebSocketArgs> {\n\tconst exposeInternalError = req ? getRequestExposeInternalError(req) : false;\n\n\t// Setup promise for the init handlers since all other behavior depends on this\n\tconst {\n\t\tpromise: handlersPromise,\n\t\tresolve: handlersResolve,\n\t\treject: handlersReject,\n\t} = Promise.withResolvers<{\n\t\tconn: AnyConn;\n\t\tactor: AnyActorInstance;\n\t\tconnId: string;\n\t}>();\n\n\t// Pre-load the actor to catch errors early\n\tlet actor: AnyActorInstance;\n\ttry {\n\t\tactor = await actorDriver.loadActor(actorId);\n\t} catch (error) {\n\t\t// Return handler that immediately closes with error\n\t\treturn {\n\t\t\tonOpen: (_evt: any, ws: WSContext) => {\n\t\t\t\tconst { code } = deconstructError(\n\t\t\t\t\terror,\n\t\t\t\t\tlogger(),\n\t\t\t\t\t{\n\t\t\t\t\t\twsEvent: \"open\",\n\t\t\t\t\t},\n\t\t\t\t\texposeInternalError,\n\t\t\t\t);\n\t\t\t\tws.close(1011, code);\n\t\t\t},\n\t\t\tonMessage: (_evt: { data: any }, ws: WSContext) => {\n\t\t\t\tws.close(1011, \"Actor not loaded\");\n\t\t\t},\n\t\t\tonClose: (_event: any, _ws: WSContext) => {},\n\t\t\tonError: (_error: unknown) => {},\n\t\t};\n\t}\n\n\treturn {\n\t\tonOpen: (_evt: any, ws: WSContext) => {\n\t\t\tlogger().debug(\"websocket open\");\n\n\t\t\t// Run async operations in background\n\t\t\t(async () => {\n\t\t\t\ttry {\n\t\t\t\t\tconst connId = generateConnId();\n\t\t\t\t\tconst connToken = generateConnToken();\n\t\t\t\t\tconst connState = await actor.prepareConn(parameters, req);\n\n\t\t\t\t\t// Save socket\n\t\t\t\t\tconst connGlobalState =\n\t\t\t\t\t\tactorDriver.getGenericConnGlobalState(actorId);\n\t\t\t\t\tconnGlobalState.websockets.set(connId, ws);\n\t\t\t\t\tlogger().debug(\"registered websocket for conn\", {\n\t\t\t\t\t\tactorId,\n\t\t\t\t\t\ttotalCount: connGlobalState.websockets.size,\n\t\t\t\t\t});\n\n\t\t\t\t\t// Create connection\n\t\t\t\t\tconst conn = await actor.createConn(\n\t\t\t\t\t\tconnId,\n\t\t\t\t\t\tconnToken,\n\t\t\t\t\t\tparameters,\n\t\t\t\t\t\tconnState,\n\t\t\t\t\t\tCONNECTION_DRIVER_WEBSOCKET,\n\t\t\t\t\t\t{ encoding } satisfies GenericWebSocketDriverState,\n\t\t\t\t\t\tauthData,\n\t\t\t\t\t);\n\n\t\t\t\t\t// Unblock other handlers\n\t\t\t\t\thandlersResolve({ conn, actor, connId });\n\t\t\t\t} catch (error) {\n\t\t\t\t\thandlersReject(error);\n\n\t\t\t\t\tconst { code } = deconstructError(\n\t\t\t\t\t\terror,\n\t\t\t\t\t\tlogger(),\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\twsEvent: \"open\",\n\t\t\t\t\t\t},\n\t\t\t\t\t\texposeInternalError,\n\t\t\t\t\t);\n\t\t\t\t\tws.close(1011, code);\n\t\t\t\t}\n\t\t\t})();\n\t\t},\n\t\tonMessage: (evt: { data: any }, ws: WSContext) => {\n\t\t\t// Handle message asynchronously\n\t\t\thandlersPromise\n\t\t\t\t.then(({ conn, actor }) => {\n\t\t\t\t\tlogger().debug(\"received message\");\n\n\t\t\t\t\tconst value = evt.data.valueOf() as InputData;\n\t\t\t\t\tparseMessage(value, {\n\t\t\t\t\t\tencoding: encoding,\n\t\t\t\t\t\tmaxIncomingMessageSize: runConfig.maxIncomingMessageSize,\n\t\t\t\t\t})\n\t\t\t\t\t\t.then((message) => {\n\t\t\t\t\t\t\tactor.processMessage(message, conn).catch((error) => {\n\t\t\t\t\t\t\t\tconst { code } = deconstructError(\n\t\t\t\t\t\t\t\t\terror,\n\t\t\t\t\t\t\t\t\tlogger(),\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\twsEvent: \"message\",\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t\texposeInternalError,\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tws.close(1011, code);\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.catch((error) => {\n\t\t\t\t\t\t\tconst { code } = deconstructError(\n\t\t\t\t\t\t\t\terror,\n\t\t\t\t\t\t\t\tlogger(),\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\twsEvent: \"message\",\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\texposeInternalError,\n\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\tws.close(1011, code);\n\t\t\t\t\t\t});\n\t\t\t\t})\n\t\t\t\t.catch((error) => {\n\t\t\t\t\tconst { code } = deconstructError(\n\t\t\t\t\t\terror,\n\t\t\t\t\t\tlogger(),\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\twsEvent: \"message\",\n\t\t\t\t\t\t},\n\t\t\t\t\t\texposeInternalError,\n\t\t\t\t\t);\n\t\t\t\t\tws.close(1011, code);\n\t\t\t\t});\n\t\t},\n\t\tonClose: (\n\t\t\tevent: {\n\t\t\t\twasClean: boolean;\n\t\t\t\tcode: number;\n\t\t\t\treason: string;\n\t\t\t},\n\t\t\tws: WSContext,\n\t\t) => {\n\t\t\tif (event.wasClean) {\n\t\t\t\tlogger().info(\"websocket closed\", {\n\t\t\t\t\tcode: event.code,\n\t\t\t\t\treason: event.reason,\n\t\t\t\t\twasClean: event.wasClean,\n\t\t\t\t});\n\t\t\t} else {\n\t\t\t\tlogger().warn(\"websocket closed\", {\n\t\t\t\t\tcode: event.code,\n\t\t\t\t\treason: event.reason,\n\t\t\t\t\twasClean: event.wasClean,\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// HACK: Close socket in order to fix bug with Cloudflare leaving WS in closing state\n\t\t\t// https://github.com/cloudflare/workerd/issues/2569\n\t\t\tws.close(1000, \"hack_force_close\");\n\n\t\t\t// Handle cleanup asynchronously\n\t\t\thandlersPromise\n\t\t\t\t.then(({ conn, actor, connId }) => {\n\t\t\t\t\tconst connGlobalState =\n\t\t\t\t\t\tactorDriver.getGenericConnGlobalState(actorId);\n\t\t\t\t\tconst didDelete = connGlobalState.websockets.delete(connId);\n\t\t\t\t\tif (didDelete) {\n\t\t\t\t\t\tlogger().info(\"removing websocket for conn\", {\n\t\t\t\t\t\t\ttotalCount: connGlobalState.websockets.size,\n\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\tlogger().warn(\"websocket does not exist for conn\", {\n\t\t\t\t\t\t\tactorId,\n\t\t\t\t\t\t\ttotalCount: connGlobalState.websockets.size,\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\n\t\t\t\t\tactor.__removeConn(conn);\n\t\t\t\t})\n\t\t\t\t.catch((error) => {\n\t\t\t\t\tdeconstructError(\n\t\t\t\t\t\terror,\n\t\t\t\t\t\tlogger(),\n\t\t\t\t\t\t{ wsEvent: \"close\" },\n\t\t\t\t\t\texposeInternalError,\n\t\t\t\t\t);\n\t\t\t\t});\n\t\t},\n\t\tonError: (_error: unknown) => {\n\t\t\ttry {\n\t\t\t\t// Actors don't need to know about this, since it's abstracted away\n\t\t\t\tlogger().warn(\"websocket error\");\n\t\t\t} catch (error) {\n\t\t\t\tdeconstructError(\n\t\t\t\t\terror,\n\t\t\t\t\tlogger(),\n\t\t\t\t\t{ wsEvent: \"error\" },\n\t\t\t\t\texposeInternalError,\n\t\t\t\t);\n\t\t\t}\n\t\t},\n\t};\n}\n\n/**\n * Creates an SSE connection handler\n */\nexport async function handleSseConnect(\n\tc: HonoContext,\n\t_runConfig: RunConfig,\n\tactorDriver: ActorDriver,\n\tactorId: string,\n\tauthData: unknown,\n) {\n\tconst encoding = getRequestEncoding(c.req);\n\tconst parameters = getRequestConnParams(c.req);\n\n\t// Return the main handler with all async work inside\n\treturn streamSSE(c, async (stream) => {\n\t\tlet actor: AnyActorInstance | undefined;\n\t\tlet connId: string | undefined;\n\t\tlet connToken: string | undefined;\n\t\tlet connState: unknown;\n\t\tlet conn: AnyConn | undefined;\n\n\t\ttry {\n\t\t\t// Do all async work inside the handler\n\t\t\tactor = await actorDriver.loadActor(actorId);\n\t\t\tconnId = generateConnId();\n\t\t\tconnToken = generateConnToken();\n\t\t\tconnState = await actor.prepareConn(parameters, c.req.raw);\n\n\t\t\tlogger().debug(\"sse open\");\n\n\t\t\t// Save stream\n\t\t\tactorDriver\n\t\t\t\t.getGenericConnGlobalState(actorId)\n\t\t\t\t.sseStreams.set(connId, stream);\n\n\t\t\t// Create connection\n\t\t\tconn = await actor.createConn(\n\t\t\t\tconnId,\n\t\t\t\tconnToken,\n\t\t\t\tparameters,\n\t\t\t\tconnState,\n\t\t\t\tCONNECTION_DRIVER_SSE,\n\t\t\t\t{ encoding } satisfies GenericSseDriverState,\n\t\t\t\tauthData,\n\t\t\t);\n\n\t\t\t// Wait for close\n\t\t\tconst abortResolver = Promise.withResolvers();\n\n\t\t\t// Handle stream abort (when client closes the connection)\n\t\t\tstream.onAbort(async () => {\n\t\t\t\ttry {\n\t\t\t\t\tlogger().debug(\"sse stream aborted\");\n\n\t\t\t\t\t// Cleanup\n\t\t\t\t\tif (connId) {\n\t\t\t\t\t\tactorDriver\n\t\t\t\t\t\t\t.getGenericConnGlobalState(actorId)\n\t\t\t\t\t\t\t.sseStreams.delete(connId);\n\t\t\t\t\t}\n\t\t\t\t\tif (conn && actor) {\n\t\t\t\t\t\tactor.__removeConn(conn);\n\t\t\t\t\t}\n\n\t\t\t\t\tabortResolver.resolve(undefined);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger().error(\"error closing sse connection\", { error });\n\t\t\t\t\tabortResolver.resolve(undefined);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// HACK: Will throw if not configured\n\t\t\ttry {\n\t\t\t\tc.executionCtx.waitUntil(abortResolver.promise);\n\t\t\t} catch {}\n\n\t\t\t// Wait until connection aborted\n\t\t\tawait abortResolver.promise;\n\t\t} catch (error) {\n\t\t\tlogger().error(\"error in sse connection\", { error });\n\n\t\t\t// Cleanup on error\n\t\t\tif (connId !== undefined) {\n\t\t\t\tactorDriver\n\t\t\t\t\t.getGenericConnGlobalState(actorId)\n\t\t\t\t\t.sseStreams.delete(connId);\n\t\t\t}\n\t\t\tif (conn && actor !== undefined) {\n\t\t\t\tactor.__removeConn(conn);\n\t\t\t}\n\n\t\t\t// Close the stream on error\n\t\t\tstream.close();\n\t\t}\n\t});\n}\n\n/**\n * Creates an action handler\n */\nexport async function handleAction(\n\tc: HonoContext,\n\t_runConfig: RunConfig,\n\tactorDriver: ActorDriver,\n\tactionName: string,\n\tactorId: string,\n\tauthData: unknown,\n) {\n\tconst encoding = getRequestEncoding(c.req);\n\tconst parameters = getRequestConnParams(c.req);\n\n\tlogger().debug(\"handling action\", { actionName, encoding });\n\n\t// Validate incoming request\n\tconst arrayBuffer = await c.req.arrayBuffer();\n\tconst request = deserializeWithEncoding(\n\t\tencoding,\n\t\tnew Uint8Array(arrayBuffer),\n\t\tHTTP_ACTION_REQUEST_VERSIONED,\n\t);\n\tconst actionArgs = cbor.decode(new Uint8Array(request.args));\n\n\t// Invoke the action\n\tlet actor: AnyActorInstance | undefined;\n\tlet conn: AnyConn | undefined;\n\tlet output: unknown | undefined;\n\ttry {\n\t\tactor = await actorDriver.loadActor(actorId);\n\n\t\t// Create conn\n\t\tconst connState = await actor.prepareConn(parameters, c.req.raw);\n\t\tconn = await actor.createConn(\n\t\t\tgenerateConnId(),\n\t\t\tgenerateConnToken(),\n\t\t\tparameters,\n\t\t\tconnState,\n\t\t\tCONNECTION_DRIVER_HTTP,\n\t\t\t{} satisfies GenericHttpDriverState,\n\t\t\tauthData,\n\t\t);\n\n\t\t// Call action\n\t\tconst ctx = new ActionContext(actor.actorContext!, conn!);\n\t\toutput = await actor.executeAction(ctx, actionName, actionArgs);\n\t} finally {\n\t\tif (conn) {\n\t\t\tactor?.__removeConn(conn);\n\t\t}\n\t}\n\n\t// Send response\n\tconst responseData: protocol.HttpActionResponse = {\n\t\toutput: bufferToArrayBuffer(cbor.encode(output)),\n\t};\n\tconst serialized = serializeWithEncoding(\n\t\tencoding,\n\t\tresponseData,\n\t\tHTTP_ACTION_RESPONSE_VERSIONED,\n\t);\n\treturn c.body(serialized as Uint8Array, 200, {\n\t\t\"Content-Type\": contentTypeForEncoding(encoding),\n\t});\n}\n\n/**\n * Create a connection message handler\n */\nexport async function handleConnectionMessage(\n\tc: HonoContext,\n\t_runConfig: RunConfig,\n\tactorDriver: ActorDriver,\n\tconnId: string,\n\tconnToken: string,\n\tactorId: string,\n) {\n\tconst encoding = getRequestEncoding(c.req);\n\n\t// Validate incoming request\n\tconst arrayBuffer = await c.req.arrayBuffer();\n\tconst message = deserializeWithEncoding(\n\t\tencoding,\n\t\tnew Uint8Array(arrayBuffer),\n\t\tTO_SERVER_VERSIONED,\n\t);\n\n\tconst actor = await actorDriver.loadActor(actorId);\n\n\t// Find connection\n\tconst conn = actor.conns.get(connId);\n\tif (!conn) {\n\t\tthrow new errors.ConnNotFound(connId);\n\t}\n\n\t// Authenticate connection\n\tif (conn._token !== connToken) {\n\t\tthrow new errors.IncorrectConnToken();\n\t}\n\n\t// Process message\n\tawait actor.processMessage(message, conn);\n\n\treturn c.json({});\n}\n\nexport async function handleRawWebSocketHandler(\n\treq: Request | undefined,\n\tpath: string,\n\tactorDriver: ActorDriver,\n\tactorId: string,\n\tauthData: unknown,\n): Promise<UpgradeWebSocketArgs> {\n\tconst actor = await actorDriver.loadActor(actorId);\n\n\t// Return WebSocket event handlers\n\treturn {\n\t\tonOpen: (_evt: any, ws: any) => {\n\t\t\t// Wrap the Hono WebSocket in our adapter\n\t\t\tconst adapter = new HonoWebSocketAdapter(ws);\n\n\t\t\t// Store adapter reference on the WebSocket for event handlers\n\t\t\t(ws as any).__adapter = adapter;\n\n\t\t\t// Extract the path after prefix and preserve query parameters\n\t\t\t// Use URL API for cleaner parsing\n\t\t\tconst url = new URL(path, \"http://actor\");\n\t\t\tconst pathname = url.pathname.replace(/^\\/raw\\/websocket/, \"\") || \"/\";\n\t\t\tconst normalizedPath = pathname + url.search;\n\n\t\t\tlet newRequest: Request;\n\t\t\tif (req) {\n\t\t\t\tnewRequest = new Request(`http://actor${normalizedPath}`, req);\n\t\t\t} else {\n\t\t\t\tnewRequest = new Request(`http://actor${normalizedPath}`, {\n\t\t\t\t\tmethod: \"GET\",\n\t\t\t\t});\n\t\t\t}\n\n\t\t\tlogger().debug(\"rewriting websocket url\", {\n\t\t\t\tfrom: path,\n\t\t\t\tto: newRequest.url,\n\t\t\t});\n\n\t\t\t// Call the actor's onWebSocket handler with the adapted WebSocket\n\t\t\tactor.handleWebSocket(adapter, {\n\t\t\t\trequest: newRequest,\n\t\t\t\tauth: authData,\n\t\t\t});\n\t\t},\n\t\tonMessage: (event: any, ws: any) => {\n\t\t\t// Find the adapter for this WebSocket\n\t\t\tconst adapter = (ws as any).__adapter;\n\t\t\tif (adapter) {\n\t\t\t\tadapter._handleMessage(event);\n\t\t\t}\n\t\t},\n\t\tonClose: (evt: any, ws: any) => {\n\t\t\t// Find the adapter for this WebSocket\n\t\t\tconst adapter = (ws as any).__adapter;\n\t\t\tif (adapter) {\n\t\t\t\tadapter._handleClose(evt?.code || 1006, evt?.reason || \"\");\n\t\t\t}\n\t\t},\n\t\tonError: (error: any, ws: any) => {\n\t\t\t// Find the adapter for this WebSocket\n\t\t\tconst adapter = (ws as any).__adapter;\n\t\t\tif (adapter) {\n\t\t\t\tadapter._handleError(error);\n\t\t\t}\n\t\t},\n\t};\n}\n\n// Helper to get the connection encoding from a request\nexport function getRequestEncoding(req: HonoRequest): Encoding {\n\tconst encodingParam = req.header(HEADER_ENCODING);\n\tif (!encodingParam) {\n\t\tthrow new errors.InvalidEncoding(\"undefined\");\n\t}\n\n\tconst result = EncodingSchema.safeParse(encodingParam);\n\tif (!result.success) {\n\t\tthrow new errors.InvalidEncoding(encodingParam as string);\n\t}\n\n\treturn result.data;\n}\n\nexport function getRequestExposeInternalError(req: Request): boolean {\n\tconst param = req.headers.get(HEADER_EXPOSE_INTERNAL_ERROR);\n\tif (!param) {\n\t\treturn false;\n\t}\n\n\treturn param === \"true\";\n}\n\nexport function getRequestQuery(c: HonoContext): unknown {\n\t// Get query parameters for actor lookup\n\tconst queryParam = c.req.header(HEADER_ACTOR_QUERY);\n\tif (!queryParam) {\n\t\tlogger().error(\"missing query parameter\");\n\t\tthrow new errors.InvalidRequest(\"missing query\");\n\t}\n\n\t// Parse the query JSON and validate with schema\n\ttry {\n\t\tconst parsed = JSON.parse(queryParam);\n\t\treturn parsed;\n\t} catch (error) {\n\t\tlogger().error(\"invalid query json\", { error });\n\t\tthrow new errors.InvalidQueryJSON(error);\n\t}\n}\n\nexport const HEADER_ACTOR_QUERY = \"X-RivetKit-Query\";\n\nexport const HEADER_ENCODING = \"X-RivetKit-Encoding\";\n\n// Internal header\nexport const HEADER_EXPOSE_INTERNAL_ERROR = \"X-RivetKit-Expose-Internal-Error\";\n\n// IMPORTANT: Params must be in headers or in an E2EE part of the request (i.e. NOT the URL or query string) in order to ensure that tokens can be securely passed in params.\nexport const HEADER_CONN_PARAMS = \"X-RivetKit-Conn-Params\";\n\n// Internal header\nexport const HEADER_AUTH_DATA = \"X-RivetKit-Auth-Data\";\n\nexport const HEADER_ACTOR_ID = \"X-RivetKit-Actor\";\n\nexport const HEADER_CONN_ID = \"X-RivetKit-Conn\";\n\nexport const HEADER_CONN_TOKEN = \"X-RivetKit-Conn-Token\";\n\n/**\n * Headers that publics can send from public clients.\n *\n * Used for CORS.\n **/\nexport const ALLOWED_PUBLIC_HEADERS = [\n\t\"Content-Type\",\n\t\"User-Agent\",\n\tHEADER_ACTOR_QUERY,\n\tHEADER_ENCODING,\n\tHEADER_CONN_PARAMS,\n\tHEADER_ACTOR_ID,\n\tHEADER_CONN_ID,\n\tHEADER_CONN_TOKEN,\n];\n\n// Helper to get connection parameters for the request\nexport function getRequestConnParams(req: HonoRequest): unknown {\n\tconst paramsParam = req.header(HEADER_CONN_PARAMS);\n\tif (!paramsParam) {\n\t\treturn null;\n\t}\n\n\ttry {\n\t\treturn JSON.parse(paramsParam);\n\t} catch (err) {\n\t\tthrow new errors.InvalidParams(\n\t\t\t`Invalid params JSON: ${stringifyError(err)}`,\n\t\t);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/action.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/action.ts\";import type { ActorKey } from \"@/actor/mod\";\nimport type { Client } from \"@/client/client\";\nimport type { Logger } from \"@/common/log\";\nimport type { Registry } from \"@/registry/mod\";\nimport type { Conn, ConnId } from \"./connection\";\nimport type { ActorContext } from \"./context\";\nimport type { AnyDatabaseProvider, InferDatabaseClient } from \"./database\";\nimport type { SaveStateOptions } from \"./instance\";\nimport type { Schedule } from \"./schedule\";\n\n/**\n * Context for a remote procedure call.\n *\n * @typeParam A Actor this action belongs to\n */\nexport class ActionContext<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n> {\n\t#actorContext: ActorContext<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>;\n\n\t/**\n\t * Should not be called directly.\n\t *\n\t * @param actorContext - The actor context\n\t * @param conn - The connection associated with the action\n\t */\n\tconstructor(\n\t\tactorContext: ActorContext<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t\tpublic readonly conn: Conn<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) {\n\t\tthis.#actorContext = actorContext;\n\t}\n\n\t/**\n\t * Get the actor state\n\t */\n\tget state(): TState {\n\t\treturn this.#actorContext.state;\n\t}\n\n\t/**\n\t * Get the actor variables\n\t */\n\tget vars(): TVars {\n\t\treturn this.#actorContext.vars;\n\t}\n\n\t/**\n\t * Broadcasts an event to all connected clients.\n\t */\n\tbroadcast(name: string, ...args: any[]): void {\n\t\tthis.#actorContext.broadcast(name, ...args);\n\t}\n\n\t/**\n\t * Gets the logger instance.\n\t */\n\tget log(): Logger {\n\t\treturn this.#actorContext.log;\n\t}\n\n\t/**\n\t * Gets actor ID.\n\t */\n\tget actorId(): string {\n\t\treturn this.#actorContext.actorId;\n\t}\n\n\t/**\n\t * Gets the actor name.\n\t */\n\tget name(): string {\n\t\treturn this.#actorContext.name;\n\t}\n\n\t/**\n\t * Gets the actor key.\n\t */\n\tget key(): ActorKey {\n\t\treturn this.#actorContext.key;\n\t}\n\n\t/**\n\t * Gets the region.\n\t */\n\tget region(): string {\n\t\treturn this.#actorContext.region;\n\t}\n\n\t/**\n\t * Gets the scheduler.\n\t */\n\tget schedule(): Schedule {\n\t\treturn this.#actorContext.schedule;\n\t}\n\n\t/**\n\t * Gets the map of connections.\n\t */\n\tget conns(): Map<\n\t\tConnId,\n\t\tConn<TState, TConnParams, TConnState, TVars, TInput, TAuthData, TDatabase>\n\t> {\n\t\treturn this.#actorContext.conns;\n\t}\n\n\t/**\n\t * Returns the client for the given registry.\n\t */\n\tclient<R extends Registry<any>>(): Client<R> {\n\t\treturn this.#actorContext.client<R>();\n\t}\n\n\t/**\n\t * @experimental\n\t */\n\tget db(): InferDatabaseClient<TDatabase> {\n\t\treturn this.#actorContext.db;\n\t}\n\n\t/**\n\t * Forces the state to get saved.\n\t */\n\tasync saveState(opts: SaveStateOptions): Promise<void> {\n\t\treturn this.#actorContext.saveState(opts);\n\t}\n\n\t/**\n\t * Prevents the actor from sleeping until promise is complete.\n\t */\n\twaitUntil(promise: Promise<void>): void {\n\t\tthis.#actorContext.waitUntil(promise);\n\t}\n\n\t/**\n\t * AbortSignal that fires when the actor is stopping.\n\t */\n\tget abortSignal(): AbortSignal {\n\t\treturn this.#actorContext.abortSignal;\n\t}\n\n\t/**\n\t * Forces the actor to sleep.\n\t *\n\t * Not supported on all drivers.\n\t *\n\t * @experimental\n\t */\n\tsleep() {\n\t\tthis.#actorContext.sleep();\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/manager/log.ts\";import { getLogger } from \"@/common//log\";\n\nexport const LOGGER_NAME = \"actor-manager\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/hono-websocket-adapter.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/manager/hono-websocket-adapter.ts\";import type { WSContext } from \"hono/ws\";\nimport type {\n\tRivetCloseEvent,\n\tRivetEvent,\n\tRivetMessageEvent,\n\tUniversalWebSocket,\n} from \"@/common/websocket-interface\";\nimport { logger } from \"./log\";\n\n/**\n * HonoWebSocketAdapter provides a WebSocket-like interface over WSContext\n * for raw WebSocket handling in actors\n */\nexport class HonoWebSocketAdapter implements UniversalWebSocket {\n\t// WebSocket readyState values\n\treadonly CONNECTING = 0 as const;\n\treadonly OPEN = 1 as const;\n\treadonly CLOSING = 2 as const;\n\treadonly CLOSED = 3 as const;\n\n\t#ws: WSContext;\n\t#readyState: 0 | 1 | 2 | 3 = 1; // Start as OPEN since WSContext is already connected\n\t#eventListeners: Map<string, Set<(event: any) => void>> = new Map();\n\t#closeCode?: number;\n\t#closeReason?: string;\n\n\tconstructor(ws: WSContext) {\n\t\tthis.#ws = ws;\n\n\t\t// The WSContext is already open when we receive it\n\t\tthis.#readyState = this.OPEN;\n\n\t\t// Immediately fire the open event\n\t\tsetTimeout(() => {\n\t\t\tthis.#fireEvent(\"open\", { type: \"open\", target: this });\n\t\t}, 0);\n\t}\n\n\tget readyState(): 0 | 1 | 2 | 3 {\n\t\treturn this.#readyState;\n\t}\n\n\tget binaryType(): \"arraybuffer\" | \"blob\" {\n\t\treturn \"arraybuffer\";\n\t}\n\n\tset binaryType(value: \"arraybuffer\" | \"blob\") {\n\t\t// Ignored for now - always use arraybuffer\n\t}\n\n\tget bufferedAmount(): number {\n\t\treturn 0; // Not tracked in WSContext\n\t}\n\n\tget extensions(): string {\n\t\treturn \"\"; // Not available in WSContext\n\t}\n\n\tget protocol(): string {\n\t\treturn \"\"; // Not available in WSContext\n\t}\n\n\tget url(): string {\n\t\treturn \"\"; // Not available in WSContext\n\t}\n\n\tsend(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n\t\tif (this.readyState !== this.OPEN) {\n\t\t\tthrow new Error(\"WebSocket is not open\");\n\t\t}\n\n\t\ttry {\n\t\t\tlogger().debug(\"bridge sending data\", {\n\t\t\t\tdataType: typeof data,\n\t\t\t\tisString: typeof data === \"string\",\n\t\t\t\tisArrayBuffer: data instanceof ArrayBuffer,\n\t\t\t\tdataStr:\n\t\t\t\t\ttypeof data === \"string\" ? data.substring(0, 100) : \"<non-string>\",\n\t\t\t});\n\n\t\t\tif (typeof data === \"string\") {\n\t\t\t\t(this.#ws as any).send(data);\n\t\t\t} else if (data instanceof ArrayBuffer) {\n\t\t\t\t(this.#ws as any).send(data);\n\t\t\t} else if (ArrayBuffer.isView(data)) {\n\t\t\t\t// Convert ArrayBufferView to ArrayBuffer\n\t\t\t\tconst buffer = data.buffer.slice(\n\t\t\t\t\tdata.byteOffset,\n\t\t\t\t\tdata.byteOffset + data.byteLength,\n\t\t\t\t);\n\t\t\t\t// Check if it's a SharedArrayBuffer and convert to ArrayBuffer\n\t\t\t\tif (buffer instanceof SharedArrayBuffer) {\n\t\t\t\t\tconst arrayBuffer = new ArrayBuffer(buffer.byteLength);\n\t\t\t\t\tnew Uint8Array(arrayBuffer).set(new Uint8Array(buffer));\n\t\t\t\t\t(this.#ws as any).send(arrayBuffer);\n\t\t\t\t} else {\n\t\t\t\t\t(this.#ws as any).send(buffer);\n\t\t\t\t}\n\t\t\t} else if (data instanceof Blob) {\n\t\t\t\t// Convert Blob to ArrayBuffer\n\t\t\t\tdata\n\t\t\t\t\t.arrayBuffer()\n\t\t\t\t\t.then((buffer) => {\n\t\t\t\t\t\t(this.#ws as any).send(buffer);\n\t\t\t\t\t})\n\t\t\t\t\t.catch((error) => {\n\t\t\t\t\t\tlogger().error(\"failed to convert blob to arraybuffer\", { error });\n\t\t\t\t\t\tthis.#fireEvent(\"error\", { type: \"error\", target: this, error });\n\t\t\t\t\t});\n\t\t\t} else {\n\t\t\t\t// Try to convert to string as a fallback\n\t\t\t\tlogger().warn(\"unsupported data type, converting to string\", {\n\t\t\t\t\tdataType: typeof data,\n\t\t\t\t\tdata,\n\t\t\t\t});\n\t\t\t\t(this.#ws as any).send(String(data));\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tlogger().error(\"error sending websocket data\", { error });\n\t\t\tthis.#fireEvent(\"error\", { type: \"error\", target: this, error });\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tclose(code = 1000, reason = \"\"): void {\n\t\tif (this.readyState === this.CLOSING || this.readyState === this.CLOSED) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis.#readyState = this.CLOSING;\n\t\tthis.#closeCode = code;\n\t\tthis.#closeReason = reason;\n\n\t\ttry {\n\t\t\t(this.#ws as any).close(code, reason);\n\n\t\t\t// Update state and fire close event\n\t\t\tthis.#readyState = this.CLOSED;\n\t\t\tthis.#fireEvent(\"close\", {\n\t\t\t\ttype: \"close\",\n\t\t\t\ttarget: this,\n\t\t\t\tcode,\n\t\t\t\treason,\n\t\t\t\twasClean: code === 1000,\n\t\t\t});\n\t\t} catch (error) {\n\t\t\tlogger().error(\"error closing websocket\", { error });\n\t\t\tthis.#readyState = this.CLOSED;\n\t\t\tthis.#fireEvent(\"close\", {\n\t\t\t\ttype: \"close\",\n\t\t\t\ttarget: this,\n\t\t\t\tcode: 1006,\n\t\t\t\treason: \"Abnormal closure\",\n\t\t\t\twasClean: false,\n\t\t\t});\n\t\t}\n\t}\n\n\taddEventListener(type: string, listener: (event: any) => void): void {\n\t\tif (!this.#eventListeners.has(type)) {\n\t\t\tthis.#eventListeners.set(type, new Set());\n\t\t}\n\t\tthis.#eventListeners.get(type)!.add(listener);\n\t}\n\n\tremoveEventListener(type: string, listener: (event: any) => void): void {\n\t\tconst listeners = this.#eventListeners.get(type);\n\t\tif (listeners) {\n\t\t\tlisteners.delete(listener);\n\t\t}\n\t}\n\n\tdispatchEvent(event: RivetEvent): boolean {\n\t\tconst listeners = this.#eventListeners.get(event.type);\n\t\tif (listeners) {\n\t\t\tfor (const listener of listeners) {\n\t\t\t\ttry {\n\t\t\t\t\tlistener(event);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger().error(`error in ${event.type} event listener`, { error });\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n\n\t// Internal method to handle incoming messages from WSContext\n\t_handleMessage(data: any): void {\n\t\t// Hono may pass either raw data or a MessageEvent-like object\n\t\tlet messageData: string | ArrayBuffer | ArrayBufferView;\n\n\t\tif (typeof data === \"string\") {\n\t\t\tmessageData = data;\n\t\t} else if (data instanceof ArrayBuffer || ArrayBuffer.isView(data)) {\n\t\t\tmessageData = data;\n\t\t} else if (data && typeof data === \"object\" && \"data\" in data) {\n\t\t\t// Handle MessageEvent-like objects\n\t\t\tmessageData = data.data;\n\t\t} else {\n\t\t\t// Fallback - shouldn't happen in normal operation\n\t\t\tmessageData = String(data);\n\t\t}\n\n\t\tlogger().debug(\"bridge handling message\", {\n\t\t\tdataType: typeof messageData,\n\t\t\tisArrayBuffer: messageData instanceof ArrayBuffer,\n\t\t\tdataStr: typeof messageData === \"string\" ? messageData : \"<binary>\",\n\t\t});\n\n\t\tthis.#fireEvent(\"message\", {\n\t\t\ttype: \"message\",\n\t\t\ttarget: this,\n\t\t\tdata: messageData,\n\t\t});\n\t}\n\n\t// Internal method to handle close from WSContext\n\t_handleClose(code: number, reason: string): void {\n\t\t// HACK: Close socket in order to fix bug with Cloudflare leaving WS in closing state\n\t\t// https://github.com/cloudflare/workerd/issues/2569\n\t\t(this.#ws as any).close(1000, \"hack_force_close\");\n\n\t\tif (this.readyState === this.CLOSED) return;\n\n\t\tthis.#readyState = this.CLOSED;\n\t\tthis.#closeCode = code;\n\t\tthis.#closeReason = reason;\n\n\t\tthis.#fireEvent(\"close\", {\n\t\t\ttype: \"close\",\n\t\t\ttarget: this,\n\t\t\tcode,\n\t\t\treason,\n\t\t\twasClean: code === 1000,\n\t\t});\n\t}\n\n\t// Internal method to handle errors from WSContext\n\t_handleError(error: any): void {\n\t\tthis.#fireEvent(\"error\", {\n\t\t\ttype: \"error\",\n\t\t\ttarget: this,\n\t\t\terror,\n\t\t});\n\t}\n\n\t#fireEvent(type: string, event: any): void {\n\t\tconst listeners = this.#eventListeners.get(type);\n\t\tif (listeners) {\n\t\t\tfor (const listener of listeners) {\n\t\t\t\ttry {\n\t\t\t\t\tlistener(event);\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger().error(`error in ${type} event listener`, { error });\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Also check for on* properties\n\t\tswitch (type) {\n\t\t\tcase \"open\":\n\t\t\t\tif (this.#onopen) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onopen(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onopen handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"close\":\n\t\t\t\tif (this.#onclose) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onclose(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onclose handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"error\":\n\t\t\t\tif (this.#onerror) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onerror(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onerror handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"message\":\n\t\t\t\tif (this.#onmessage) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onmessage(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onmessage handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\t// Event handler properties with getters/setters\n\t#onopen: ((event: RivetEvent) => void) | null = null;\n\t#onclose: ((event: RivetCloseEvent) => void) | null = null;\n\t#onerror: ((event: RivetEvent) => void) | null = null;\n\t#onmessage: ((event: RivetMessageEvent) => void) | null = null;\n\n\tget onopen(): ((event: RivetEvent) => void) | null {\n\t\treturn this.#onopen;\n\t}\n\tset onopen(handler: ((event: RivetEvent) => void) | null) {\n\t\tthis.#onopen = handler;\n\t}\n\n\tget onclose(): ((event: RivetCloseEvent) => void) | null {\n\t\treturn this.#onclose;\n\t}\n\tset onclose(handler: ((event: RivetCloseEvent) => void) | null) {\n\t\tthis.#onclose = handler;\n\t}\n\n\tget onerror(): ((event: RivetEvent) => void) | null {\n\t\treturn this.#onerror;\n\t}\n\tset onerror(handler: ((event: RivetEvent) => void) | null) {\n\t\tthis.#onerror = handler;\n\t}\n\n\tget onmessage(): ((event: RivetMessageEvent) => void) | null {\n\t\treturn this.#onmessage;\n\t}\n\tset onmessage(handler: ((event: RivetMessageEvent) => void) | null) {\n\t\tthis.#onmessage = handler;\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol/old.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/protocol/old.ts\";import * as cbor from \"cbor-x\";\nimport { z } from \"zod\";\nimport type { AnyDatabaseProvider } from \"@/actor/database\";\nimport * as errors from \"@/actor/errors\";\nimport {\n\tCachedSerializer,\n\ttype Encoding,\n\ttype InputData,\n} from \"@/actor/protocol/serde\";\nimport { deconstructError } from \"@/common/utils\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport {\n\tTO_CLIENT_VERSIONED,\n\tTO_SERVER_VERSIONED,\n} from \"@/schemas/client-protocol/versioned\";\nimport { deserializeWithEncoding } from \"@/serde\";\nimport { assertUnreachable, bufferToArrayBuffer } from \"../../utils\";\nimport { ActionContext } from \"../action\";\nimport type { Conn } from \"../connection\";\nimport type { ActorInstance } from \"../instance\";\nimport { logger } from \"../log\";\n\nexport const TransportSchema = z.enum([\"websocket\", \"sse\"]);\n\n/**\n * Transport mechanism used to communicate between client & actor.\n */\nexport type Transport = z.infer<typeof TransportSchema>;\n\ninterface MessageEventOpts {\n\tencoding: Encoding;\n\tmaxIncomingMessageSize: number;\n}\n\nfunction getValueLength(value: InputData): number {\n\tif (typeof value === \"string\") {\n\t\treturn value.length;\n\t} else if (value instanceof Blob) {\n\t\treturn value.size;\n\t} else if (\n\t\tvalue instanceof ArrayBuffer ||\n\t\tvalue instanceof SharedArrayBuffer ||\n\t\tvalue instanceof Uint8Array\n\t) {\n\t\treturn value.byteLength;\n\t} else {\n\t\tassertUnreachable(value);\n\t}\n}\n\nexport async function inputDataToBuffer(\n\tdata: InputData,\n): Promise<Uint8Array | string> {\n\tif (typeof data === \"string\") {\n\t\treturn data;\n\t} else if (data instanceof Blob) {\n\t\tconst arrayBuffer = await data.arrayBuffer();\n\t\treturn new Uint8Array(arrayBuffer);\n\t} else if (data instanceof Uint8Array) {\n\t\treturn data;\n\t} else if (data instanceof ArrayBuffer || data instanceof SharedArrayBuffer) {\n\t\treturn new Uint8Array(data);\n\t} else {\n\t\tthrow new errors.MalformedMessage();\n\t}\n}\n\nexport async function parseMessage(\n\tvalue: InputData,\n\topts: MessageEventOpts,\n): Promise<protocol.ToServer> {\n\t// Validate value length\n\tconst length = getValueLength(value);\n\tif (length > opts.maxIncomingMessageSize) {\n\t\tthrow new errors.MessageTooLong();\n\t}\n\n\t// Parse & validate message\n\tconst buffer = await inputDataToBuffer(value);\n\treturn deserializeWithEncoding(opts.encoding, buffer, TO_SERVER_VERSIONED);\n}\n\nexport interface ProcessMessageHandler<\n\tS,\n\tCP,\n\tCS,\n\tV,\n\tI,\n\tAD,\n\tDB extends AnyDatabaseProvider,\n> {\n\tonExecuteAction?: (\n\t\tctx: ActionContext<S, CP, CS, V, I, AD, DB>,\n\t\tname: string,\n\t\targs: unknown[],\n\t) => Promise<unknown>;\n\tonSubscribe?: (\n\t\teventName: string,\n\t\tconn: Conn<S, CP, CS, V, I, AD, DB>,\n\t) => Promise<void>;\n\tonUnsubscribe?: (\n\t\teventName: string,\n\t\tconn: Conn<S, CP, CS, V, I, AD, DB>,\n\t) => Promise<void>;\n}\n\nexport async function processMessage<\n\tS,\n\tCP,\n\tCS,\n\tV,\n\tI,\n\tAD,\n\tDB extends AnyDatabaseProvider,\n>(\n\tmessage: protocol.ToServer,\n\tactor: ActorInstance<S, CP, CS, V, I, AD, DB>,\n\tconn: Conn<S, CP, CS, V, I, AD, DB>,\n\thandler: ProcessMessageHandler<S, CP, CS, V, I, AD, DB>,\n) {\n\tlet actionId: bigint | undefined;\n\tlet actionName: string | undefined;\n\n\ttry {\n\t\tif (message.body.tag === \"ActionRequest\") {\n\t\t\t// Action request\n\n\t\t\tif (handler.onExecuteAction === undefined) {\n\t\t\t\tthrow new errors.Unsupported(\"Action\");\n\t\t\t}\n\n\t\t\tconst { id, name, args: argsRaw } = message.body.val;\n\t\t\tactionId = id;\n\t\t\tactionName = name;\n\t\t\tconst args = cbor.decode(new Uint8Array(argsRaw));\n\n\t\t\tlogger().debug(\"processing action request\", {\n\t\t\t\tactionId: id,\n\t\t\t\tactionName: name,\n\t\t\t});\n\n\t\t\tconst ctx = new ActionContext<S, CP, CS, V, I, AD, DB>(\n\t\t\t\tactor.actorContext,\n\t\t\t\tconn,\n\t\t\t);\n\n\t\t\t// Process the action request and wait for the result\n\t\t\t// This will wait for async actions to complete\n\t\t\tconst output = await handler.onExecuteAction(ctx, name, args);\n\n\t\t\tlogger().debug(\"sending action response\", {\n\t\t\t\tactionId: id,\n\t\t\t\tactionName: name,\n\t\t\t\toutputType: typeof output,\n\t\t\t\tisPromise: output instanceof Promise,\n\t\t\t});\n\n\t\t\t// Send the response back to the client\n\t\t\tconn._sendMessage(\n\t\t\t\tnew CachedSerializer<protocol.ToClient>(\n\t\t\t\t\t{\n\t\t\t\t\t\tbody: {\n\t\t\t\t\t\t\ttag: \"ActionResponse\",\n\t\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\t\tid: id,\n\t\t\t\t\t\t\t\toutput: bufferToArrayBuffer(cbor.encode(output)),\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t\t),\n\t\t\t);\n\n\t\t\tlogger().debug(\"action response sent\", { id, name: name });\n\t\t} else if (message.body.tag === \"SubscriptionRequest\") {\n\t\t\t// Subscription request\n\n\t\t\tif (\n\t\t\t\thandler.onSubscribe === undefined ||\n\t\t\t\thandler.onUnsubscribe === undefined\n\t\t\t) {\n\t\t\t\tthrow new errors.Unsupported(\"Subscriptions\");\n\t\t\t}\n\n\t\t\tconst { eventName, subscribe } = message.body.val;\n\t\t\tlogger().debug(\"processing subscription request\", {\n\t\t\t\teventName,\n\t\t\t\tsubscribe,\n\t\t\t});\n\n\t\t\tif (subscribe) {\n\t\t\t\tawait handler.onSubscribe(eventName, conn);\n\t\t\t} else {\n\t\t\t\tawait handler.onUnsubscribe(eventName, conn);\n\t\t\t}\n\n\t\t\tlogger().debug(\"subscription request completed\", {\n\t\t\t\teventName,\n\t\t\t\tsubscribe,\n\t\t\t});\n\t\t} else {\n\t\t\tassertUnreachable(message.body);\n\t\t}\n\t} catch (error) {\n\t\tconst { code, message, metadata } = deconstructError(error, logger(), {\n\t\t\tconnectionId: conn.id,\n\t\t\tactionId,\n\t\t\tactionName,\n\t\t});\n\n\t\tlogger().debug(\"sending error response\", {\n\t\t\tactionId,\n\t\t\tactionName,\n\t\t\tcode,\n\t\t\tmessage,\n\t\t});\n\n\t\t// Build response\n\t\tconn._sendMessage(\n\t\t\tnew CachedSerializer<protocol.ToClient>(\n\t\t\t\t{\n\t\t\t\t\tbody: {\n\t\t\t\t\t\ttag: \"Error\",\n\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\tcode,\n\t\t\t\t\t\t\tmessage,\n\t\t\t\t\t\t\tmetadata: bufferToArrayBuffer(cbor.encode(metadata)),\n\t\t\t\t\t\t\tactionId: actionId ?? null,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t),\n\t\t);\n\n\t\tlogger().debug(\"error response sent\", { actionId, actionName });\n\t}\n}\n\n///**\n// * Use `CachedSerializer` if serializing the same data repeatedly.\n// */\n//export function serialize<T>(value: T, encoding: Encoding): OutputData {\n//\tif (encoding === \"json\") {\n//\t\treturn JSON.stringify(value);\n//\t} else if (encoding === \"cbor\") {\n//\t\t// TODO: Remove this hack, but cbor-x can't handle anything extra in data structures\n//\t\tconst cleanValue = JSON.parse(JSON.stringify(value));\n//\t\treturn cbor.encode(cleanValue);\n//\t} else {\n//\t\tassertUnreachable(encoding);\n//\t}\n//}\n//\n//export async function deserialize(data: InputData, encoding: Encoding) {\n//\tif (encoding === \"json\") {\n//\t\tif (typeof data !== \"string\") {\n//\t\t\tlogger().warn(\"received non-string for json parse\");\n//\t\t\tthrow new errors.MalformedMessage();\n//\t\t} else {\n//\t\t\treturn JSON.parse(data);\n//\t\t}\n//\t} else if (encoding === \"cbor\") {\n//\t\tif (data instanceof Blob) {\n//\t\t\tconst arrayBuffer = await data.arrayBuffer();\n//\t\t\treturn cbor.decode(new Uint8Array(arrayBuffer));\n//\t\t} else if (data instanceof Uint8Array) {\n//\t\t\treturn cbor.decode(data);\n//\t\t} else if (\n//\t\t\tdata instanceof ArrayBuffer ||\n//\t\t\tdata instanceof SharedArrayBuffer\n//\t\t) {\n//\t\t\treturn cbor.decode(new Uint8Array(data));\n//\t\t} else {\n//\t\t\tlogger().warn(\"received non-binary type for cbor parse\");\n//\t\t\tthrow new errors.MalformedMessage();\n//\t\t}\n//\t} else {\n//\t\tassertUnreachable(encoding);\n//\t}\n//}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/actor-persist/v1.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/actor-persist\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/dist/schemas/actor-persist/v1.ts\";import * as bare from \"@bare-ts/lib\"\n\nconst config = /* @__PURE__ */ bare.Config({})\n\nexport type u64 = bigint\n\nexport type PersistedSubscription = {\n    readonly eventName: string,\n}\n\nexport function readPersistedSubscription(bc: bare.ByteCursor): PersistedSubscription {\n    return {\n        eventName: bare.readString(bc),\n    }\n}\n\nexport function writePersistedSubscription(bc: bare.ByteCursor, x: PersistedSubscription): void {\n    bare.writeString(bc, x.eventName)\n}\n\nfunction read0(bc: bare.ByteCursor): ArrayBuffer | null {\n    return bare.readBool(bc)\n        ? bare.readData(bc)\n        : null\n}\n\nfunction write0(bc: bare.ByteCursor, x: ArrayBuffer | null): void {\n    bare.writeBool(bc, x !== null)\n    if (x !== null) {\n        bare.writeData(bc, x)\n    }\n}\n\nfunction read1(bc: bare.ByteCursor): readonly PersistedSubscription[] {\n    const len = bare.readUintSafe(bc)\n    if (len === 0) { return [] }\n    const result = [readPersistedSubscription(bc)]\n    for (let i = 1; i < len; i++) {\n        result[i] = readPersistedSubscription(bc)\n    }\n    return result\n}\n\nfunction write1(bc: bare.ByteCursor, x: readonly PersistedSubscription[]): void {\n    bare.writeUintSafe(bc, x.length)\n    for (let i = 0; i < x.length; i++) {\n        writePersistedSubscription(bc, x[i])\n    }\n}\n\nexport type PersistedConnection = {\n    readonly id: string,\n    readonly token: string,\n    readonly driver: string,\n    readonly driverState: ArrayBuffer,\n    readonly parameters: ArrayBuffer,\n    readonly state: ArrayBuffer,\n    readonly auth: ArrayBuffer | null,\n    readonly subscriptions: readonly PersistedSubscription[],\n    readonly lastSeen: u64,\n}\n\nexport function readPersistedConnection(bc: bare.ByteCursor): PersistedConnection {\n    return {\n        id: bare.readString(bc),\n        token: bare.readString(bc),\n        driver: bare.readString(bc),\n        driverState: bare.readData(bc),\n        parameters: bare.readData(bc),\n        state: bare.readData(bc),\n        auth: read0(bc),\n        subscriptions: read1(bc),\n        lastSeen: bare.readU64(bc),\n    }\n}\n\nexport function writePersistedConnection(bc: bare.ByteCursor, x: PersistedConnection): void {\n    bare.writeString(bc, x.id)\n    bare.writeString(bc, x.token)\n    bare.writeString(bc, x.driver)\n    bare.writeData(bc, x.driverState)\n    bare.writeData(bc, x.parameters)\n    bare.writeData(bc, x.state)\n    write0(bc, x.auth)\n    write1(bc, x.subscriptions)\n    bare.writeU64(bc, x.lastSeen)\n}\n\nexport type GenericPersistedScheduleEvent = {\n    readonly action: string,\n    readonly args: ArrayBuffer | null,\n}\n\nexport function readGenericPersistedScheduleEvent(bc: bare.ByteCursor): GenericPersistedScheduleEvent {\n    return {\n        action: bare.readString(bc),\n        args: read0(bc),\n    }\n}\n\nexport function writeGenericPersistedScheduleEvent(bc: bare.ByteCursor, x: GenericPersistedScheduleEvent): void {\n    bare.writeString(bc, x.action)\n    write0(bc, x.args)\n}\n\nexport type PersistedScheduleEventKind =\n    | { readonly tag: \"GenericPersistedScheduleEvent\", readonly val: GenericPersistedScheduleEvent }\n\nexport function readPersistedScheduleEventKind(bc: bare.ByteCursor): PersistedScheduleEventKind {\n    const offset = bc.offset\n    const tag = bare.readU8(bc)\n    switch (tag) {\n        case 0:\n            return { tag: \"GenericPersistedScheduleEvent\", val: readGenericPersistedScheduleEvent(bc) }\n        default: {\n            bc.offset = offset\n            throw new bare.BareError(offset, \"invalid tag\")\n        }\n    }\n}\n\nexport function writePersistedScheduleEventKind(bc: bare.ByteCursor, x: PersistedScheduleEventKind): void {\n    switch (x.tag) {\n        case \"GenericPersistedScheduleEvent\": {\n            bare.writeU8(bc, 0)\n            writeGenericPersistedScheduleEvent(bc, x.val)\n            break\n        }\n    }\n}\n\nexport type PersistedScheduleEvent = {\n    readonly eventId: string,\n    readonly timestamp: u64,\n    readonly kind: PersistedScheduleEventKind,\n}\n\nexport function readPersistedScheduleEvent(bc: bare.ByteCursor): PersistedScheduleEvent {\n    return {\n        eventId: bare.readString(bc),\n        timestamp: bare.readU64(bc),\n        kind: readPersistedScheduleEventKind(bc),\n    }\n}\n\nexport function writePersistedScheduleEvent(bc: bare.ByteCursor, x: PersistedScheduleEvent): void {\n    bare.writeString(bc, x.eventId)\n    bare.writeU64(bc, x.timestamp)\n    writePersistedScheduleEventKind(bc, x.kind)\n}\n\nfunction read2(bc: bare.ByteCursor): readonly PersistedConnection[] {\n    const len = bare.readUintSafe(bc)\n    if (len === 0) { return [] }\n    const result = [readPersistedConnection(bc)]\n    for (let i = 1; i < len; i++) {\n        result[i] = readPersistedConnection(bc)\n    }\n    return result\n}\n\nfunction write2(bc: bare.ByteCursor, x: readonly PersistedConnection[]): void {\n    bare.writeUintSafe(bc, x.length)\n    for (let i = 0; i < x.length; i++) {\n        writePersistedConnection(bc, x[i])\n    }\n}\n\nfunction read3(bc: bare.ByteCursor): readonly PersistedScheduleEvent[] {\n    const len = bare.readUintSafe(bc)\n    if (len === 0) { return [] }\n    const result = [readPersistedScheduleEvent(bc)]\n    for (let i = 1; i < len; i++) {\n        result[i] = readPersistedScheduleEvent(bc)\n    }\n    return result\n}\n\nfunction write3(bc: bare.ByteCursor, x: readonly PersistedScheduleEvent[]): void {\n    bare.writeUintSafe(bc, x.length)\n    for (let i = 0; i < x.length; i++) {\n        writePersistedScheduleEvent(bc, x[i])\n    }\n}\n\nexport type PersistedActor = {\n    readonly input: ArrayBuffer | null,\n    readonly hasInitialized: boolean,\n    readonly state: ArrayBuffer,\n    readonly connections: readonly PersistedConnection[],\n    readonly scheduledEvents: readonly PersistedScheduleEvent[],\n}\n\nexport function readPersistedActor(bc: bare.ByteCursor): PersistedActor {\n    return {\n        input: read0(bc),\n        hasInitialized: bare.readBool(bc),\n        state: bare.readData(bc),\n        connections: read2(bc),\n        scheduledEvents: read3(bc),\n    }\n}\n\nexport function writePersistedActor(bc: bare.ByteCursor, x: PersistedActor): void {\n    write0(bc, x.input)\n    bare.writeBool(bc, x.hasInitialized)\n    bare.writeData(bc, x.state)\n    write2(bc, x.connections)\n    write3(bc, x.scheduledEvents)\n}\n\nexport function encodePersistedActor(x: PersistedActor): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writePersistedActor(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodePersistedActor(bytes: Uint8Array): PersistedActor {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readPersistedActor(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/actor-persist/versioned.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/actor-persist\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/schemas/actor-persist/versioned.ts\";import {\n\tcreateVersionedDataHandler,\n\ttype MigrationFn,\n} from \"@/common/versioned-data\";\nimport * as v1 from \"../../../dist/schemas/actor-persist/v1\";\n\nexport const CURRENT_VERSION = 1;\n\nexport type CurrentPersistedActor = v1.PersistedActor;\nexport type CurrentPersistedConnection = v1.PersistedConnection;\nexport type CurrentPersistedSubscription = v1.PersistedSubscription;\nexport type CurrentGenericPersistedScheduleEvent =\n\tv1.GenericPersistedScheduleEvent;\nexport type CurrentPersistedScheduleEventKind = v1.PersistedScheduleEventKind;\nexport type CurrentPersistedScheduleEvent = v1.PersistedScheduleEvent;\n\nconst migrations = new Map<number, MigrationFn<any, any>>();\n\nexport const PERSISTED_ACTOR_VERSIONED =\n\tcreateVersionedDataHandler<CurrentPersistedActor>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodePersistedActor(data),\n\t\tdeserializeVersion: (bytes) => v1.decodePersistedActor(bytes),\n\t});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/context.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/context.ts\";import type { ActorKey } from \"@/actor/mod\";\nimport type { Client } from \"@/client/client\";\nimport type { Logger } from \"@/common/log\";\nimport type { Registry } from \"@/registry/mod\";\nimport type { Conn, ConnId } from \"./connection\";\nimport type { AnyDatabaseProvider, InferDatabaseClient } from \"./database\";\nimport type { ActorInstance, SaveStateOptions } from \"./instance\";\nimport type { Schedule } from \"./schedule\";\n\n/**\n * ActorContext class that provides access to actor methods and state\n */\nexport class ActorContext<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n> {\n\t#actor: ActorInstance<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>;\n\n\tconstructor(\n\t\tactor: ActorInstance<\n\t\t\tTState,\n\t\t\tTConnParams,\n\t\t\tTConnState,\n\t\t\tTVars,\n\t\t\tTInput,\n\t\t\tTAuthData,\n\t\t\tTDatabase\n\t\t>,\n\t) {\n\t\tthis.#actor = actor;\n\t}\n\n\t/**\n\t * Get the actor state\n\t */\n\tget state(): TState {\n\t\treturn this.#actor.state;\n\t}\n\n\t/**\n\t * Get the actor variables\n\t */\n\tget vars(): TVars {\n\t\treturn this.#actor.vars;\n\t}\n\n\t/**\n\t * Broadcasts an event to all connected clients.\n\t * @param name - The name of the event.\n\t * @param args - The arguments to send with the event.\n\t */\n\tbroadcast<Args extends Array<unknown>>(name: string, ...args: Args): void {\n\t\tthis.#actor._broadcast(name, ...args);\n\t\treturn;\n\t}\n\n\t/**\n\t * Gets the logger instance.\n\t */\n\tget log(): Logger {\n\t\treturn this.#actor.log;\n\t}\n\n\t/**\n\t * Gets actor ID.\n\t */\n\tget actorId(): string {\n\t\treturn this.#actor.id;\n\t}\n\n\t/**\n\t * Gets the actor name.\n\t */\n\tget name(): string {\n\t\treturn this.#actor.name;\n\t}\n\n\t/**\n\t * Gets the actor key.\n\t */\n\tget key(): ActorKey {\n\t\treturn this.#actor.key;\n\t}\n\n\t/**\n\t * Gets the region.\n\t */\n\tget region(): string {\n\t\treturn this.#actor.region;\n\t}\n\n\t/**\n\t * Gets the scheduler.\n\t */\n\tget schedule(): Schedule {\n\t\treturn this.#actor.schedule;\n\t}\n\n\t/**\n\t * Gets the map of connections.\n\t */\n\tget conns(): Map<\n\t\tConnId,\n\t\tConn<TState, TConnParams, TConnState, TVars, TInput, TAuthData, TDatabase>\n\t> {\n\t\treturn this.#actor.conns;\n\t}\n\n\t/**\n\t * Returns the client for the given registry.\n\t */\n\tclient<R extends Registry<any>>(): Client<R> {\n\t\treturn this.#actor.inlineClient as Client<R>;\n\t}\n\n\t/**\n\t * Gets the database.\n\t * @experimental\n\t * @throws {DatabaseNotEnabled} If the database is not enabled.\n\t */\n\tget db(): InferDatabaseClient<TDatabase> {\n\t\treturn this.#actor.db;\n\t}\n\n\t/**\n\t * Forces the state to get saved.\n\t *\n\t * @param opts - Options for saving the state.\n\t */\n\tasync saveState(opts: SaveStateOptions): Promise<void> {\n\t\treturn this.#actor.saveState(opts);\n\t}\n\n\t/**\n\t * Prevents the actor from sleeping until promise is complete.\n\t */\n\twaitUntil(promise: Promise<void>): void {\n\t\tthis.#actor._waitUntil(promise);\n\t}\n\n\t/**\n\t * AbortSignal that fires when the actor is stopping.\n\t */\n\tget abortSignal(): AbortSignal {\n\t\treturn this.#actor.abortSignal;\n\t}\n\n\t/**\n\t * Forces the actor to sleep.\n\t *\n\t * Not supported on all drivers.\n\t *\n\t * @experimental\n\t */\n\tsleep() {\n\t\tthis.#actor._sleep();\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/schedule.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/schedule.ts\";import type { AnyActorInstance } from \"./instance\";\n\nexport class Schedule {\n\t#actor: AnyActorInstance;\n\n\tconstructor(actor: AnyActorInstance) {\n\t\tthis.#actor = actor;\n\t}\n\n\tasync after(duration: number, fn: string, ...args: unknown[]) {\n\t\tawait this.#actor.scheduleEvent(Date.now() + duration, fn, args);\n\t}\n\n\tasync at(timestamp: number, fn: string, ...args: unknown[]) {\n\t\tawait this.#actor.scheduleEvent(timestamp, fn, args);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/definition.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/definition.ts\";import type { RegistryConfig } from \"@/registry/config\";\nimport type { ActionContext } from \"./action\";\nimport type { Actions, ActorConfig } from \"./config\";\nimport type { ActorContext } from \"./context\";\nimport type { AnyDatabaseProvider } from \"./database\";\nimport { ActorInstance } from \"./instance\";\n\nexport type AnyActorDefinition = ActorDefinition<\n\tany,\n\tany,\n\tany,\n\tany,\n\tany,\n\tany,\n\tany,\n\tany\n>;\n\n/**\n * Extracts the context type from an ActorDefinition\n */\nexport type ActorContextOf<AD extends AnyActorDefinition> =\n\tAD extends ActorDefinition<\n\t\tinfer S,\n\t\tinfer CP,\n\t\tinfer CS,\n\t\tinfer V,\n\t\tinfer I,\n\t\tinfer AD,\n\t\tinfer DB,\n\t\tany\n\t>\n\t\t? ActorContext<S, CP, CS, V, I, AD, DB>\n\t\t: never;\n\n/**\n * Extracts the context type from an ActorDefinition\n */\nexport type ActionContextOf<AD extends AnyActorDefinition> =\n\tAD extends ActorDefinition<\n\t\tinfer S,\n\t\tinfer CP,\n\t\tinfer CS,\n\t\tinfer V,\n\t\tinfer I,\n\t\tinfer AD,\n\t\tinfer DB,\n\t\tany\n\t>\n\t\t? ActionContext<S, CP, CS, V, I, AD, DB>\n\t\t: never;\n\nexport class ActorDefinition<\n\tS,\n\tCP,\n\tCS,\n\tV,\n\tI,\n\tAD,\n\tDB extends AnyDatabaseProvider,\n\tR extends Actions<S, CP, CS, V, I, AD, DB>,\n> {\n\t#config: ActorConfig<S, CP, CS, V, I, AD, DB>;\n\n\tconstructor(config: ActorConfig<S, CP, CS, V, I, AD, DB>) {\n\t\tthis.#config = config;\n\t}\n\n\tget config(): ActorConfig<S, CP, CS, V, I, AD, DB> {\n\t\treturn this.#config;\n\t}\n\n\tinstantiate(): ActorInstance<S, CP, CS, V, I, AD, DB> {\n\t\treturn new ActorInstance(this.#config);\n\t}\n}\n\nexport function lookupInRegistry(\n\tregistryConfig: RegistryConfig,\n\tname: string,\n): AnyActorDefinition {\n\t// Build actor\n\tconst definition = registryConfig.use[name];\n\tif (!definition) throw new Error(`no actor in registry for name ${name}`);\n\treturn definition;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/generic-conn-driver.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/generic-conn-driver.ts\";import type { SSEStreamingApi } from \"hono/streaming\";\nimport type { WSContext } from \"hono/ws\";\nimport type { WebSocket } from \"ws\";\nimport {\n\ttype AnyConn,\n\tCONNECTION_DRIVER_HTTP,\n\tCONNECTION_DRIVER_SSE,\n\tCONNECTION_DRIVER_WEBSOCKET,\n} from \"@/actor/connection\";\nimport {\n\ttype ConnDriver,\n\ttype ConnectionDriversMap,\n\tConnectionReadyState,\n} from \"@/actor/driver\";\nimport type { AnyActorInstance } from \"@/actor/instance\";\nimport type { CachedSerializer, Encoding } from \"@/actor/protocol/serde\";\nimport { encodeDataToString } from \"@/actor/protocol/serde\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport { logger } from \"./log\";\n\n// This state is different than `PersistedConn` state since the connection-specific state is persisted & must be serializable. This is also part of the connection driver, not part of the core actor.\n//\n// This holds the actual connections, which are not serializable.\n//\n// This is scoped to each actor. Do not share between multiple actors.\nexport class GenericConnGlobalState {\n\twebsockets = new Map<string, WSContext>();\n\tsseStreams = new Map<string, SSEStreamingApi>();\n}\n\n/**\n * Exposes connection drivers for platforms that support vanilla WebSocket, SSE, and HTTP.\n */\nexport function createGenericConnDrivers(\n\tglobalState: GenericConnGlobalState,\n): ConnectionDriversMap {\n\treturn {\n\t\t[CONNECTION_DRIVER_WEBSOCKET]: createGenericWebSocketDriver(globalState),\n\t\t[CONNECTION_DRIVER_SSE]: createGenericSseDriver(globalState),\n\t\t[CONNECTION_DRIVER_HTTP]: createGenericHttpDriver(),\n\t};\n}\n\n// MARK: WebSocket\nexport interface GenericWebSocketDriverState {\n\tencoding: Encoding;\n}\n\nexport function createGenericWebSocketDriver(\n\tglobalState: GenericConnGlobalState,\n): ConnDriver<GenericWebSocketDriverState> {\n\treturn {\n\t\tsendMessage: (\n\t\t\tactor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t\tstate: GenericWebSocketDriverState,\n\t\t\tmessage: CachedSerializer<protocol.ToClient>,\n\t\t) => {\n\t\t\tconst ws = globalState.websockets.get(conn.id);\n\t\t\tif (!ws) {\n\t\t\t\tlogger().warn(\"missing ws for sendMessage\", {\n\t\t\t\t\tactorId: actor.id,\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t\ttotalCount: globalState.websockets.size,\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tconst serialized = message.serialize(state.encoding);\n\n\t\t\tlogger().debug(\"sending websocket message\", {\n\t\t\t\tencoding: state.encoding,\n\t\t\t\tdataType: typeof serialized,\n\t\t\t\tisUint8Array: serialized instanceof Uint8Array,\n\t\t\t\tisArrayBuffer: serialized instanceof ArrayBuffer,\n\t\t\t\tdataLength:\n\t\t\t\t\t(serialized as any).byteLength || (serialized as any).length,\n\t\t\t});\n\n\t\t\t// Convert Uint8Array to ArrayBuffer for proper transmission\n\t\t\tif (serialized instanceof Uint8Array) {\n\t\t\t\tconst buffer = serialized.buffer.slice(\n\t\t\t\t\tserialized.byteOffset,\n\t\t\t\t\tserialized.byteOffset + serialized.byteLength,\n\t\t\t\t);\n\t\t\t\t// Handle SharedArrayBuffer case\n\t\t\t\tif (buffer instanceof SharedArrayBuffer) {\n\t\t\t\t\tconst arrayBuffer = new ArrayBuffer(buffer.byteLength);\n\t\t\t\t\tnew Uint8Array(arrayBuffer).set(new Uint8Array(buffer));\n\t\t\t\t\tlogger().debug(\"converted SharedArrayBuffer to ArrayBuffer\", {\n\t\t\t\t\t\tbyteLength: arrayBuffer.byteLength,\n\t\t\t\t\t});\n\t\t\t\t\tws.send(arrayBuffer);\n\t\t\t\t} else {\n\t\t\t\t\tlogger().debug(\"sending ArrayBuffer\", {\n\t\t\t\t\t\tbyteLength: buffer.byteLength,\n\t\t\t\t\t});\n\t\t\t\t\tws.send(buffer);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tlogger().debug(\"sending string data\", {\n\t\t\t\t\tlength: (serialized as string).length,\n\t\t\t\t});\n\t\t\t\tws.send(serialized);\n\t\t\t}\n\t\t},\n\n\t\tdisconnect: async (\n\t\t\tactor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t\t_state: GenericWebSocketDriverState,\n\t\t\treason?: string,\n\t\t) => {\n\t\t\tconst ws = globalState.websockets.get(conn.id);\n\t\t\tif (!ws) {\n\t\t\t\tlogger().warn(\"missing ws for disconnect\", {\n\t\t\t\t\tactorId: actor.id,\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t\ttotalCount: globalState.websockets.size,\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tconst raw = ws.raw as WebSocket;\n\t\t\tif (!raw) {\n\t\t\t\tlogger().warn(\"ws.raw does not exist\");\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Create promise to wait for socket to close gracefully\n\t\t\tconst { promise, resolve } = Promise.withResolvers<void>();\n\t\t\traw.addEventListener(\"close\", () => resolve());\n\n\t\t\t// Close socket\n\t\t\tws.close(1000, reason);\n\n\t\t\tawait promise;\n\t\t},\n\n\t\tgetConnectionReadyState: (\n\t\t\t_actor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t): ConnectionReadyState | undefined => {\n\t\t\tconst ws = globalState.websockets.get(conn.id);\n\t\t\tif (!ws) {\n\t\t\t\tlogger().warn(\"missing ws for getConnectionReadyState\", {\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\tconst raw = ws.raw as WebSocket;\n\n\t\t\treturn raw.readyState as ConnectionReadyState;\n\t\t},\n\t};\n}\n\n// MARK: SSE\nexport interface GenericSseDriverState {\n\tencoding: Encoding;\n}\n\nexport function createGenericSseDriver(\n\tglobalState: GenericConnGlobalState,\n): ConnDriver<GenericSseDriverState> {\n\treturn {\n\t\tsendMessage: (\n\t\t\t_actor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t\tstate: GenericSseDriverState,\n\t\t\tmessage: CachedSerializer<protocol.ToClient>,\n\t\t) => {\n\t\t\tconst stream = globalState.sseStreams.get(conn.id);\n\t\t\tif (!stream) {\n\t\t\t\tlogger().warn(\"missing sse stream for sendMessage\", {\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tstream.writeSSE({\n\t\t\t\tdata: encodeDataToString(message.serialize(state.encoding)),\n\t\t\t});\n\t\t},\n\n\t\tdisconnect: async (\n\t\t\t_actor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t\t_state: GenericSseDriverState,\n\t\t\t_reason?: string,\n\t\t) => {\n\t\t\tconst stream = globalState.sseStreams.get(conn.id);\n\t\t\tif (!stream) {\n\t\t\t\tlogger().warn(\"missing sse stream for disconnect\", { connId: conn.id });\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\tstream.close();\n\t\t},\n\n\t\tgetConnectionReadyState: (\n\t\t\t_actor: AnyActorInstance,\n\t\t\tconn: AnyConn,\n\t\t): ConnectionReadyState | undefined => {\n\t\t\tconst stream = globalState.sseStreams.get(conn.id);\n\t\t\tif (!stream) {\n\t\t\t\tlogger().warn(\"missing sse stream for getConnectionReadyState\", {\n\t\t\t\t\tconnId: conn.id,\n\t\t\t\t});\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\tif (stream.aborted || stream.closed) {\n\t\t\t\treturn ConnectionReadyState.CLOSED;\n\t\t\t}\n\n\t\t\treturn ConnectionReadyState.OPEN;\n\t\t},\n\t};\n}\n\n// MARK: HTTP\nexport type GenericHttpDriverState = Record<never, never>;\n\nexport function createGenericHttpDriver(): ConnDriver<GenericHttpDriverState> {\n\treturn {\n\t\tgetConnectionReadyState(_actor, _conn) {\n\t\t\t// TODO: This might not be the correct logic\n\t\t\treturn ConnectionReadyState.OPEN;\n\t\t},\n\t\tdisconnect: async () => {\n\t\t\t// Noop\n\t\t},\n\t};\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/router.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/router.ts\";import { Hono, type Context as HonoContext } from \"hono\";\nimport invariant from \"invariant\";\nimport { EncodingSchema } from \"@/actor/protocol/serde\";\nimport {\n\ttype ActionOpts,\n\ttype ActionOutput,\n\ttype ConnectSseOpts,\n\ttype ConnectSseOutput,\n\ttype ConnectWebSocketOpts,\n\ttype ConnectWebSocketOutput,\n\ttype ConnsMessageOpts,\n\tHEADER_AUTH_DATA,\n\tHEADER_CONN_ID,\n\tHEADER_CONN_PARAMS,\n\tHEADER_CONN_TOKEN,\n\tHEADER_ENCODING,\n\thandleAction,\n\thandleConnectionMessage,\n\thandleRawWebSocketHandler,\n\thandleSseConnect,\n\thandleWebSocketConnect,\n} from \"@/actor/router-endpoints\";\nimport {\n\thandleRouteError,\n\thandleRouteNotFound,\n\tloggerMiddleware,\n} from \"@/common/router\";\nimport { noopNext } from \"@/common/utils\";\nimport {\n\ttype ActorInspectorRouterEnv,\n\tcreateActorInspectorRouter,\n} from \"@/inspector/actor\";\nimport { secureInspector } from \"@/inspector/utils\";\nimport type { RunConfig } from \"@/registry/run-config\";\nimport type { ActorDriver } from \"./driver\";\nimport { InternalError } from \"./errors\";\nimport { logger } from \"./log\";\n\nexport const PATH_CONNECT_WEBSOCKET = \"/connect/websocket\";\nexport const PATH_RAW_WEBSOCKET_PREFIX = \"/raw/websocket/\";\n\nexport type {\n\tConnectWebSocketOpts,\n\tConnectWebSocketOutput,\n\tConnectSseOpts,\n\tConnectSseOutput,\n\tActionOpts,\n\tActionOutput,\n\tConnsMessageOpts,\n};\n\ninterface ActorRouterBindings {\n\tactorId: string;\n}\n\nexport type ActorRouter = Hono<{ Bindings: ActorRouterBindings }>;\n\n/**\n * Creates a router that runs on the partitioned instance.\n */\nexport function createActorRouter(\n\trunConfig: RunConfig,\n\tactorDriver: ActorDriver,\n): ActorRouter {\n\tconst router = new Hono<{ Bindings: ActorRouterBindings }>({ strict: false });\n\n\trouter.use(\"*\", loggerMiddleware(logger()));\n\n\trouter.get(\"/\", (c) => {\n\t\treturn c.text(\n\t\t\t\"This is an RivetKit actor.\\n\\nLearn more at https://rivetkit.org\",\n\t\t);\n\t});\n\n\trouter.get(\"/health\", (c) => {\n\t\treturn c.text(\"ok\");\n\t});\n\n\trouter.get(PATH_CONNECT_WEBSOCKET, async (c) => {\n\t\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\t\tif (upgradeWebSocket) {\n\t\t\treturn upgradeWebSocket(async (c) => {\n\t\t\t\tconst encodingRaw = c.req.header(HEADER_ENCODING);\n\t\t\t\tconst connParamsRaw = c.req.header(HEADER_CONN_PARAMS);\n\t\t\t\tconst authDataRaw = c.req.header(HEADER_AUTH_DATA);\n\n\t\t\t\tconst encoding = EncodingSchema.parse(encodingRaw);\n\t\t\t\tconst connParams = connParamsRaw\n\t\t\t\t\t? JSON.parse(connParamsRaw)\n\t\t\t\t\t: undefined;\n\t\t\t\tconst authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;\n\n\t\t\t\treturn await handleWebSocketConnect(\n\t\t\t\t\tc.req.raw,\n\t\t\t\t\trunConfig,\n\t\t\t\t\tactorDriver,\n\t\t\t\t\tc.env.actorId,\n\t\t\t\t\tencoding,\n\t\t\t\t\tconnParams,\n\t\t\t\t\tauthData,\n\t\t\t\t);\n\t\t\t})(c, noopNext());\n\t\t} else {\n\t\t\treturn c.text(\n\t\t\t\t\"WebSockets are not enabled for this driver. Use SSE instead.\",\n\t\t\t\t400,\n\t\t\t);\n\t\t}\n\t});\n\n\trouter.get(\"/connect/sse\", async (c) => {\n\t\tconst authDataRaw = c.req.header(HEADER_AUTH_DATA);\n\t\tlet authData: unknown;\n\t\tif (authDataRaw) {\n\t\t\tauthData = JSON.parse(authDataRaw);\n\t\t}\n\n\t\treturn handleSseConnect(c, runConfig, actorDriver, c.env.actorId, authData);\n\t});\n\n\trouter.post(\"/action/:action\", async (c) => {\n\t\tconst actionName = c.req.param(\"action\");\n\n\t\tconst authDataRaw = c.req.header(HEADER_AUTH_DATA);\n\t\tlet authData: unknown;\n\t\tif (authDataRaw) {\n\t\t\tauthData = JSON.parse(authDataRaw);\n\t\t}\n\n\t\treturn handleAction(\n\t\t\tc,\n\t\t\trunConfig,\n\t\t\tactorDriver,\n\t\t\tactionName,\n\t\t\tc.env.actorId,\n\t\t\tauthData,\n\t\t);\n\t});\n\n\trouter.post(\"/connections/message\", async (c) => {\n\t\tconst connId = c.req.header(HEADER_CONN_ID);\n\t\tconst connToken = c.req.header(HEADER_CONN_TOKEN);\n\t\tif (!connId || !connToken) {\n\t\t\tthrow new Error(\"Missing required parameters\");\n\t\t}\n\t\treturn handleConnectionMessage(\n\t\t\tc,\n\t\t\trunConfig,\n\t\t\tactorDriver,\n\t\t\tconnId,\n\t\t\tconnToken,\n\t\t\tc.env.actorId,\n\t\t);\n\t});\n\n\t// Raw HTTP endpoints - /http/*\n\trouter.all(\"/raw/http/*\", async (c) => {\n\t\tconst authDataRaw = c.req.header(HEADER_AUTH_DATA);\n\t\tlet authData: unknown;\n\t\tif (authDataRaw) {\n\t\t\tauthData = JSON.parse(authDataRaw);\n\t\t}\n\n\t\tconst actor = await actorDriver.loadActor(c.env.actorId);\n\n\t\t// TODO: This is not a clean way of doing this since `/http/` might exist mid-path\n\t\t// Strip the /http prefix from the URL to get the original path\n\t\tconst url = new URL(c.req.url);\n\t\tconst originalPath = url.pathname.replace(/^\\/raw\\/http/, \"\") || \"/\";\n\n\t\t// Create a new request with the corrected URL\n\t\tconst correctedUrl = new URL(originalPath + url.search, url.origin);\n\t\tconst correctedRequest = new Request(correctedUrl, {\n\t\t\tmethod: c.req.method,\n\t\t\theaders: c.req.raw.headers,\n\t\t\tbody: c.req.raw.body,\n\t\t});\n\n\t\tlogger().debug(\"rewriting http url\", {\n\t\t\tfrom: c.req.url,\n\t\t\tto: correctedRequest.url,\n\t\t});\n\n\t\t// Call the actor's onFetch handler - it will throw appropriate errors\n\t\tconst response = await actor.handleFetch(correctedRequest, {\n\t\t\tauth: authData,\n\t\t});\n\n\t\t// This should never happen now since handleFetch throws errors\n\t\tif (!response) {\n\t\t\tthrow new InternalError(\"handleFetch returned void unexpectedly\");\n\t\t}\n\n\t\treturn response;\n\t});\n\n\t// Raw WebSocket endpoint - /websocket/*\n\trouter.get(`${PATH_RAW_WEBSOCKET_PREFIX}*`, async (c) => {\n\t\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\t\tif (upgradeWebSocket) {\n\t\t\treturn upgradeWebSocket(async (c) => {\n\t\t\t\tconst encodingRaw = c.req.header(HEADER_ENCODING);\n\t\t\t\tconst connParamsRaw = c.req.header(HEADER_CONN_PARAMS);\n\t\t\t\tconst authDataRaw = c.req.header(HEADER_AUTH_DATA);\n\n\t\t\t\tconst encoding = EncodingSchema.parse(encodingRaw);\n\t\t\t\tconst connParams = connParamsRaw\n\t\t\t\t\t? JSON.parse(connParamsRaw)\n\t\t\t\t\t: undefined;\n\t\t\t\tconst authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;\n\n\t\t\t\tconst url = new URL(c.req.url);\n\t\t\t\tconst pathWithQuery = c.req.path + url.search;\n\n\t\t\t\tlogger().debug(\"actor router raw websocket\", {\n\t\t\t\t\tpath: c.req.path,\n\t\t\t\t\turl: c.req.url,\n\t\t\t\t\tsearch: url.search,\n\t\t\t\t\tpathWithQuery,\n\t\t\t\t});\n\n\t\t\t\treturn await handleRawWebSocketHandler(\n\t\t\t\t\tc.req.raw,\n\t\t\t\t\tpathWithQuery,\n\t\t\t\t\tactorDriver,\n\t\t\t\t\tc.env.actorId,\n\t\t\t\t\tauthData,\n\t\t\t\t);\n\t\t\t})(c, noopNext());\n\t\t} else {\n\t\t\treturn c.text(\n\t\t\t\t\"WebSockets are not enabled for this driver. Use SSE instead.\",\n\t\t\t\t400,\n\t\t\t);\n\t\t}\n\t});\n\n\tif (runConfig.inspector.enabled) {\n\t\trouter.route(\n\t\t\t\"/inspect\",\n\t\t\tnew Hono<ActorInspectorRouterEnv & { Bindings: ActorRouterBindings }>()\n\t\t\t\t.use(secureInspector(runConfig), async (c, next) => {\n\t\t\t\t\tconst inspector = (await actorDriver.loadActor(c.env.actorId))\n\t\t\t\t\t\t.inspector;\n\t\t\t\t\tinvariant(inspector, \"inspector not supported on this platform\");\n\n\t\t\t\t\tc.set(\"inspector\", inspector);\n\t\t\t\t\tawait next();\n\t\t\t\t})\n\t\t\t\t.route(\"/\", createActorInspectorRouter()),\n\t\t);\n\t}\n\n\trouter.notFound(handleRouteNotFound);\n\trouter.onError(\n\t\thandleRouteError.bind(undefined, {\n\t\t\t// All headers to this endpoint are considered secure, so we can enable the expose internal error header for requests from the internal client\n\t\t\tenableExposeInternalError: true,\n\t\t}),\n\t);\n\n\treturn router;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/router.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/router.ts\";import * as cbor from \"cbor-x\";\nimport type { Context as HonoContext, Next } from \"hono\";\nimport type { Encoding } from \"@/actor/protocol/serde\";\nimport {\n\tgetRequestEncoding,\n\tgetRequestExposeInternalError,\n} from \"@/actor/router-endpoints\";\nimport { HttpResponseError } from \"@/schemas/client-protocol/mod\";\nimport { HTTP_RESPONSE_ERROR_VERSIONED } from \"@/schemas/client-protocol/versioned\";\nimport { serializeWithEncoding } from \"@/serde\";\nimport { bufferToArrayBuffer } from \"@/utils\";\nimport { getLogger, type Logger } from \"./log\";\nimport { deconstructError, stringifyError } from \"./utils\";\n\nexport function logger() {\n\treturn getLogger(\"router\");\n}\n\nexport function loggerMiddleware(logger: Logger) {\n\treturn async (c: HonoContext, next: Next) => {\n\t\tconst method = c.req.method;\n\t\tconst path = c.req.path;\n\t\tconst startTime = Date.now();\n\n\t\tawait next();\n\n\t\tconst duration = Date.now() - startTime;\n\t\tlogger.debug(\"http request\", {\n\t\t\tmethod,\n\t\t\tpath,\n\t\t\tstatus: c.res.status,\n\t\t\tdt: `${duration}ms`,\n\t\t\treqSize: c.req.header(\"content-length\"),\n\t\t\tresSize: c.res.headers.get(\"content-length\"),\n\t\t\tuserAgent: c.req.header(\"user-agent\"),\n\t\t});\n\t};\n}\n\nexport function handleRouteNotFound(c: HonoContext) {\n\treturn c.text(\"Not Found (RivetKit)\", 404);\n}\n\nexport interface HandleRouterErrorOpts {\n\tenableExposeInternalError?: boolean;\n}\n\nexport function handleRouteError(\n\topts: HandleRouterErrorOpts,\n\terror: unknown,\n\tc: HonoContext,\n) {\n\tconst exposeInternalError =\n\t\topts.enableExposeInternalError && getRequestExposeInternalError(c.req.raw);\n\n\tconst { statusCode, code, message, metadata } = deconstructError(\n\t\terror,\n\t\tlogger(),\n\t\t{\n\t\t\tmethod: c.req.method,\n\t\t\tpath: c.req.path,\n\t\t},\n\t\texposeInternalError,\n\t);\n\n\tlet encoding: Encoding;\n\ttry {\n\t\tencoding = getRequestEncoding(c.req);\n\t} catch (err) {\n\t\tlogger().debug(\"failed to extract encoding\", {\n\t\t\terror: stringifyError(err),\n\t\t});\n\t\tencoding = \"json\";\n\t}\n\n\tconst output = serializeWithEncoding(\n\t\tencoding,\n\t\t{\n\t\t\tcode,\n\t\t\tmessage,\n\t\t\tmetadata: bufferToArrayBuffer(cbor.encode(metadata)),\n\t\t},\n\t\tHTTP_RESPONSE_ERROR_VERSIONED,\n\t);\n\n\treturn c.body(output, { status: statusCode });\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/utils.ts\";import crypto from \"node:crypto\";\nimport { createMiddleware } from \"hono/factory\";\nimport type { RunConfig } from \"@/mod\";\nimport type { RunConfigInput } from \"@/registry/run-config\";\nimport { inspectorLogger } from \"./log\";\n\nexport function compareSecrets(providedSecret: string, validSecret: string) {\n\t// Early length check to avoid unnecessary processing\n\tif (providedSecret.length !== validSecret.length) {\n\t\treturn false;\n\t}\n\n\tconst encoder = new TextEncoder();\n\n\tconst a = encoder.encode(providedSecret);\n\tconst b = encoder.encode(validSecret);\n\n\tif (a.byteLength !== b.byteLength) {\n\t\treturn false;\n\t}\n\n\t// Perform timing-safe comparison\n\tif (!crypto.timingSafeEqual(a, b)) {\n\t\treturn false;\n\t}\n\treturn true;\n}\n\nexport const secureInspector = (runConfig: RunConfig) =>\n\tcreateMiddleware(async (c, next) => {\n\t\tif (!runConfig.inspector.enabled) {\n\t\t\treturn c.text(\"Inspector is not enabled\", 503);\n\t\t}\n\n\t\tconst userToken = c.req.header(\"Authorization\")?.replace(\"Bearer \", \"\");\n\t\tif (!userToken) {\n\t\t\treturn c.text(\"Unauthorized\", 401);\n\t\t}\n\n\t\tconst inspectorToken = runConfig.inspector.token?.();\n\t\tif (!inspectorToken) {\n\t\t\treturn c.text(\"Unauthorized\", 401);\n\t\t}\n\n\t\tconst isValid = compareSecrets(userToken, inspectorToken);\n\n\t\tif (!isValid) {\n\t\t\treturn c.text(\"Unauthorized\", 401);\n\t\t}\n\t\tawait next();\n\t});\n\nexport function getInspectorUrl(runConfig: RunConfigInput | undefined) {\n\tif (!runConfig?.inspector?.enabled) {\n\t\treturn \"disabled\";\n\t}\n\n\tconst accessToken = runConfig?.inspector?.token?.();\n\n\tif (!accessToken) {\n\t\tinspectorLogger().warn(\n\t\t\t\"Inspector Token is not set, but Inspector is enabled. Please set it in the run configuration `inspector.token` or via `RIVETKIT_INSPECTOR_TOKEN` environment variable. Inspector will not be accessible.\",\n\t\t);\n\t\treturn \"disabled\";\n\t}\n\n\tconst url = new URL(\"https://studio.rivet.gg\");\n\n\turl.searchParams.set(\"t\", accessToken);\n\n\tif (runConfig?.inspector?.defaultEndpoint) {\n\t\turl.searchParams.set(\"u\", runConfig.inspector.defaultEndpoint);\n\t}\n\n\treturn url.href;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/log.ts\";import { getLogger } from \"@/common//log\";\n\nexport function inspectorLogger() {\n\treturn getLogger(\"inspector\");\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor/mod.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/actor\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/actor/mod.ts\";import {\n\ttype Actions,\n\ttype ActorConfig,\n\ttype ActorConfigInput,\n\tActorConfigSchema,\n\tActorTypes,\n} from \"./config\";\nimport type { AnyDatabaseProvider } from \"./database\";\nimport { ActorDefinition } from \"./definition\";\n\nexport function actor<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase extends AnyDatabaseProvider,\n\tTActions extends Actions<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>,\n>(\n\tinput: ActorConfigInput<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase,\n\t\tTActions\n\t>,\n): ActorDefinition<\n\tTState,\n\tTConnParams,\n\tTConnState,\n\tTVars,\n\tTInput,\n\tTAuthData,\n\tTDatabase,\n\tTActions\n> {\n\tconst config = ActorConfigSchema.parse(input) as ActorConfig<\n\t\tTState,\n\t\tTConnParams,\n\t\tTConnState,\n\t\tTVars,\n\t\tTInput,\n\t\tTAuthData,\n\t\tTDatabase\n\t>;\n\treturn new ActorDefinition(config);\n}\nexport type { Encoding } from \"@/actor/protocol/serde\";\nexport type {\n\tUniversalErrorEvent,\n\tUniversalEvent,\n\tUniversalEventSource,\n\tUniversalMessageEvent,\n} from \"@/common/eventsource-interface\";\nexport type { UpgradeWebSocketArgs } from \"@/common/inline-websocket-adapter2\";\nexport type {\n\tRivetCloseEvent,\n\tRivetEvent,\n\tRivetMessageEvent,\n\tUniversalWebSocket,\n} from \"@/common/websocket-interface\";\nexport type { ActorKey } from \"@/manager/protocol/query\";\nexport type { ActionContext } from \"./action\";\nexport type * from \"./config\";\nexport type {\n\tConn,\n\tConnectionDriver,\n\tConnectionStatus,\n\tgenerateConnId,\n\tgenerateConnToken,\n} from \"./connection\";\nexport {\n\tCONNECTION_DRIVER_HTTP,\n\tCONNECTION_DRIVER_SSE,\n\tCONNECTION_DRIVER_WEBSOCKET,\n} from \"./connection\";\nexport type { ActorContext } from \"./context\";\nexport type {\n\tActionContextOf,\n\tActorContextOf,\n\tActorDefinition,\n\tAnyActorDefinition,\n} from \"./definition\";\nexport { lookupInRegistry } from \"./definition\";\nexport { UserError, type UserErrorOptions } from \"./errors\";\nexport {\n\tcreateGenericConnDrivers,\n\tGenericConnGlobalState,\n} from \"./generic-conn-driver\";\nexport type { AnyActorInstance } from \"./instance\";\nexport {\n\ttype ActorRouter,\n\tcreateActorRouter,\n\tPATH_CONNECT_WEBSOCKET,\n\tPATH_RAW_WEBSOCKET_PREFIX,\n} from \"./router\";\nexport {\n\tALLOWED_PUBLIC_HEADERS,\n\thandleRawWebSocketHandler,\n\thandleWebSocketConnect,\n} from \"./router-endpoints\";\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/actor-conn.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/actor-conn.ts\";import * as cbor from \"cbor-x\";\nimport invariant from \"invariant\";\nimport pRetry from \"p-retry\";\nimport type { CloseEvent, WebSocket } from \"ws\";\nimport type { AnyActorDefinition } from \"@/actor/definition\";\nimport { inputDataToBuffer } from \"@/actor/protocol/old\";\nimport { type Encoding, jsonStringifyCompat } from \"@/actor/protocol/serde\";\nimport type {\n\tUniversalErrorEvent,\n\tUniversalEventSource,\n\tUniversalMessageEvent,\n} from \"@/common/eventsource-interface\";\nimport { assertUnreachable, stringifyError } from \"@/common/utils\";\nimport type { ActorQuery } from \"@/manager/protocol/query\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport {\n\tTO_CLIENT_VERSIONED,\n\tTO_SERVER_VERSIONED,\n} from \"@/schemas/client-protocol/versioned\";\nimport {\n\tdeserializeWithEncoding,\n\tencodingIsBinary,\n\tserializeWithEncoding,\n} from \"@/serde\";\nimport { bufferToArrayBuffer, getEnvUniversal } from \"@/utils\";\nimport type { ActorDefinitionActions } from \"./actor-common\";\nimport {\n\tACTOR_CONNS_SYMBOL,\n\ttype ClientDriver,\n\ttype ClientRaw,\n\tTRANSPORT_SYMBOL,\n} from \"./client\";\nimport * as errors from \"./errors\";\nimport { logger } from \"./log\";\nimport { type WebSocketMessage as ConnMessage, messageLength } from \"./utils\";\n\ninterface ActionInFlight {\n\tname: string;\n\tresolve: (response: protocol.ActionResponse) => void;\n\treject: (error: Error) => void;\n}\n\ninterface EventSubscriptions<Args extends Array<unknown>> {\n\tcallback: (...args: Args) => void;\n\tonce: boolean;\n}\n\n/**\n * A function that unsubscribes from an event.\n *\n * @typedef {Function} EventUnsubscribe\n */\nexport type EventUnsubscribe = () => void;\n\n/**\n * A function that handles connection errors.\n *\n * @typedef {Function} ActorErrorCallback\n */\nexport type ActorErrorCallback = (error: errors.ActorError) => void;\n\nexport interface SendHttpMessageOpts {\n\tephemeral: boolean;\n\tsignal?: AbortSignal;\n}\n\nexport type ConnTransport =\n\t| { websocket: WebSocket }\n\t| { sse: UniversalEventSource };\n\nexport const CONNECT_SYMBOL = Symbol(\"connect\");\n\n/**\n * Provides underlying functions for {@link ActorConn}. See {@link ActorConn} for using type-safe remote procedure calls.\n *\n * @see {@link ActorConn}\n */\nexport class ActorConnRaw {\n\t#disposed = false;\n\n\t/* Will be aborted on dispose. */\n\t#abortController = new AbortController();\n\n\t/** If attempting to connect. Helpful for knowing if in a retry loop when reconnecting. */\n\t#connecting = false;\n\n\t// These will only be set on SSE driver\n\t#actorId?: string;\n\t#connectionId?: string;\n\t#connectionToken?: string;\n\n\t#transport?: ConnTransport;\n\n\t#messageQueue: protocol.ToServer[] = [];\n\t#actionsInFlight = new Map<number, ActionInFlight>();\n\n\t// biome-ignore lint/suspicious/noExplicitAny: Unknown subscription type\n\t#eventSubscriptions = new Map<string, Set<EventSubscriptions<any[]>>>();\n\n\t#errorHandlers = new Set<ActorErrorCallback>();\n\n\t#actionIdCounter = 0;\n\n\t/**\n\t * Interval that keeps the NodeJS process alive if this is the only thing running.\n\t *\n\t * See ttps://github.com/nodejs/node/issues/22088\n\t */\n\t#keepNodeAliveInterval: NodeJS.Timeout;\n\n\t/** Promise used to indicate the socket has connected successfully. This will be rejected if the connection fails. */\n\t#onOpenPromise?: PromiseWithResolvers<undefined>;\n\n\t#client: ClientRaw;\n\t#driver: ClientDriver;\n\t#params: unknown;\n\t#encodingKind: Encoding;\n\t#actorQuery: ActorQuery;\n\n\t// TODO: ws message queue\n\n\t/**\n\t * Do not call this directly.\n\t *\n\t * Creates an instance of ActorConnRaw.\n\t *\n\t * @protected\n\t */\n\tpublic constructor(\n\t\tclient: ClientRaw,\n\t\tdriver: ClientDriver,\n\t\tparams: unknown,\n\t\tencodingKind: Encoding,\n\t\tactorQuery: ActorQuery,\n\t) {\n\t\tthis.#client = client;\n\t\tthis.#driver = driver;\n\t\tthis.#params = params;\n\t\tthis.#encodingKind = encodingKind;\n\t\tthis.#actorQuery = actorQuery;\n\n\t\tthis.#keepNodeAliveInterval = setInterval(() => 60_000);\n\t}\n\n\t/**\n\t * Call a raw action connection. See {@link ActorConn} for type-safe action calls.\n\t *\n\t * @see {@link ActorConn}\n\t * @template Args - The type of arguments to pass to the action function.\n\t * @template Response - The type of the response returned by the action function.\n\t * @param {string} name - The name of the action function to call.\n\t * @param {...Args} args - The arguments to pass to the action function.\n\t * @returns {Promise<Response>} - A promise that resolves to the response of the action function.\n\t */\n\tasync action<\n\t\tArgs extends Array<unknown> = unknown[],\n\t\tResponse = unknown,\n\t>(opts: {\n\t\tname: string;\n\t\targs: Args;\n\t\tsignal?: AbortSignal;\n\t}): Promise<Response> {\n\t\tlogger().debug(\"action\", { name: opts.name, args: opts.args });\n\n\t\t// If we have an active connection, use the websockactionId\n\t\tconst actionId = this.#actionIdCounter;\n\t\tthis.#actionIdCounter += 1;\n\n\t\tconst { promise, resolve, reject } =\n\t\t\tPromise.withResolvers<protocol.ActionResponse>();\n\t\tthis.#actionsInFlight.set(actionId, { name: opts.name, resolve, reject });\n\n\t\tthis.#sendMessage({\n\t\t\tbody: {\n\t\t\t\ttag: \"ActionRequest\",\n\t\t\t\tval: {\n\t\t\t\t\tid: BigInt(actionId),\n\t\t\t\t\tname: opts.name,\n\t\t\t\t\targs: bufferToArrayBuffer(cbor.encode(opts.args)),\n\t\t\t\t},\n\t\t\t},\n\t\t} satisfies protocol.ToServer);\n\n\t\t// TODO: Throw error if disconnect is called\n\n\t\tconst { id: responseId, output } = await promise;\n\t\tif (responseId !== BigInt(actionId))\n\t\t\tthrow new Error(\n\t\t\t\t`Request ID ${actionId} does not match response ID ${responseId}`,\n\t\t\t);\n\n\t\treturn cbor.decode(new Uint8Array(output)) as Response;\n\t}\n\n\t/**\n\t * Do not call this directly.\nenc\n\t * Establishes a connection to the server using the specified endpoint & encoding & driver.\n\t *\n\t * @protected\n\t */\n\tpublic [CONNECT_SYMBOL]() {\n\t\tthis.#connectWithRetry();\n\t}\n\n\tasync #connectWithRetry() {\n\t\tthis.#connecting = true;\n\n\t\t// Attempt to reconnect indefinitely\n\t\ttry {\n\t\t\tawait pRetry(this.#connectAndWait.bind(this), {\n\t\t\t\tforever: true,\n\t\t\t\tminTimeout: 250,\n\t\t\t\tmaxTimeout: 30_000,\n\n\t\t\t\tonFailedAttempt: (error) => {\n\t\t\t\t\tlogger().warn(\"failed to reconnect\", {\n\t\t\t\t\t\tattempt: error.attemptNumber,\n\t\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t\t});\n\t\t\t\t},\n\n\t\t\t\t// Cancel retry if aborted\n\t\t\t\tsignal: this.#abortController.signal,\n\t\t\t});\n\t\t} catch (err) {\n\t\t\tif ((err as Error).name === \"AbortError\") {\n\t\t\t\t// Ignore abortions\n\t\t\t\tlogger().info(\"connection retry aborted\");\n\t\t\t\treturn;\n\t\t\t} else {\n\t\t\t\t// Unknown error\n\t\t\t\tthrow err;\n\t\t\t}\n\t\t}\n\n\t\tthis.#connecting = false;\n\t}\n\n\tasync #connectAndWait() {\n\t\ttry {\n\t\t\t// Create promise for open\n\t\t\tif (this.#onOpenPromise)\n\t\t\t\tthrow new Error(\"#onOpenPromise already defined\");\n\t\t\tthis.#onOpenPromise = Promise.withResolvers();\n\n\t\t\t// Connect transport\n\t\t\tif (this.#client[TRANSPORT_SYMBOL] === \"websocket\") {\n\t\t\t\tawait this.#connectWebSocket();\n\t\t\t} else if (this.#client[TRANSPORT_SYMBOL] === \"sse\") {\n\t\t\t\tawait this.#connectSse();\n\t\t\t} else {\n\t\t\t\tassertUnreachable(this.#client[TRANSPORT_SYMBOL]);\n\t\t\t}\n\n\t\t\t// Wait for result\n\t\t\tawait this.#onOpenPromise.promise;\n\t\t} finally {\n\t\t\tthis.#onOpenPromise = undefined;\n\t\t}\n\t}\n\n\tasync #connectWebSocket({ signal }: { signal?: AbortSignal } = {}) {\n\t\tconst ws = await this.#driver.connectWebSocket(\n\t\t\tundefined,\n\t\t\tthis.#actorQuery,\n\t\t\tthis.#encodingKind,\n\t\t\tthis.#params,\n\t\t\tsignal ? { signal } : undefined,\n\t\t);\n\t\tthis.#transport = { websocket: ws };\n\t\tws.addEventListener(\"open\", () => {\n\t\t\tlogger().debug(\"websocket open\");\n\t\t});\n\t\tws.addEventListener(\"message\", async (ev) => {\n\t\t\tthis.#handleOnMessage(ev.data);\n\t\t});\n\t\tws.addEventListener(\"close\", (ev) => {\n\t\t\tthis.#handleOnClose(ev);\n\t\t});\n\t\tws.addEventListener(\"error\", (_ev) => {\n\t\t\tthis.#handleOnError();\n\t\t});\n\t}\n\n\tasync #connectSse({ signal }: { signal?: AbortSignal } = {}) {\n\t\tconst eventSource = await this.#driver.connectSse(\n\t\t\tundefined,\n\t\t\tthis.#actorQuery,\n\t\t\tthis.#encodingKind,\n\t\t\tthis.#params,\n\t\t\tsignal ? { signal } : undefined,\n\t\t);\n\t\tthis.#transport = { sse: eventSource };\n\t\teventSource.onopen = () => {\n\t\t\tlogger().debug(\"eventsource open\");\n\t\t\t// #handleOnOpen is called on \"i\" event\n\t\t};\n\t\teventSource.onmessage = (ev: UniversalMessageEvent) => {\n\t\t\tthis.#handleOnMessage(ev.data);\n\t\t};\n\t\teventSource.onerror = (_ev: UniversalErrorEvent) => {\n\t\t\tif (eventSource.readyState === eventSource.CLOSED) {\n\t\t\t\t// This error indicates a close event\n\t\t\t\tthis.#handleOnClose(new Event(\"error\"));\n\t\t\t} else {\n\t\t\t\t// Log error since event source is still open\n\t\t\t\tthis.#handleOnError();\n\t\t\t}\n\t\t};\n\t}\n\n\t/** Called by the onopen event from drivers. */\n\t#handleOnOpen() {\n\t\tlogger().debug(\"socket open\", {\n\t\t\tmessageQueueLength: this.#messageQueue.length,\n\t\t});\n\n\t\t// Resolve open promise\n\t\tif (this.#onOpenPromise) {\n\t\t\tthis.#onOpenPromise.resolve(undefined);\n\t\t} else {\n\t\t\tlogger().warn(\"#onOpenPromise is undefined\");\n\t\t}\n\n\t\t// Resubscribe to all active events\n\t\tfor (const eventName of this.#eventSubscriptions.keys()) {\n\t\t\tthis.#sendSubscription(eventName, true);\n\t\t}\n\n\t\t// Flush queue\n\t\t//\n\t\t// If the message fails to send, the message will be re-queued\n\t\tconst queue = this.#messageQueue;\n\t\tthis.#messageQueue = [];\n\t\tfor (const msg of queue) {\n\t\t\tthis.#sendMessage(msg);\n\t\t}\n\t}\n\n\t/** Called by the onmessage event from drivers. */\n\tasync #handleOnMessage(data: any) {\n\t\tlogger().trace(\"received message\", {\n\t\t\tdataType: typeof data,\n\t\t\tisBlob: data instanceof Blob,\n\t\t\tisArrayBuffer: data instanceof ArrayBuffer,\n\t\t});\n\n\t\tconst response = await this.#parseMessage(data as ConnMessage);\n\t\tlogger().trace(\n\t\t\t\"parsed message\",\n\t\t\tgetEnvUniversal(\"_RIVETKIT_LOG_MESSAGE\")\n\t\t\t\t? {\n\t\t\t\t\t\tmessage: jsonStringifyCompat(response).substring(0, 100) + \"...\",\n\t\t\t\t\t}\n\t\t\t\t: {},\n\t\t);\n\n\t\tif (response.body.tag === \"Init\") {\n\t\t\t// This is only called for SSE\n\t\t\tthis.#actorId = response.body.val.actorId;\n\t\t\tthis.#connectionId = response.body.val.connectionId;\n\t\t\tthis.#connectionToken = response.body.val.connectionToken;\n\t\t\tlogger().trace(\"received init message\", {\n\t\t\t\tactorId: this.#actorId,\n\t\t\t\tconnectionId: this.#connectionId,\n\t\t\t});\n\t\t\tthis.#handleOnOpen();\n\t\t} else if (response.body.tag === \"Error\") {\n\t\t\t// Connection error\n\t\t\tconst { code, message, metadata, actionId } = response.body.val;\n\n\t\t\tif (actionId) {\n\t\t\t\tconst inFlight = this.#takeActionInFlight(Number(actionId));\n\n\t\t\t\tlogger().warn(\"action error\", {\n\t\t\t\t\tactionId: actionId,\n\t\t\t\t\tactionName: inFlight?.name,\n\t\t\t\t\tcode,\n\t\t\t\t\tmessage,\n\t\t\t\t\tmetadata,\n\t\t\t\t});\n\n\t\t\t\tinFlight.reject(new errors.ActorError(code, message, metadata));\n\t\t\t} else {\n\t\t\t\tlogger().warn(\"connection error\", {\n\t\t\t\t\tcode,\n\t\t\t\t\tmessage,\n\t\t\t\t\tmetadata,\n\t\t\t\t});\n\n\t\t\t\t// Create a connection error\n\t\t\t\tconst actorError = new errors.ActorError(code, message, metadata);\n\n\t\t\t\t// If we have an onOpenPromise, reject it with the error\n\t\t\t\tif (this.#onOpenPromise) {\n\t\t\t\t\tthis.#onOpenPromise.reject(actorError);\n\t\t\t\t}\n\n\t\t\t\t// Reject any in-flight requests\n\t\t\t\tfor (const [id, inFlight] of this.#actionsInFlight.entries()) {\n\t\t\t\t\tinFlight.reject(actorError);\n\t\t\t\t\tthis.#actionsInFlight.delete(id);\n\t\t\t\t}\n\n\t\t\t\t// Dispatch to error handler if registered\n\t\t\t\tthis.#dispatchActorError(actorError);\n\t\t\t}\n\t\t} else if (response.body.tag === \"ActionResponse\") {\n\t\t\t// Action response OK\n\t\t\tconst { id: actionId } = response.body.val;\n\t\t\tlogger().trace(\"received action response\", {\n\t\t\t\tactionId,\n\t\t\t});\n\n\t\t\tconst inFlight = this.#takeActionInFlight(Number(actionId));\n\t\t\tlogger().trace(\"resolving action promise\", {\n\t\t\t\tactionId,\n\t\t\t\tactionName: inFlight?.name,\n\t\t\t});\n\t\t\tinFlight.resolve(response.body.val);\n\t\t} else if (response.body.tag === \"Event\") {\n\t\t\tlogger().trace(\"received event\", { name: response.body.val.name });\n\t\t\tthis.#dispatchEvent(response.body.val);\n\t\t} else {\n\t\t\tassertUnreachable(response.body);\n\t\t}\n\t}\n\n\t/** Called by the onclose event from drivers. */\n\t#handleOnClose(event: Event | CloseEvent) {\n\t\t// TODO: Handle queue\n\t\t// TODO: Reconnect with backoff\n\n\t\t// Reject open promise\n\t\tif (this.#onOpenPromise) {\n\t\t\tthis.#onOpenPromise.reject(new Error(\"Closed\"));\n\t\t}\n\n\t\t// We can't use `event instanceof CloseEvent` because it's not defined in NodeJS\n\t\t//\n\t\t// These properties will be undefined\n\t\tconst closeEvent = event as CloseEvent;\n\t\tif (closeEvent.wasClean) {\n\t\t\tlogger().info(\"socket closed\", {\n\t\t\t\tcode: closeEvent.code,\n\t\t\t\treason: closeEvent.reason,\n\t\t\t\twasClean: closeEvent.wasClean,\n\t\t\t});\n\t\t} else {\n\t\t\tlogger().warn(\"socket closed\", {\n\t\t\t\tcode: closeEvent.code,\n\t\t\t\treason: closeEvent.reason,\n\t\t\t\twasClean: closeEvent.wasClean,\n\t\t\t});\n\t\t}\n\n\t\tthis.#transport = undefined;\n\n\t\t// Automatically reconnect. Skip if already attempting to connect.\n\t\tif (!this.#disposed && !this.#connecting) {\n\t\t\t// TODO: Fetch actor to check if it's destroyed\n\t\t\t// TODO: Add backoff for reconnect\n\t\t\t// TODO: Add a way of preserving connection ID for connection state\n\n\t\t\t// Attempt to connect again\n\t\t\tthis.#connectWithRetry();\n\t\t}\n\t}\n\n\t/** Called by the onerror event from drivers. */\n\t#handleOnError() {\n\t\tif (this.#disposed) return;\n\n\t\t// More detailed information will be logged in onclose\n\t\tlogger().warn(\"socket error\");\n\t}\n\n\t#takeActionInFlight(id: number): ActionInFlight {\n\t\tconst inFlight = this.#actionsInFlight.get(id);\n\t\tif (!inFlight) {\n\t\t\tthrow new errors.InternalError(`No in flight response for ${id}`);\n\t\t}\n\t\tthis.#actionsInFlight.delete(id);\n\t\treturn inFlight;\n\t}\n\n\t#dispatchEvent(event: protocol.Event) {\n\t\tconst { name, args: argsRaw } = event;\n\t\tconst args = cbor.decode(new Uint8Array(argsRaw));\n\n\t\tconst listeners = this.#eventSubscriptions.get(name);\n\t\tif (!listeners) return;\n\n\t\t// Create a new array to avoid issues with listeners being removed during iteration\n\t\tfor (const listener of [...listeners]) {\n\t\t\tlistener.callback(...args);\n\n\t\t\t// Remove if this was a one-time listener\n\t\t\tif (listener.once) {\n\t\t\t\tlisteners.delete(listener);\n\t\t\t}\n\t\t}\n\n\t\t// Clean up empty listener sets\n\t\tif (listeners.size === 0) {\n\t\t\tthis.#eventSubscriptions.delete(name);\n\t\t}\n\t}\n\n\t#dispatchActorError(error: errors.ActorError) {\n\t\t// Call all registered error handlers\n\t\tfor (const handler of [...this.#errorHandlers]) {\n\t\t\ttry {\n\t\t\t\thandler(error);\n\t\t\t} catch (err) {\n\t\t\t\tlogger().error(\"Error in connection error handler\", {\n\t\t\t\t\terror: stringifyError(err),\n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n\n\t#addEventSubscription<Args extends Array<unknown>>(\n\t\teventName: string,\n\t\tcallback: (...args: Args) => void,\n\t\tonce: boolean,\n\t): EventUnsubscribe {\n\t\tconst listener: EventSubscriptions<Args> = {\n\t\t\tcallback,\n\t\t\tonce,\n\t\t};\n\n\t\tlet subscriptionSet = this.#eventSubscriptions.get(eventName);\n\t\tif (subscriptionSet === undefined) {\n\t\t\tsubscriptionSet = new Set();\n\t\t\tthis.#eventSubscriptions.set(eventName, subscriptionSet);\n\t\t\tthis.#sendSubscription(eventName, true);\n\t\t}\n\t\tsubscriptionSet.add(listener);\n\n\t\t// Return unsubscribe function\n\t\treturn () => {\n\t\t\tconst listeners = this.#eventSubscriptions.get(eventName);\n\t\t\tif (listeners) {\n\t\t\t\tlisteners.delete(listener);\n\t\t\t\tif (listeners.size === 0) {\n\t\t\t\t\tthis.#eventSubscriptions.delete(eventName);\n\t\t\t\t\tthis.#sendSubscription(eventName, false);\n\t\t\t\t}\n\t\t\t}\n\t\t};\n\t}\n\n\t/**\n\t * Subscribes to an event that will happen repeatedly.\n\t *\n\t * @template Args - The type of arguments the event callback will receive.\n\t * @param {string} eventName - The name of the event to subscribe to.\n\t * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.\n\t * @returns {EventUnsubscribe} - A function to unsubscribe from the event.\n\t * @see {@link https://rivet.gg/docs/events|Events Documentation}\n\t */\n\ton<Args extends Array<unknown> = unknown[]>(\n\t\teventName: string,\n\t\tcallback: (...args: Args) => void,\n\t): EventUnsubscribe {\n\t\treturn this.#addEventSubscription<Args>(eventName, callback, false);\n\t}\n\n\t/**\n\t * Subscribes to an event that will be triggered only once.\n\t *\n\t * @template Args - The type of arguments the event callback will receive.\n\t * @param {string} eventName - The name of the event to subscribe to.\n\t * @param {(...args: Args) => void} callback - The callback function to execute when the event is triggered.\n\t * @returns {EventUnsubscribe} - A function to unsubscribe from the event.\n\t * @see {@link https://rivet.gg/docs/events|Events Documentation}\n\t */\n\tonce<Args extends Array<unknown> = unknown[]>(\n\t\teventName: string,\n\t\tcallback: (...args: Args) => void,\n\t): EventUnsubscribe {\n\t\treturn this.#addEventSubscription<Args>(eventName, callback, true);\n\t}\n\n\t/**\n\t * Subscribes to connection errors.\n\t *\n\t * @param {ActorErrorCallback} callback - The callback function to execute when a connection error occurs.\n\t * @returns {() => void} - A function to unsubscribe from the error handler.\n\t */\n\tonError(callback: ActorErrorCallback): () => void {\n\t\tthis.#errorHandlers.add(callback);\n\n\t\t// Return unsubscribe function\n\t\treturn () => {\n\t\t\tthis.#errorHandlers.delete(callback);\n\t\t};\n\t}\n\n\t#sendMessage(message: protocol.ToServer, opts?: SendHttpMessageOpts) {\n\t\tif (this.#disposed) {\n\t\t\tthrow new errors.ActorConnDisposed();\n\t\t}\n\n\t\tlet queueMessage = false;\n\t\tif (!this.#transport) {\n\t\t\t// No transport connected yet\n\t\t\tqueueMessage = true;\n\t\t} else if (\"websocket\" in this.#transport) {\n\t\t\tif (this.#transport.websocket.readyState === 1) {\n\t\t\t\ttry {\n\t\t\t\t\tconst messageSerialized = serializeWithEncoding(\n\t\t\t\t\t\tthis.#encodingKind,\n\t\t\t\t\t\tmessage,\n\t\t\t\t\t\tTO_SERVER_VERSIONED,\n\t\t\t\t\t);\n\t\t\t\t\tthis.#transport.websocket.send(messageSerialized);\n\t\t\t\t\tlogger().trace(\"sent websocket message\", {\n\t\t\t\t\t\tlen: messageLength(messageSerialized),\n\t\t\t\t\t});\n\t\t\t\t} catch (error) {\n\t\t\t\t\tlogger().warn(\"failed to send message, added to queue\", {\n\t\t\t\t\t\terror,\n\t\t\t\t\t});\n\n\t\t\t\t\t// Assuming the socket is disconnected and will be reconnected soon\n\t\t\t\t\tqueueMessage = true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tqueueMessage = true;\n\t\t\t}\n\t\t} else if (\"sse\" in this.#transport) {\n\t\t\tif (this.#transport.sse.readyState === 1) {\n\t\t\t\t// Spawn in background since #sendMessage cannot be async\n\t\t\t\tthis.#sendHttpMessage(message, opts);\n\t\t\t} else {\n\t\t\t\tqueueMessage = true;\n\t\t\t}\n\t\t} else {\n\t\t\tassertUnreachable(this.#transport);\n\t\t}\n\n\t\tif (!opts?.ephemeral && queueMessage) {\n\t\t\tthis.#messageQueue.push(message);\n\t\t\tlogger().debug(\"queued connection message\");\n\t\t}\n\t}\n\n\tasync #sendHttpMessage(\n\t\tmessage: protocol.ToServer,\n\t\topts?: SendHttpMessageOpts,\n\t) {\n\t\ttry {\n\t\t\tif (!this.#actorId || !this.#connectionId || !this.#connectionToken)\n\t\t\t\tthrow new errors.InternalError(\"Missing connection ID or token.\");\n\n\t\t\tlogger().trace(\n\t\t\t\t\"sent http message\",\n\t\t\t\tgetEnvUniversal(\"_RIVETKIT_LOG_MESSAGE\")\n\t\t\t\t\t? {\n\t\t\t\t\t\t\tmessage: jsonStringifyCompat(message).substring(0, 100) + \"...\",\n\t\t\t\t\t\t}\n\t\t\t\t\t: {},\n\t\t\t);\n\n\t\t\tawait this.#driver.sendHttpMessage(\n\t\t\t\tundefined,\n\t\t\t\tthis.#actorId,\n\t\t\t\tthis.#encodingKind,\n\t\t\t\tthis.#connectionId,\n\t\t\t\tthis.#connectionToken,\n\t\t\t\tmessage,\n\t\t\t\topts?.signal ? { signal: opts.signal } : undefined,\n\t\t\t);\n\t\t} catch (error) {\n\t\t\t// TODO: This will not automatically trigger a re-broadcast of HTTP events since SSE is separate from the HTTP action\n\n\t\t\tlogger().warn(\"failed to send message, added to queue\", {\n\t\t\t\terror,\n\t\t\t});\n\n\t\t\t// Assuming the socket is disconnected and will be reconnected soon\n\t\t\t//\n\t\t\t// Will attempt to resend soon\n\t\t\tif (!opts?.ephemeral) {\n\t\t\t\tthis.#messageQueue.unshift(message);\n\t\t\t}\n\t\t}\n\t}\n\n\tasync #parseMessage(data: ConnMessage): Promise<protocol.ToClient> {\n\t\tinvariant(this.#transport, \"transport must be defined\");\n\n\t\t// Decode base64 since SSE sends raw strings\n\t\tif (encodingIsBinary(this.#encodingKind) && \"sse\" in this.#transport) {\n\t\t\tif (typeof data === \"string\") {\n\t\t\t\tconst binaryString = atob(data);\n\t\t\t\tdata = new Uint8Array(\n\t\t\t\t\t[...binaryString].map((char) => char.charCodeAt(0)),\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tthrow new errors.InternalError(\n\t\t\t\t\t`Expected data to be a string for SSE, got ${data}.`,\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\n\t\tconst buffer = await inputDataToBuffer(data);\n\n\t\treturn deserializeWithEncoding(\n\t\t\tthis.#encodingKind,\n\t\t\tbuffer,\n\t\t\tTO_CLIENT_VERSIONED,\n\t\t);\n\t}\n\n\t/**\n\t * Disconnects from the actor.\n\t *\n\t * @returns {Promise<void>} A promise that resolves when the socket is gracefully closed.\n\t */\n\tasync dispose(): Promise<void> {\n\t\t// Internally, this \"disposes\" the connection\n\n\t\tif (this.#disposed) {\n\t\t\tlogger().warn(\"connection already disconnected\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#disposed = true;\n\n\t\tlogger().debug(\"disposing actor conn\");\n\n\t\t// Clear interval so NodeJS process can exit\n\t\tclearInterval(this.#keepNodeAliveInterval);\n\n\t\t// Abort\n\t\tthis.#abortController.abort();\n\n\t\t// Remove from registry\n\t\tthis.#client[ACTOR_CONNS_SYMBOL].delete(this);\n\n\t\t// Disconnect transport cleanly\n\t\tif (!this.#transport) {\n\t\t\t// Nothing to do\n\t\t} else if (\"websocket\" in this.#transport) {\n\t\t\tconst ws = this.#transport.websocket;\n\t\t\t// Check if WebSocket is already closed or closing\n\t\t\tif (\n\t\t\t\tws.readyState === 2 /* CLOSING */ ||\n\t\t\t\tws.readyState === 3 /* CLOSED */\n\t\t\t) {\n\t\t\t\tlogger().debug(\"ws already closed or closing\");\n\t\t\t} else {\n\t\t\t\tconst { promise, resolve } = Promise.withResolvers();\n\t\t\t\tws.addEventListener(\"close\", () => {\n\t\t\t\t\tlogger().debug(\"ws closed\");\n\t\t\t\t\tresolve(undefined);\n\t\t\t\t});\n\t\t\t\tws.close();\n\t\t\t\tawait promise;\n\t\t\t}\n\t\t} else if (\"sse\" in this.#transport) {\n\t\t\tthis.#transport.sse.close();\n\t\t} else {\n\t\t\tassertUnreachable(this.#transport);\n\t\t}\n\t\tthis.#transport = undefined;\n\t}\n\n\t#sendSubscription(eventName: string, subscribe: boolean) {\n\t\tthis.#sendMessage(\n\t\t\t{\n\t\t\t\tbody: {\n\t\t\t\t\ttag: \"SubscriptionRequest\",\n\t\t\t\t\tval: {\n\t\t\t\t\t\teventName,\n\t\t\t\t\t\tsubscribe,\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\t{ ephemeral: true },\n\t\t);\n\t}\n}\n\n/**\n * Connection to a actor. Allows calling actor's remote procedure calls with inferred types. See {@link ActorConnRaw} for underlying methods.\n *\n * @example\n * ```\n * const room = client.connect<ChatRoom>(...etc...);\n * // This calls the action named `sendMessage` on the `ChatRoom` actor.\n * await room.sendMessage('Hello, world!');\n * ```\n *\n * Private methods (e.g. those starting with `_`) are automatically excluded.\n *\n * @template AD The actor class that this connection is for.\n * @see {@link ActorConnRaw}\n */\nexport type ActorConn<AD extends AnyActorDefinition> = ActorConnRaw &\n\tActorDefinitionActions<AD>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/errors.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/errors.ts\";import { MAX_CONN_PARAMS_SIZE } from \"@/common//network\";\n\nexport class ActorClientError extends Error {}\n\nexport class InternalError extends ActorClientError {}\n\nexport class ManagerError extends ActorClientError {\n\tconstructor(error: string, opts?: ErrorOptions) {\n\t\tsuper(`Manager error: ${error}`, opts);\n\t}\n}\n\nexport class MalformedResponseMessage extends ActorClientError {\n\tconstructor(cause?: unknown) {\n\t\tsuper(`Malformed response message: ${cause}`, { cause });\n\t}\n}\n\nexport class ActorError extends ActorClientError {\n\t__type = \"ActorError\";\n\n\tconstructor(\n\t\tpublic readonly code: string,\n\t\tmessage: string,\n\t\tpublic readonly metadata?: unknown,\n\t) {\n\t\tsuper(message);\n\t}\n}\n\nexport class HttpRequestError extends ActorClientError {\n\tconstructor(message: string, opts?: { cause?: unknown }) {\n\t\tsuper(`HTTP request error: ${message}`, { cause: opts?.cause });\n\t}\n}\n\nexport class ActorConnDisposed extends ActorClientError {\n\tconstructor() {\n\t\tsuper(\"Attempting to interact with a disposed actor connection.\");\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/log.ts\";import { getLogger } from \"@/common//log\";\n\nexport const LOGGER_NAME = \"actor-client\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/utils.ts\";import * as cbor from \"cbor-x\";\nimport invariant from \"invariant\";\nimport { assertUnreachable } from \"@/common/utils\";\nimport type { VersionedDataHandler } from \"@/common/versioned-data\";\nimport type { Encoding } from \"@/mod\";\nimport type { HttpResponseError } from \"@/schemas/client-protocol/mod\";\nimport { HTTP_RESPONSE_ERROR_VERSIONED } from \"@/schemas/client-protocol/versioned\";\nimport {\n\tcontentTypeForEncoding,\n\tdeserializeWithEncoding,\n\tserializeWithEncoding,\n} from \"@/serde\";\nimport { httpUserAgent } from \"@/utils\";\nimport { ActorError, HttpRequestError } from \"./errors\";\nimport { logger } from \"./log\";\n\nexport type WebSocketMessage = string | Blob | ArrayBuffer | Uint8Array;\n\nexport function messageLength(message: WebSocketMessage): number {\n\tif (message instanceof Blob) {\n\t\treturn message.size;\n\t}\n\tif (message instanceof ArrayBuffer) {\n\t\treturn message.byteLength;\n\t}\n\tif (message instanceof Uint8Array) {\n\t\treturn message.byteLength;\n\t}\n\tif (typeof message === \"string\") {\n\t\treturn message.length;\n\t}\n\tassertUnreachable(message);\n}\n\nexport interface HttpRequestOpts<RequestBody, ResponseBody> {\n\tmethod: string;\n\turl: string;\n\theaders: Record<string, string>;\n\tbody?: RequestBody;\n\tencoding: Encoding;\n\tskipParseResponse?: boolean;\n\tsignal?: AbortSignal;\n\tcustomFetch?: (req: Request) => Promise<Response>;\n\trequestVersionedDataHandler: VersionedDataHandler<RequestBody>;\n\tresponseVersionedDataHandler: VersionedDataHandler<ResponseBody>;\n}\n\nexport async function sendHttpRequest<\n\tRequestBody = unknown,\n\tResponseBody = unknown,\n>(opts: HttpRequestOpts<RequestBody, ResponseBody>): Promise<ResponseBody> {\n\tlogger().debug(\"sending http request\", {\n\t\turl: opts.url,\n\t\tencoding: opts.encoding,\n\t});\n\n\t// Serialize body\n\tlet contentType: string | undefined;\n\tlet bodyData: string | Uint8Array | undefined;\n\tif (opts.method === \"POST\" || opts.method === \"PUT\") {\n\t\tinvariant(opts.body !== undefined, \"missing body\");\n\t\tcontentType = contentTypeForEncoding(opts.encoding);\n\t\tbodyData = serializeWithEncoding<RequestBody>(\n\t\t\topts.encoding,\n\t\t\topts.body,\n\t\t\topts.requestVersionedDataHandler,\n\t\t);\n\t}\n\n\t// Send request\n\tlet response: Response;\n\ttry {\n\t\t// Make the HTTP request\n\t\tresponse = await (opts.customFetch ?? fetch)(\n\t\t\tnew Request(opts.url, {\n\t\t\t\tmethod: opts.method,\n\t\t\t\theaders: {\n\t\t\t\t\t...opts.headers,\n\t\t\t\t\t...(contentType\n\t\t\t\t\t\t? {\n\t\t\t\t\t\t\t\t\"Content-Type\": contentType,\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t: {}),\n\t\t\t\t\t\"User-Agent\": httpUserAgent(),\n\t\t\t\t},\n\t\t\t\tbody: bodyData,\n\t\t\t\tcredentials: \"include\",\n\t\t\t\tsignal: opts.signal,\n\t\t\t}),\n\t\t);\n\t} catch (error) {\n\t\tthrow new HttpRequestError(`Request failed: ${error}`, {\n\t\t\tcause: error,\n\t\t});\n\t}\n\n\t// Parse response error\n\tif (!response.ok) {\n\t\t// Attempt to parse structured data\n\t\tconst bufferResponse = await response.arrayBuffer();\n\t\tlet responseData: HttpResponseError;\n\t\ttry {\n\t\t\tresponseData = deserializeWithEncoding(\n\t\t\t\topts.encoding,\n\t\t\t\tnew Uint8Array(bufferResponse),\n\t\t\t\tHTTP_RESPONSE_ERROR_VERSIONED,\n\t\t\t);\n\t\t} catch (error) {\n\t\t\t//logger().warn(\"failed to cleanly parse error, this is likely because a non-structured response is being served\", {\n\t\t\t//\terror: stringifyError(error),\n\t\t\t//});\n\n\t\t\t// Error is not structured\n\t\t\tconst textResponse = new TextDecoder(\"utf-8\", { fatal: false }).decode(\n\t\t\t\tbufferResponse,\n\t\t\t);\n\t\t\tthrow new HttpRequestError(\n\t\t\t\t`${response.statusText} (${response.status}):\\n${textResponse}`,\n\t\t\t);\n\t\t}\n\n\t\t// Throw structured error\n\t\tthrow new ActorError(\n\t\t\tresponseData.code,\n\t\t\tresponseData.message,\n\t\t\tresponseData.metadata\n\t\t\t\t? cbor.decode(new Uint8Array(responseData.metadata))\n\t\t\t\t: undefined,\n\t\t);\n\t}\n\n\t// Some requests don't need the success response to be parsed, so this can speed things up\n\tif (opts.skipParseResponse) {\n\t\treturn undefined as ResponseBody;\n\t}\n\n\t// Parse the response based on encoding\n\ttry {\n\t\tconst buffer = new Uint8Array(await response.arrayBuffer());\n\t\treturn deserializeWithEncoding(\n\t\t\topts.encoding,\n\t\t\tbuffer,\n\t\t\topts.responseVersionedDataHandler,\n\t\t);\n\t} catch (error) {\n\t\tthrow new HttpRequestError(`Failed to parse response: ${error}`, {\n\t\t\tcause: error,\n\t\t});\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/actor-handle.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/actor-handle.ts\";import invariant from \"invariant\";\nimport type { AnyActorDefinition } from \"@/actor/definition\";\nimport type { Encoding } from \"@/actor/protocol/serde\";\nimport { assertUnreachable } from \"@/actor/utils\";\nimport { importWebSocket } from \"@/common/websocket\";\nimport type { ActorQuery } from \"@/manager/protocol/query\";\nimport type { ActorDefinitionActions } from \"./actor-common\";\nimport { type ActorConn, ActorConnRaw } from \"./actor-conn\";\nimport {\n\ttype ClientDriver,\n\ttype ClientRaw,\n\tCREATE_ACTOR_CONN_PROXY,\n} from \"./client\";\nimport { logger } from \"./log\";\nimport { rawHttpFetch, rawWebSocket } from \"./raw-utils\";\n\n/**\n * Provides underlying functions for stateless {@link ActorHandle} for action calls.\n * Similar to ActorConnRaw but doesn't maintain a connection.\n *\n * @see {@link ActorHandle}\n */\nexport class ActorHandleRaw {\n\t#client: ClientRaw;\n\t#driver: ClientDriver;\n\t#encodingKind: Encoding;\n\t#actorQuery: ActorQuery;\n\t#params: unknown;\n\n\t/**\n\t * Do not call this directly.\n\t *\n\t * Creates an instance of ActorHandleRaw.\n\t *\n\t * @protected\n\t */\n\tpublic constructor(\n\t\tclient: any,\n\t\tdriver: ClientDriver,\n\t\tparams: unknown,\n\t\tencodingKind: Encoding,\n\t\tactorQuery: ActorQuery,\n\t) {\n\t\tthis.#client = client;\n\t\tthis.#driver = driver;\n\t\tthis.#encodingKind = encodingKind;\n\t\tthis.#actorQuery = actorQuery;\n\t\tthis.#params = params;\n\t}\n\n\t/**\n\t * Call a raw action. This method sends an HTTP request to invoke the named action.\n\t *\n\t * @see {@link ActorHandle}\n\t * @template Args - The type of arguments to pass to the action function.\n\t * @template Response - The type of the response returned by the action function.\n\t */\n\tasync action<\n\t\tArgs extends Array<unknown> = unknown[],\n\t\tResponse = unknown,\n\t>(opts: {\n\t\tname: string;\n\t\targs: Args;\n\t\tsignal?: AbortSignal;\n\t}): Promise<Response> {\n\t\treturn await this.#driver.action<Args, Response>(\n\t\t\tundefined,\n\t\t\tthis.#actorQuery,\n\t\t\tthis.#encodingKind,\n\t\t\tthis.#params,\n\t\t\topts.name,\n\t\t\topts.args,\n\t\t\t{ signal: opts.signal },\n\t\t);\n\t}\n\n\t/**\n\t * Establishes a persistent connection to the actor.\n\t *\n\t * @template AD The actor class that this connection is for.\n\t * @returns {ActorConn<AD>} A connection to the actor.\n\t */\n\tconnect(): ActorConn<AnyActorDefinition> {\n\t\tlogger().debug(\"establishing connection from handle\", {\n\t\t\tquery: this.#actorQuery,\n\t\t});\n\n\t\tconst conn = new ActorConnRaw(\n\t\t\tthis.#client,\n\t\t\tthis.#driver,\n\t\t\tthis.#params,\n\t\t\tthis.#encodingKind,\n\t\t\tthis.#actorQuery,\n\t\t);\n\n\t\treturn this.#client[CREATE_ACTOR_CONN_PROXY](\n\t\t\tconn,\n\t\t) as ActorConn<AnyActorDefinition>;\n\t}\n\n\t/**\n\t * Makes a raw HTTP request to the actor.\n\t *\n\t * @param input - The URL, path, or Request object\n\t * @param init - Standard fetch RequestInit options\n\t * @returns Promise<Response> - The raw HTTP response\n\t */\n\tasync fetch(\n\t\tinput: string | URL | Request,\n\t\tinit?: RequestInit,\n\t): Promise<Response> {\n\t\treturn rawHttpFetch(\n\t\t\tthis.#driver,\n\t\t\tthis.#actorQuery,\n\t\t\tthis.#params,\n\t\t\tinput,\n\t\t\tinit,\n\t\t);\n\t}\n\n\t/**\n\t * Creates a raw WebSocket connection to the actor.\n\t *\n\t * @param path - The path for the WebSocket connection (e.g., \"stream\")\n\t * @param protocols - Optional WebSocket subprotocols\n\t * @returns WebSocket - A raw WebSocket connection\n\t */\n\tasync websocket(\n\t\tpath?: string,\n\t\tprotocols?: string | string[],\n\t): Promise<WebSocket> {\n\t\treturn rawWebSocket(\n\t\t\tthis.#driver,\n\t\t\tthis.#actorQuery,\n\t\t\tthis.#params,\n\t\t\tpath,\n\t\t\tprotocols,\n\t\t);\n\t}\n\n\t/**\n\t * Resolves the actor to get its unique actor ID\n\t *\n\t * @returns {Promise<string>} - A promise that resolves to the actor's ID\n\t */\n\tasync resolve({ signal }: { signal?: AbortSignal } = {}): Promise<string> {\n\t\tif (\n\t\t\t\"getForKey\" in this.#actorQuery ||\n\t\t\t\"getOrCreateForKey\" in this.#actorQuery\n\t\t) {\n\t\t\t// TODO:\n\t\t\tlet name: string;\n\t\t\tif (\"getForKey\" in this.#actorQuery) {\n\t\t\t\tname = this.#actorQuery.getForKey.name;\n\t\t\t} else if (\"getOrCreateForKey\" in this.#actorQuery) {\n\t\t\t\tname = this.#actorQuery.getOrCreateForKey.name;\n\t\t\t} else {\n\t\t\t\tassertUnreachable(this.#actorQuery);\n\t\t\t}\n\n\t\t\tconst actorId = await this.#driver.resolveActorId(\n\t\t\t\tundefined,\n\t\t\t\tthis.#actorQuery,\n\t\t\t\tthis.#encodingKind,\n\t\t\t\tthis.#params,\n\t\t\t\tsignal ? { signal } : undefined,\n\t\t\t);\n\n\t\t\tthis.#actorQuery = { getForId: { actorId, name } };\n\n\t\t\treturn actorId;\n\t\t} else if (\"getForId\" in this.#actorQuery) {\n\t\t\t// SKip since it's already resolved\n\t\t\treturn this.#actorQuery.getForId.actorId;\n\t\t} else if (\"create\" in this.#actorQuery) {\n\t\t\t// Cannot create a handle with this query\n\t\t\tinvariant(false, \"actorQuery cannot be create\");\n\t\t} else {\n\t\t\tassertUnreachable(this.#actorQuery);\n\t\t}\n\t}\n}\n\n/**\n * Stateless handle to a actor. Allows calling actor's remote procedure calls with inferred types\n * without establishing a persistent connection.\n *\n * @example\n * ```\n * const room = client.get<ChatRoom>(...etc...);\n * // This calls the action named `sendMessage` on the `ChatRoom` actor without a connection.\n * await room.sendMessage('Hello, world!');\n * ```\n *\n * Private methods (e.g. those starting with `_`) are automatically excluded.\n *\n * @template AD The actor class that this handle is for.\n * @see {@link ActorHandleRaw}\n */\nexport type ActorHandle<AD extends AnyActorDefinition> = Omit<\n\tActorHandleRaw,\n\t\"connect\"\n> & {\n\t// Add typed version of ActorConn (instead of using AnyActorDefinition)\n\tconnect(): ActorConn<AD>;\n\t// Resolve method returns the actor ID\n\tresolve(): Promise<string>;\n} & ActorDefinitionActions<AD>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/raw-utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/raw-utils.ts\";import type { ActorQuery } from \"@/manager/protocol/query\";\nimport type { ClientDriver } from \"./client\";\n\n/**\n * Shared implementation for raw HTTP fetch requests\n */\nexport async function rawHttpFetch(\n\tdriver: ClientDriver,\n\tactorQuery: ActorQuery,\n\tparams: unknown,\n\tinput: string | URL | Request,\n\tinit?: RequestInit,\n): Promise<Response> {\n\t// Extract path and merge init options\n\tlet path: string;\n\tlet mergedInit: RequestInit = init || {};\n\n\tif (typeof input === \"string\") {\n\t\tpath = input;\n\t} else if (input instanceof URL) {\n\t\tpath = input.pathname + input.search;\n\t} else if (input instanceof Request) {\n\t\t// Extract path from Request URL\n\t\tconst url = new URL(input.url);\n\t\tpath = url.pathname + url.search;\n\t\t// Merge Request properties with init\n\t\tconst requestHeaders = new Headers(input.headers);\n\t\tconst initHeaders = new Headers(init?.headers || {});\n\n\t\t// Merge headers - init headers override request headers\n\t\tconst mergedHeaders = new Headers(requestHeaders);\n\t\tfor (const [key, value] of initHeaders) {\n\t\t\tmergedHeaders.set(key, value);\n\t\t}\n\n\t\tmergedInit = {\n\t\t\tmethod: input.method,\n\t\t\tbody: input.body,\n\t\t\tmode: input.mode,\n\t\t\tcredentials: input.credentials,\n\t\t\tredirect: input.redirect,\n\t\t\treferrer: input.referrer,\n\t\t\treferrerPolicy: input.referrerPolicy,\n\t\t\tintegrity: input.integrity,\n\t\t\tkeepalive: input.keepalive,\n\t\t\tsignal: input.signal,\n\t\t\t...mergedInit, // init overrides Request properties\n\t\t\theaders: mergedHeaders, // headers must be set after spread to ensure proper merge\n\t\t};\n\t\t// Add duplex if body is present\n\t\tif (mergedInit.body) {\n\t\t\t(mergedInit as any).duplex = \"half\";\n\t\t}\n\t} else {\n\t\tthrow new TypeError(\"Invalid input type for fetch\");\n\t}\n\n\t// Use the driver's raw HTTP method - just pass the sub-path\n\treturn await driver.rawHttpRequest(\n\t\tundefined,\n\t\tactorQuery,\n\t\t// Force JSON so it's readable by the user\n\t\t\"json\",\n\t\tparams,\n\t\tpath,\n\t\tmergedInit,\n\t\tundefined,\n\t);\n}\n\n/**\n * Shared implementation for raw WebSocket connections\n */\nexport async function rawWebSocket(\n\tdriver: ClientDriver,\n\tactorQuery: ActorQuery,\n\tparams: unknown,\n\tpath?: string,\n\tprotocols?: string | string[],\n): Promise<any> {\n\t// Use the driver's raw WebSocket method\n\treturn await driver.rawWebSocket(\n\t\tundefined,\n\t\tactorQuery,\n\t\t// Force JSON so it's readable by the user\n\t\t\"json\",\n\t\tparams,\n\t\tpath || \"\",\n\t\tprotocols,\n\t\tundefined,\n\t);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client/client.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/client\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/client/client.ts\";import type { Context as HonoContext } from \"hono\";\nimport type { WebSocket } from \"ws\";\nimport type { AnyActorDefinition } from \"@/actor/definition\";\nimport type { Transport } from \"@/actor/protocol/old\";\nimport type { Encoding } from \"@/actor/protocol/serde\";\nimport type { UniversalEventSource } from \"@/common/eventsource-interface\";\nimport type { ActorQuery } from \"@/manager/protocol/query\";\nimport type { Registry } from \"@/mod\";\nimport type { ToServer } from \"@/schemas/client-protocol/mod\";\nimport type { ActorActionFunction } from \"./actor-common\";\nimport {\n\ttype ActorConn,\n\ttype ActorConnRaw,\n\tCONNECT_SYMBOL,\n} from \"./actor-conn\";\nimport { type ActorHandle, ActorHandleRaw } from \"./actor-handle\";\nimport { logger } from \"./log\";\n\n/** Extract the actor registry from the registry definition. */\nexport type ExtractActorsFromRegistry<A extends Registry<any>> =\n\tA extends Registry<infer Actors> ? Actors : never;\n\n/** Extract the registry definition from the client. */\nexport type ExtractRegistryFromClient<C extends Client<Registry<{}>>> =\n\tC extends Client<infer A> ? A : never;\n\n/**\n * Represents a actor accessor that provides methods to interact with a specific actor.\n */\nexport interface ActorAccessor<AD extends AnyActorDefinition> {\n\t/**\n\t * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.\n\t * The actor name is automatically injected from the property accessor.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {GetWithIdOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tget(key?: string | string[], opts?: GetWithIdOptions): ActorHandle<AD>;\n\n\t/**\n\t * Gets a stateless handle to a actor by its key, creating it if necessary.\n\t * The actor name is automatically injected from the property accessor.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {GetOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tgetOrCreate(\n\t\tkey?: string | string[],\n\t\topts?: GetOrCreateOptions,\n\t): ActorHandle<AD>;\n\n\t/**\n\t * Gets a stateless handle to a actor by its ID.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string} actorId - The ID of the actor.\n\t * @param {GetWithIdOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tgetForId(actorId: string, opts?: GetWithIdOptions): ActorHandle<AD>;\n\n\t/**\n\t * Creates a new actor with the name automatically injected from the property accessor,\n\t * and returns a stateless handle to it with the actor ID resolved.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).\n\t * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.\n\t */\n\tcreate(\n\t\tkey?: string | string[],\n\t\topts?: CreateOptions,\n\t): Promise<ActorHandle<AD>>;\n}\n\n/**\n * Options for configuring the client.\n * @typedef {Object} ClientOptions\n */\nexport interface ClientOptions {\n\tencoding?: Encoding;\n\ttransport?: Transport;\n}\n\n/**\n * Options for querying actors.\n * @typedef {Object} QueryOptions\n * @property {unknown} [parameters] - Parameters to pass to the connection.\n */\nexport interface QueryOptions {\n\t/** Parameters to pass to the connection. */\n\tparams?: unknown;\n\t/** Signal to abort the request. */\n\tsignal?: AbortSignal;\n}\n\n/**\n * Options for getting a actor by ID.\n * @typedef {QueryOptions} GetWithIdOptions\n */\nexport interface GetWithIdOptions extends QueryOptions {}\n\n/**\n * Options for getting a actor.\n * @typedef {QueryOptions} GetOptions\n */\nexport interface GetOptions extends QueryOptions {}\n\n/**\n * Options for getting or creating a actor.\n * @typedef {QueryOptions} GetOrCreateOptions\n * @property {string} [createInRegion] - Region to create the actor in if it doesn't exist.\n */\nexport interface GetOrCreateOptions extends QueryOptions {\n\t/** Region to create the actor in if it doesn't exist. */\n\tcreateInRegion?: string;\n\t/** Input data to pass to the actor. */\n\tcreateWithInput?: unknown;\n}\n\n/**\n * Options for creating a actor.\n * @typedef {QueryOptions} CreateOptions\n * @property {string} [region] - The region to create the actor in.\n */\nexport interface CreateOptions extends QueryOptions {\n\t/** The region to create the actor in. */\n\tregion?: string;\n\t/** Input data to pass to the actor. */\n\tinput?: unknown;\n}\n\n/**\n * Represents a region to connect to.\n * @typedef {Object} Region\n * @property {string} id - The region ID.\n * @property {string} name - The region name.\n * @see {@link https://rivet.gg/docs/edge|Edge Networking}\n * @see {@link https://rivet.gg/docs/regions|Available Regions}\n */\nexport interface Region {\n\t/**\n\t * The region slug.\n\t */\n\tid: string;\n\n\t/**\n\t * The human-friendly region name.\n\t */\n\tname: string;\n}\n\nexport const ACTOR_CONNS_SYMBOL = Symbol(\"actorConns\");\nexport const CREATE_ACTOR_CONN_PROXY = Symbol(\"createActorConnProxy\");\nexport const TRANSPORT_SYMBOL = Symbol(\"transport\");\n\nexport interface ClientDriver {\n\taction<Args extends Array<unknown> = unknown[], Response = unknown>(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t\tname: string,\n\t\targs: Args,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<Response>;\n\tresolveActorId(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencodingKind: Encoding,\n\t\tparams: unknown,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<string>;\n\tconnectWebSocket(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencodingKind: Encoding,\n\t\tparams: unknown,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<WebSocket>;\n\tconnectSse(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencodingKind: Encoding,\n\t\tparams: unknown,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<UniversalEventSource>;\n\tsendHttpMessage(\n\t\tc: HonoContext | undefined,\n\t\tactorId: string,\n\t\tencoding: Encoding,\n\t\tconnectionId: string,\n\t\tconnectionToken: string,\n\t\tmessage: ToServer,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<void>;\n\trawHttpRequest(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t\tpath: string,\n\t\tinit: RequestInit,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<Response>;\n\trawWebSocket(\n\t\tc: HonoContext | undefined,\n\t\tactorQuery: ActorQuery,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t\tpath: string,\n\t\tprotocols: string | string[] | undefined,\n\t\topts: { signal?: AbortSignal } | undefined,\n\t): Promise<WebSocket>;\n}\n\n/**\n * Client for managing & connecting to actors.\n *\n * @template A The actors map type that defines the available actors.\n * @see {@link https://rivet.gg/docs/manage|Create & Manage Actors}\n */\nexport class ClientRaw {\n\t#disposed = false;\n\n\t[ACTOR_CONNS_SYMBOL] = new Set<ActorConnRaw>();\n\n\t#driver: ClientDriver;\n\t#encodingKind: Encoding;\n\t[TRANSPORT_SYMBOL]: Transport;\n\n\t/**\n\t * Creates an instance of Client.\n\t *\n\t * @param {string} managerEndpoint - The manager endpoint. See {@link https://rivet.gg/docs/setup|Initial Setup} for instructions on getting the manager endpoint.\n\t * @param {ClientOptions} [opts] - Options for configuring the client.\n\t * @see {@link https://rivet.gg/docs/setup|Initial Setup}\n\t */\n\tpublic constructor(driver: ClientDriver, opts?: ClientOptions) {\n\t\tthis.#driver = driver;\n\n\t\tthis.#encodingKind = opts?.encoding ?? \"bare\";\n\t\tthis[TRANSPORT_SYMBOL] = opts?.transport ?? \"websocket\";\n\t}\n\n\t/**\n\t * Gets a stateless handle to a actor by its ID.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string} name - The name of the actor.\n\t * @param {string} actorId - The ID of the actor.\n\t * @param {GetWithIdOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tgetForId<AD extends AnyActorDefinition>(\n\t\tname: string,\n\t\tactorId: string,\n\t\topts?: GetWithIdOptions,\n\t): ActorHandle<AD> {\n\t\tlogger().debug(\"get handle to actor with id\", {\n\t\t\tname,\n\t\t\tactorId,\n\t\t\tparams: opts?.params,\n\t\t});\n\n\t\tconst actorQuery: ActorQuery = {\n\t\t\tgetForId: {\n\t\t\t\tname,\n\t\t\t\tactorId,\n\t\t\t},\n\t\t};\n\n\t\tconst handle = this.#createHandle(opts?.params, actorQuery);\n\t\treturn createActorProxy(handle) as ActorHandle<AD>;\n\t}\n\n\t/**\n\t * Gets a stateless handle to a actor by its key, but does not create the actor if it doesn't exist.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string} name - The name of the actor.\n\t * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {GetWithIdOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tget<AD extends AnyActorDefinition>(\n\t\tname: string,\n\t\tkey?: string | string[],\n\t\topts?: GetWithIdOptions,\n\t): ActorHandle<AD> {\n\t\t// Convert string to array of strings\n\t\tconst keyArray: string[] = typeof key === \"string\" ? [key] : key || [];\n\n\t\tlogger().debug(\"get handle to actor\", {\n\t\t\tname,\n\t\t\tkey: keyArray,\n\t\t\tparameters: opts?.params,\n\t\t});\n\n\t\tconst actorQuery: ActorQuery = {\n\t\t\tgetForKey: {\n\t\t\t\tname,\n\t\t\t\tkey: keyArray,\n\t\t\t},\n\t\t};\n\n\t\tconst handle = this.#createHandle(opts?.params, actorQuery);\n\t\treturn createActorProxy(handle) as ActorHandle<AD>;\n\t}\n\n\t/**\n\t * Gets a stateless handle to a actor by its key, creating it if necessary.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string} name - The name of the actor.\n\t * @param {string | string[]} [key=[]] - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {GetOptions} [opts] - Options for getting the actor.\n\t * @returns {ActorHandle<AD>} - A handle to the actor.\n\t */\n\tgetOrCreate<AD extends AnyActorDefinition>(\n\t\tname: string,\n\t\tkey?: string | string[],\n\t\topts?: GetOrCreateOptions,\n\t): ActorHandle<AD> {\n\t\t// Convert string to array of strings\n\t\tconst keyArray: string[] = typeof key === \"string\" ? [key] : key || [];\n\n\t\tlogger().debug(\"get or create handle to actor\", {\n\t\t\tname,\n\t\t\tkey: keyArray,\n\t\t\tparameters: opts?.params,\n\t\t\tcreateInRegion: opts?.createInRegion,\n\t\t});\n\n\t\tconst actorQuery: ActorQuery = {\n\t\t\tgetOrCreateForKey: {\n\t\t\t\tname,\n\t\t\t\tkey: keyArray,\n\t\t\t\tinput: opts?.createWithInput,\n\t\t\t\tregion: opts?.createInRegion,\n\t\t\t},\n\t\t};\n\n\t\tconst handle = this.#createHandle(opts?.params, actorQuery);\n\t\treturn createActorProxy(handle) as ActorHandle<AD>;\n\t}\n\n\t/**\n\t * Creates a new actor with the provided key and returns a stateless handle to it.\n\t * Resolves the actor ID and returns a handle with getForId query.\n\t *\n\t * @template AD The actor class that this handle is for.\n\t * @param {string} name - The name of the actor.\n\t * @param {string | string[]} key - The key to identify the actor. Can be a single string or an array of strings.\n\t * @param {CreateOptions} [opts] - Options for creating the actor (excluding name and key).\n\t * @returns {Promise<ActorHandle<AD>>} - A promise that resolves to a handle to the actor.\n\t */\n\tasync create<AD extends AnyActorDefinition>(\n\t\tname: string,\n\t\tkey?: string | string[],\n\t\topts?: CreateOptions,\n\t): Promise<ActorHandle<AD>> {\n\t\t// Convert string to array of strings\n\t\tconst keyArray: string[] = typeof key === \"string\" ? [key] : key || [];\n\n\t\tconst createQuery = {\n\t\t\tcreate: {\n\t\t\t\t...opts,\n\t\t\t\t// Do these last to override `opts`\n\t\t\t\tname,\n\t\t\t\tkey: keyArray,\n\t\t\t},\n\t\t} satisfies ActorQuery;\n\n\t\tlogger().debug(\"create actor handle\", {\n\t\t\tname,\n\t\t\tkey: keyArray,\n\t\t\tparameters: opts?.params,\n\t\t\tcreate: createQuery.create,\n\t\t});\n\n\t\t// Create the actor\n\t\tconst actorId = await this.#driver.resolveActorId(\n\t\t\tundefined,\n\t\t\tcreateQuery,\n\t\t\tthis.#encodingKind,\n\t\t\topts?.params,\n\t\t\topts?.signal ? { signal: opts.signal } : undefined,\n\t\t);\n\t\tlogger().debug(\"created actor with ID\", {\n\t\t\tname,\n\t\t\tkey: keyArray,\n\t\t\tactorId,\n\t\t});\n\n\t\t// Create handle with actor ID\n\t\tconst getForIdQuery = {\n\t\t\tgetForId: {\n\t\t\t\tname,\n\t\t\t\tactorId,\n\t\t\t},\n\t\t} satisfies ActorQuery;\n\t\tconst handle = this.#createHandle(opts?.params, getForIdQuery);\n\n\t\tconst proxy = createActorProxy(handle) as ActorHandle<AD>;\n\n\t\treturn proxy;\n\t}\n\n\t#createHandle(params: unknown, actorQuery: ActorQuery): ActorHandleRaw {\n\t\treturn new ActorHandleRaw(\n\t\t\tthis,\n\t\t\tthis.#driver,\n\t\t\tparams,\n\t\t\tthis.#encodingKind,\n\t\t\tactorQuery,\n\t\t);\n\t}\n\n\t[CREATE_ACTOR_CONN_PROXY]<AD extends AnyActorDefinition>(\n\t\tconn: ActorConnRaw,\n\t): ActorConn<AD> {\n\t\t// Save to connection list\n\t\tthis[ACTOR_CONNS_SYMBOL].add(conn);\n\n\t\t// Start connection\n\t\tconn[CONNECT_SYMBOL]();\n\n\t\treturn createActorProxy(conn) as ActorConn<AD>;\n\t}\n\n\t/**\n\t * Disconnects from all actors.\n\t *\n\t * @returns {Promise<void>} A promise that resolves when all connections are closed.\n\t */\n\tasync dispose(): Promise<void> {\n\t\tif (this.#disposed) {\n\t\t\tlogger().warn(\"client already disconnected\");\n\t\t\treturn;\n\t\t}\n\t\tthis.#disposed = true;\n\n\t\tlogger().debug(\"disposing client\");\n\n\t\tconst disposePromises = [];\n\n\t\t// Dispose all connections\n\t\tfor (const conn of this[ACTOR_CONNS_SYMBOL].values()) {\n\t\t\tdisposePromises.push(conn.dispose());\n\t\t}\n\n\t\tawait Promise.all(disposePromises);\n\t}\n}\n\n/**\n * Client type with actor accessors.\n * This adds property accessors for actor names to the ClientRaw base class.\n *\n * @template A The actor registry type.\n */\nexport type Client<A extends Registry<any>> = ClientRaw & {\n\t[K in keyof ExtractActorsFromRegistry<A>]: ActorAccessor<\n\t\tExtractActorsFromRegistry<A>[K]\n\t>;\n};\n\nexport type AnyClient = Client<Registry<any>>;\n\nexport function createClientWithDriver<A extends Registry<any>>(\n\tdriver: ClientDriver,\n\topts?: ClientOptions,\n): Client<A> {\n\tconst client = new ClientRaw(driver, opts);\n\n\t// Create proxy for accessing actors by name\n\treturn new Proxy(client, {\n\t\tget: (target: ClientRaw, prop: string | symbol, receiver: unknown) => {\n\t\t\t// Get the real property if it exists\n\t\t\tif (typeof prop === \"symbol\" || prop in target) {\n\t\t\t\tconst value = Reflect.get(target, prop, receiver);\n\t\t\t\t// Preserve method binding\n\t\t\t\tif (typeof value === \"function\") {\n\t\t\t\t\treturn value.bind(target);\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t}\n\n\t\t\t// Handle actor accessor for string properties (actor names)\n\t\t\tif (typeof prop === \"string\") {\n\t\t\t\t// Return actor accessor object with methods\n\t\t\t\treturn {\n\t\t\t\t\t// Handle methods (stateless action)\n\t\t\t\t\tget: (\n\t\t\t\t\t\tkey?: string | string[],\n\t\t\t\t\t\topts?: GetWithIdOptions,\n\t\t\t\t\t): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {\n\t\t\t\t\t\treturn target.get<ExtractActorsFromRegistry<A>[typeof prop]>(\n\t\t\t\t\t\t\tprop,\n\t\t\t\t\t\t\tkey,\n\t\t\t\t\t\t\topts,\n\t\t\t\t\t\t);\n\t\t\t\t\t},\n\t\t\t\t\tgetOrCreate: (\n\t\t\t\t\t\tkey?: string | string[],\n\t\t\t\t\t\topts?: GetOptions,\n\t\t\t\t\t): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {\n\t\t\t\t\t\treturn target.getOrCreate<\n\t\t\t\t\t\t\tExtractActorsFromRegistry<A>[typeof prop]\n\t\t\t\t\t\t>(prop, key, opts);\n\t\t\t\t\t},\n\t\t\t\t\tgetForId: (\n\t\t\t\t\t\tactorId: string,\n\t\t\t\t\t\topts?: GetWithIdOptions,\n\t\t\t\t\t): ActorHandle<ExtractActorsFromRegistry<A>[typeof prop]> => {\n\t\t\t\t\t\treturn target.getForId<ExtractActorsFromRegistry<A>[typeof prop]>(\n\t\t\t\t\t\t\tprop,\n\t\t\t\t\t\t\tactorId,\n\t\t\t\t\t\t\topts,\n\t\t\t\t\t\t);\n\t\t\t\t\t},\n\t\t\t\t\tcreate: async (\n\t\t\t\t\t\tkey: string | string[],\n\t\t\t\t\t\topts: CreateOptions = {},\n\t\t\t\t\t): Promise<\n\t\t\t\t\t\tActorHandle<ExtractActorsFromRegistry<A>[typeof prop]>\n\t\t\t\t\t> => {\n\t\t\t\t\t\treturn await target.create<\n\t\t\t\t\t\t\tExtractActorsFromRegistry<A>[typeof prop]\n\t\t\t\t\t\t>(prop, key, opts);\n\t\t\t\t\t},\n\t\t\t\t} as ActorAccessor<ExtractActorsFromRegistry<A>[typeof prop]>;\n\t\t\t}\n\n\t\t\treturn undefined;\n\t\t},\n\t}) as Client<A>;\n}\n\n/**\n * Creates a proxy for a actor that enables calling actions without explicitly using `.action`.\n **/\nfunction createActorProxy<AD extends AnyActorDefinition>(\n\thandle: ActorHandleRaw | ActorConnRaw,\n): ActorHandle<AD> | ActorConn<AD> {\n\t// Stores returned action functions for faster calls\n\tconst methodCache = new Map<string, ActorActionFunction>();\n\treturn new Proxy(handle, {\n\t\tget(target: ActorHandleRaw, prop: string | symbol, receiver: unknown) {\n\t\t\t// Handle built-in Symbol properties\n\t\t\tif (typeof prop === \"symbol\") {\n\t\t\t\treturn Reflect.get(target, prop, receiver);\n\t\t\t}\n\n\t\t\t// Handle built-in Promise methods and existing properties\n\t\t\tif (prop === \"constructor\" || prop in target) {\n\t\t\t\tconst value = Reflect.get(target, prop, receiver);\n\t\t\t\t// Preserve method binding\n\t\t\t\tif (typeof value === \"function\") {\n\t\t\t\t\treturn value.bind(target);\n\t\t\t\t}\n\t\t\t\treturn value;\n\t\t\t}\n\n\t\t\t// Create action function that preserves 'this' context\n\t\t\tif (typeof prop === \"string\") {\n\t\t\t\t// If JS is attempting to calling this as a promise, ignore it\n\t\t\t\tif (prop === \"then\") return undefined;\n\n\t\t\t\tlet method = methodCache.get(prop);\n\t\t\t\tif (!method) {\n\t\t\t\t\tmethod = (...args: unknown[]) => target.action({ name: prop, args });\n\t\t\t\t\tmethodCache.set(prop, method);\n\t\t\t\t}\n\t\t\t\treturn method;\n\t\t\t}\n\t\t},\n\n\t\t// Support for 'in' operator\n\t\thas(target: ActorHandleRaw, prop: string | symbol) {\n\t\t\t// All string properties are potentially action functions\n\t\t\tif (typeof prop === \"string\") {\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\t// For symbols, defer to the target's own has behavior\n\t\t\treturn Reflect.has(target, prop);\n\t\t},\n\n\t\t// Support instanceof checks\n\t\tgetPrototypeOf(target: ActorHandleRaw) {\n\t\t\treturn Reflect.getPrototypeOf(target);\n\t\t},\n\n\t\t// Prevent property enumeration of non-existent action methods\n\t\townKeys(target: ActorHandleRaw) {\n\t\t\treturn Reflect.ownKeys(target);\n\t\t},\n\n\t\t// Support proper property descriptors\n\t\tgetOwnPropertyDescriptor(target: ActorHandleRaw, prop: string | symbol) {\n\t\t\tconst targetDescriptor = Reflect.getOwnPropertyDescriptor(target, prop);\n\t\t\tif (targetDescriptor) {\n\t\t\t\treturn targetDescriptor;\n\t\t\t}\n\t\t\tif (typeof prop === \"string\") {\n\t\t\t\t// Make action methods appear non-enumerable\n\t\t\t\treturn {\n\t\t\t\t\tconfigurable: true,\n\t\t\t\t\tenumerable: false,\n\t\t\t\t\twritable: false,\n\t\t\t\t\tvalue: (...args: unknown[]) => target.action({ name: prop, args }),\n\t\t\t\t};\n\t\t\t}\n\t\t\treturn undefined;\n\t\t},\n\t}) as ActorHandle<AD> | ActorConn<AD>;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/inline-websocket-adapter2.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/inline-websocket-adapter2.ts\";import { WSContext } from \"hono/ws\";\nimport type {\n\tRivetCloseEvent,\n\tRivetEvent,\n\tRivetMessageEvent,\n\tUniversalWebSocket,\n} from \"@/common/websocket-interface\";\nimport { getLogger } from \"./log\";\n\nexport const LOGGER_NAME = \"fake-event-source2\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n\n// TODO: Merge with ConnectWebSocketOutput interface\nexport interface UpgradeWebSocketArgs {\n\tonOpen: (event: any, ws: WSContext) => void;\n\tonMessage: (event: any, ws: WSContext) => void;\n\tonClose: (event: any, ws: WSContext) => void;\n\tonError: (error: any, ws: WSContext) => void;\n}\n\n// TODO: Remove `2` suffix\n/**\n * InlineWebSocketAdapter implements a WebSocket-like interface\n * that connects to a UpgradeWebSocketArgs handler\n */\nexport class InlineWebSocketAdapter2 implements UniversalWebSocket {\n\t// WebSocket readyState values\n\treadonly CONNECTING = 0 as const;\n\treadonly OPEN = 1 as const;\n\treadonly CLOSING = 2 as const;\n\treadonly CLOSED = 3 as const;\n\n\t// Private properties\n\t#handler: UpgradeWebSocketArgs;\n\t#wsContext: WSContext;\n\t#readyState: 0 | 1 | 2 | 3 = 0; // Start in CONNECTING state\n\t#queuedMessages: Array<string | ArrayBuffer | Uint8Array> = [];\n\t// Event buffering is needed since events can be fired\n\t// before JavaScript has a chance to add event listeners (e.g. within the same tick)\n\t#bufferedEvents: Array<{\n\t\ttype: string;\n\t\tevent: any;\n\t}> = [];\n\n\t// Event listeners with buffering\n\t#eventListeners: Map<string, ((ev: any) => void)[]> = new Map();\n\n\tconstructor(handler: UpgradeWebSocketArgs) {\n\t\tthis.#handler = handler;\n\n\t\t// Create a fake WSContext to pass to the handler\n\t\tthis.#wsContext = new WSContext({\n\t\t\traw: this,\n\t\t\tsend: (data: string | ArrayBuffer | Uint8Array) => {\n\t\t\t\tlogger().debug(\"WSContext.send called\");\n\t\t\t\tthis.#handleMessage(data);\n\t\t\t},\n\t\t\tclose: (code?: number, reason?: string) => {\n\t\t\t\tlogger().debug(\"WSContext.close called\", { code, reason });\n\t\t\t\tthis.#handleClose(code || 1000, reason || \"\");\n\t\t\t},\n\t\t\t// Set readyState to 1 (OPEN) since handlers expect an open connection\n\t\t\treadyState: 1,\n\t\t});\n\n\t\t// Initialize the connection\n\t\tthis.#initialize();\n\t}\n\n\tget readyState(): 0 | 1 | 2 | 3 {\n\t\treturn this.#readyState;\n\t}\n\n\tget binaryType(): \"arraybuffer\" | \"blob\" {\n\t\treturn \"arraybuffer\";\n\t}\n\n\tset binaryType(value: \"arraybuffer\" | \"blob\") {\n\t\t// Ignored for now - always use arraybuffer\n\t}\n\n\tget bufferedAmount(): number {\n\t\treturn 0; // Not tracked in InlineWebSocketAdapter\n\t}\n\n\tget extensions(): string {\n\t\treturn \"\"; // Not available in InlineWebSocketAdapter\n\t}\n\n\tget protocol(): string {\n\t\treturn \"\"; // Not available in InlineWebSocketAdapter\n\t}\n\n\tget url(): string {\n\t\treturn \"\"; // Not available in InlineWebSocketAdapter\n\t}\n\n\tsend(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {\n\t\tlogger().debug(\"send called\", { readyState: this.readyState });\n\n\t\tif (this.readyState !== this.OPEN) {\n\t\t\tconst error = new Error(\"WebSocket is not open\");\n\t\t\tlogger().warn(\"cannot send message, websocket not open\", {\n\t\t\t\treadyState: this.readyState,\n\t\t\t\tdataType: typeof data,\n\t\t\t\tdataLength: typeof data === \"string\" ? data.length : \"binary\",\n\t\t\t\terror,\n\t\t\t});\n\t\t\tthis.#fireError(error);\n\t\t\treturn;\n\t\t}\n\n\t\tthis.#handler.onMessage({ data }, this.#wsContext);\n\t}\n\n\t/**\n\t * Closes the connection\n\t */\n\tclose(code = 1000, reason = \"\"): void {\n\t\tif (this.readyState === this.CLOSED || this.readyState === this.CLOSING) {\n\t\t\treturn;\n\t\t}\n\n\t\tlogger().debug(\"closing fake websocket\", { code, reason });\n\n\t\tthis.#readyState = this.CLOSING;\n\n\t\t// Call the handler's onClose method\n\t\ttry {\n\t\t\tthis.#handler.onClose({ code, reason, wasClean: true }, this.#wsContext);\n\t\t} catch (err) {\n\t\t\tlogger().error(\"error closing websocket\", { error: err });\n\t\t} finally {\n\t\t\tthis.#readyState = this.CLOSED;\n\n\t\t\t// Fire the close event\n\t\t\t// Create a close event object since CloseEvent is not available in Node.js\n\t\t\tconst closeEvent = {\n\t\t\t\ttype: \"close\",\n\t\t\t\twasClean: code === 1000,\n\t\t\t\tcode,\n\t\t\t\treason,\n\t\t\t\ttarget: this,\n\t\t\t\tcurrentTarget: this,\n\t\t\t} as unknown as RivetCloseEvent;\n\n\t\t\tthis.#fireClose(closeEvent);\n\t\t}\n\t}\n\n\t/**\n\t * Initialize the connection with the handler\n\t */\n\tasync #initialize(): Promise<void> {\n\t\ttry {\n\t\t\tlogger().debug(\"fake websocket initializing\");\n\n\t\t\t// Call the handler's onOpen method\n\t\t\tlogger().debug(\"calling handler.onOpen with WSContext\");\n\t\t\tthis.#handler.onOpen(undefined, this.#wsContext);\n\n\t\t\t// Update the ready state and fire events\n\t\t\tthis.#readyState = this.OPEN;\n\t\t\tlogger().debug(\"fake websocket initialized and now OPEN\");\n\n\t\t\t// Fire the open event\n\t\t\tthis.#fireOpen();\n\n\t\t\t// Delay processing queued messages slightly to allow event handlers to be set up\n\t\t\tif (this.#queuedMessages.length > 0) {\n\t\t\t\tif (this.readyState !== this.OPEN) {\n\t\t\t\t\tlogger().warn(\"socket no longer open, dropping queued messages\");\n\t\t\t\t\treturn;\n\t\t\t\t}\n\n\t\t\t\tlogger().debug(\n\t\t\t\t\t`now processing ${this.#queuedMessages.length} queued messages`,\n\t\t\t\t);\n\n\t\t\t\t// Create a copy to avoid issues if new messages arrive during processing\n\t\t\t\tconst messagesToProcess = [...this.#queuedMessages];\n\t\t\t\tthis.#queuedMessages = [];\n\n\t\t\t\t// Process each queued message\n\t\t\t\tfor (const message of messagesToProcess) {\n\t\t\t\t\tlogger().debug(\"processing queued message\");\n\t\t\t\t\tthis.#handleMessage(message);\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\tlogger().error(\"error opening fake websocket\", {\n\t\t\t\terror: err,\n\t\t\t\terrorMessage: err instanceof Error ? err.message : String(err),\n\t\t\t\tstack: err instanceof Error ? err.stack : undefined,\n\t\t\t});\n\t\t\tthis.#fireError(err);\n\t\t\tthis.close(1011, \"Internal error during initialization\");\n\t\t}\n\t}\n\n\t/**\n\t * Handle messages received from the server via the WSContext\n\t */\n\t#handleMessage(data: string | ArrayBuffer | Uint8Array): void {\n\t\t// Store messages that arrive before the socket is fully initialized\n\t\tif (this.readyState !== this.OPEN) {\n\t\t\tlogger().debug(\"message received before socket is OPEN, queuing\", {\n\t\t\t\treadyState: this.readyState,\n\t\t\t\tdataType: typeof data,\n\t\t\t\tdataLength:\n\t\t\t\t\ttypeof data === \"string\"\n\t\t\t\t\t\t? data.length\n\t\t\t\t\t\t: data instanceof ArrayBuffer\n\t\t\t\t\t\t\t? data.byteLength\n\t\t\t\t\t\t\t: data instanceof Uint8Array\n\t\t\t\t\t\t\t\t? data.byteLength\n\t\t\t\t\t\t\t\t: \"unknown\",\n\t\t\t});\n\n\t\t\t// Queue the message to be processed once the socket is open\n\t\t\tthis.#queuedMessages.push(data);\n\t\t\treturn;\n\t\t}\n\n\t\t// Log message received from server\n\t\tlogger().debug(\"fake websocket received message from server\", {\n\t\t\tdataType: typeof data,\n\t\t\tdataLength:\n\t\t\t\ttypeof data === \"string\"\n\t\t\t\t\t? data.length\n\t\t\t\t\t: data instanceof ArrayBuffer\n\t\t\t\t\t\t? data.byteLength\n\t\t\t\t\t\t: data instanceof Uint8Array\n\t\t\t\t\t\t\t? data.byteLength\n\t\t\t\t\t\t\t: \"unknown\",\n\t\t});\n\n\t\t// Create a MessageEvent-like object\n\t\tconst event = {\n\t\t\ttype: \"message\",\n\t\t\tdata,\n\t\t\ttarget: this,\n\t\t\tcurrentTarget: this,\n\t\t} as unknown as RivetMessageEvent;\n\n\t\t// Dispatch the event\n\t\tthis.#dispatchEvent(\"message\", event);\n\t}\n\n\t#handleClose(code: number, reason: string): void {\n\t\tif (this.readyState === this.CLOSED) return;\n\n\t\tthis.#readyState = this.CLOSED;\n\n\t\t// Create a CloseEvent-like object\n\t\tconst event = {\n\t\t\ttype: \"close\",\n\t\t\tcode,\n\t\t\treason,\n\t\t\twasClean: code === 1000,\n\t\t\ttarget: this,\n\t\t\tcurrentTarget: this,\n\t\t} as unknown as RivetCloseEvent;\n\n\t\t// Dispatch the event\n\t\tthis.#dispatchEvent(\"close\", event);\n\t}\n\n\taddEventListener(type: string, listener: (ev: any) => void): void {\n\t\tif (!this.#eventListeners.has(type)) {\n\t\t\tthis.#eventListeners.set(type, []);\n\t\t}\n\t\tthis.#eventListeners.get(type)!.push(listener);\n\n\t\t// Flush any buffered events for this type\n\t\tthis.#flushBufferedEvents(type);\n\t}\n\n\tremoveEventListener(type: string, listener: (ev: any) => void): void {\n\t\tconst listeners = this.#eventListeners.get(type);\n\t\tif (listeners) {\n\t\t\tconst index = listeners.indexOf(listener);\n\t\t\tif (index !== -1) {\n\t\t\t\tlisteners.splice(index, 1);\n\t\t\t}\n\t\t}\n\t}\n\n\t#dispatchEvent(type: string, event: any): void {\n\t\tconst listeners = this.#eventListeners.get(type);\n\t\tif (listeners && listeners.length > 0) {\n\t\t\tlogger().debug(\n\t\t\t\t`dispatching ${type} event to ${listeners.length} listeners`,\n\t\t\t);\n\t\t\tfor (const listener of listeners) {\n\t\t\t\ttry {\n\t\t\t\t\tlistener(event);\n\t\t\t\t} catch (err) {\n\t\t\t\t\tlogger().error(`error in ${type} event listener`, { error: err });\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\tlogger().debug(`no ${type} listeners registered, buffering event`);\n\t\t\tthis.#bufferedEvents.push({ type, event });\n\t\t}\n\n\t\t// Also check for on* properties\n\t\tswitch (type) {\n\t\t\tcase \"open\":\n\t\t\t\tif (this.#onopen) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onopen(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onopen handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"close\":\n\t\t\t\tif (this.#onclose) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onclose(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onclose handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"error\":\n\t\t\t\tif (this.#onerror) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onerror(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onerror handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase \"message\":\n\t\t\t\tif (this.#onmessage) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\tthis.#onmessage(event);\n\t\t\t\t\t} catch (error) {\n\t\t\t\t\t\tlogger().error(\"error in onmessage handler\", { error });\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tdispatchEvent(event: RivetEvent): boolean {\n\t\tthis.#dispatchEvent(event.type, event);\n\t\treturn true;\n\t}\n\n\t#flushBufferedEvents(type: string): void {\n\t\tconst eventsToFlush = this.#bufferedEvents.filter(\n\t\t\t(buffered) => buffered.type === type,\n\t\t);\n\t\tthis.#bufferedEvents = this.#bufferedEvents.filter(\n\t\t\t(buffered) => buffered.type !== type,\n\t\t);\n\n\t\tfor (const { event } of eventsToFlush) {\n\t\t\tthis.#dispatchEvent(type, event);\n\t\t}\n\t}\n\n\t#fireOpen(): void {\n\t\ttry {\n\t\t\t// Create an Event-like object since Event constructor may not be available\n\t\t\tconst event = {\n\t\t\t\ttype: \"open\",\n\t\t\t\ttarget: this,\n\t\t\t\tcurrentTarget: this,\n\t\t\t} as unknown as RivetEvent;\n\n\t\t\tthis.#dispatchEvent(\"open\", event);\n\t\t} catch (err) {\n\t\t\tlogger().error(\"error in open event\", { error: err });\n\t\t}\n\t}\n\n\t#fireClose(event: RivetCloseEvent): void {\n\t\ttry {\n\t\t\tthis.#dispatchEvent(\"close\", event);\n\t\t} catch (err) {\n\t\t\tlogger().error(\"error in close event\", { error: err });\n\t\t}\n\t}\n\n\t#fireError(error: unknown): void {\n\t\ttry {\n\t\t\t// Create an Event-like object for error\n\t\t\tconst event = {\n\t\t\t\ttype: \"error\",\n\t\t\t\ttarget: this,\n\t\t\t\tcurrentTarget: this,\n\t\t\t\terror,\n\t\t\t\tmessage: error instanceof Error ? error.message : String(error),\n\t\t\t} as unknown as RivetEvent;\n\n\t\t\tthis.#dispatchEvent(\"error\", event);\n\t\t} catch (err) {\n\t\t\tlogger().error(\"error in error event\", { error: err });\n\t\t}\n\n\t\t// Log the error\n\t\tlogger().error(\"websocket error\", { error });\n\t}\n\n\t// Event handler properties with getters/setters\n\t#onopen: ((event: RivetEvent) => void) | null = null;\n\t#onclose: ((event: RivetCloseEvent) => void) | null = null;\n\t#onerror: ((event: RivetEvent) => void) | null = null;\n\t#onmessage: ((event: RivetMessageEvent) => void) | null = null;\n\n\tget onopen(): ((event: RivetEvent) => void) | null {\n\t\treturn this.#onopen;\n\t}\n\tset onopen(handler: ((event: RivetEvent) => void) | null) {\n\t\tthis.#onopen = handler;\n\t}\n\n\tget onclose(): ((event: RivetCloseEvent) => void) | null {\n\t\treturn this.#onclose;\n\t}\n\tset onclose(handler: ((event: RivetCloseEvent) => void) | null) {\n\t\tthis.#onclose = handler;\n\t}\n\n\tget onerror(): ((event: RivetEvent) => void) | null {\n\t\treturn this.#onerror;\n\t}\n\tset onerror(handler: ((event: RivetEvent) => void) | null) {\n\t\tthis.#onerror = handler;\n\t}\n\n\tget onmessage(): ((event: RivetMessageEvent) => void) | null {\n\t\treturn this.#onmessage;\n\t}\n\tset onmessage(handler: ((event: RivetMessageEvent) => void) | null) {\n\t\tthis.#onmessage = handler;\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/actor-driver.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/actor-driver.ts\";import type {\n\tActorConfig as RunnerActorConfig,\n\tRunnerConfig,\n} from \"@rivetkit/engine-runner\";\nimport { Runner } from \"@rivetkit/engine-runner\";\nimport * as cbor from \"cbor-x\";\nimport { WSContext } from \"hono/ws\";\nimport invariant from \"invariant\";\nimport { EncodingSchema } from \"@/actor/protocol/serde\";\nimport type { Client } from \"@/client/client\";\nimport {\n\ttype ActorDriver,\n\ttype AnyActorInstance,\n\tHEADER_AUTH_DATA,\n\tHEADER_CONN_PARAMS,\n\tHEADER_ENCODING,\n\ttype ManagerDriver,\n\tserializeEmptyPersistData,\n} from \"@/driver-helpers/mod\";\nimport type {\n\tActorRouter,\n\tRegistryConfig,\n\tRunConfig,\n\tUniversalWebSocket,\n\tUpgradeWebSocketArgs,\n} from \"@/mod\";\nimport {\n\tcreateActorRouter,\n\tcreateGenericConnDrivers,\n\tGenericConnGlobalState,\n\thandleRawWebSocketHandler,\n\thandleWebSocketConnect,\n\tlookupInRegistry,\n\tPATH_CONNECT_WEBSOCKET,\n\tPATH_RAW_WEBSOCKET_PREFIX,\n} from \"@/mod\";\nimport type { Config } from \"./config\";\nimport { deserializeActorKey } from \"./keys\";\nimport { KEYS } from \"./kv\";\nimport { logger } from \"./log\";\n\ninterface ActorHandler {\n\tactor?: AnyActorInstance;\n\tactorStartPromise?: PromiseWithResolvers<void>;\n\tgenericConnGlobalState: GenericConnGlobalState;\n\tpersistedData?: Uint8Array;\n}\n\nexport type DriverContext = {};\n\nexport class EngineActorDriver implements ActorDriver {\n\t#registryConfig: RegistryConfig;\n\t#runConfig: RunConfig;\n\t#managerDriver: ManagerDriver;\n\t#inlineClient: Client<any>;\n\t#config: Config;\n\t#runner: Runner;\n\t#actors: Map<string, ActorHandler> = new Map();\n\t#actorRouter: ActorRouter;\n\t#version: number = 1; // Version for the runner protocol\n\n\tconstructor(\n\t\tregistryConfig: RegistryConfig,\n\t\trunConfig: RunConfig,\n\t\tmanagerDriver: ManagerDriver,\n\t\tinlineClient: Client<any>,\n\t\tconfig: Config,\n\t) {\n\t\tthis.#registryConfig = registryConfig;\n\t\tthis.#runConfig = runConfig;\n\t\tthis.#managerDriver = managerDriver;\n\t\tthis.#inlineClient = inlineClient;\n\t\tthis.#config = config;\n\t\tthis.#actorRouter = createActorRouter(runConfig, this);\n\n\t\t// Create runner configuration\n\t\tlet hasDisconnected = false;\n\t\tconst runnerConfig: RunnerConfig = {\n\t\t\tversion: this.#version,\n\t\t\tendpoint: config.endpoint,\n\t\t\tpegboardEndpoint: config.pegboardEndpoint,\n\t\t\tnamespace: config.namespace,\n\t\t\ttotalSlots: config.totalSlots,\n\t\t\trunnerName: config.runnerName,\n\t\t\trunnerKey: config.runnerKey,\n\t\t\tmetadata: {\n\t\t\t\tinspectorToken: this.#runConfig.inspector.token(),\n\t\t\t},\n\t\t\tprepopulateActorNames: Object.fromEntries(\n\t\t\t\tObject.keys(this.#registryConfig.use).map((name) => [\n\t\t\t\t\tname,\n\t\t\t\t\t{ metadata: {} },\n\t\t\t\t]),\n\t\t\t),\n\t\t\tonConnected: () => {\n\t\t\t\tif (hasDisconnected) {\n\t\t\t\t\tlogger().info(\"runner reconnected\", {\n\t\t\t\t\t\tnamespace: this.#config.namespace,\n\t\t\t\t\t\trunnerName: this.#config.runnerName,\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tlogger().debug(\"runner connected\", {\n\t\t\t\t\t\tnamespace: this.#config.namespace,\n\t\t\t\t\t\trunnerName: this.#config.runnerName,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t},\n\t\t\tonDisconnected: () => {\n\t\t\t\tlogger().warn(\"runner disconnected\", {\n\t\t\t\t\tnamespace: this.#config.namespace,\n\t\t\t\t\trunnerName: this.#config.runnerName,\n\t\t\t\t});\n\t\t\t\thasDisconnected = true;\n\t\t\t},\n\t\t\tfetch: this.#runnerFetch.bind(this),\n\t\t\twebsocket: this.#runnerWebSocket.bind(this),\n\t\t\tonActorStart: this.#runnerOnActorStart.bind(this),\n\t\t\tonActorStop: this.#runnerOnActorStop.bind(this),\n\t\t};\n\n\t\t// Create and start runner\n\t\tthis.#runner = new Runner(runnerConfig);\n\t\tthis.#runner.start();\n\t\tlogger().debug(\"engine runner started\", {\n\t\t\tendpoint: config.endpoint,\n\t\t\tnamespace: config.namespace,\n\t\t\trunnerName: config.runnerName,\n\t\t});\n\t}\n\n\tasync #loadActorHandler(actorId: string): Promise<ActorHandler> {\n\t\t// Check if actor is already loaded\n\t\tconst handler = this.#actors.get(actorId);\n\t\tif (!handler) throw new Error(`Actor handler does not exist ${actorId}`);\n\t\tif (handler.actorStartPromise) await handler.actorStartPromise.promise;\n\t\tif (!handler.actor) throw new Error(\"Actor should be loaded\");\n\t\treturn handler;\n\t}\n\n\tasync loadActor(actorId: string): Promise<AnyActorInstance> {\n\t\tconst handler = await this.#loadActorHandler(actorId);\n\t\tif (!handler.actor) throw new Error(`Actor ${actorId} failed to load`);\n\t\treturn handler.actor;\n\t}\n\n\tgetGenericConnGlobalState(actorId: string): GenericConnGlobalState {\n\t\tconst handler = this.#actors.get(actorId);\n\t\tif (!handler) {\n\t\t\tthrow new Error(`Actor ${actorId} not loaded`);\n\t\t}\n\t\treturn handler.genericConnGlobalState;\n\t}\n\n\tgetContext(actorId: string): DriverContext {\n\t\treturn {};\n\t}\n\n\tasync readPersistedData(actorId: string): Promise<Uint8Array | undefined> {\n\t\tconst handler = this.#actors.get(actorId);\n\t\tif (!handler) throw new Error(`Actor ${actorId} not loaded`);\n\t\tif (handler.persistedData) return handler.persistedData;\n\n\t\tconst [value] = await this.#runner.kvGet(actorId, [KEYS.PERSIST_DATA]);\n\n\t\tif (value !== null) {\n\t\t\thandler.persistedData = value;\n\t\t\treturn value;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tasync writePersistedData(actorId: string, data: Uint8Array): Promise<void> {\n\t\tconst handler = this.#actors.get(actorId);\n\t\tif (!handler) throw new Error(`Actor ${actorId} not loaded`);\n\n\t\thandler.persistedData = data;\n\n\t\tawait this.#runner.kvPut(actorId, [[KEYS.PERSIST_DATA, data]]);\n\t}\n\n\tasync setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void> {\n\t\t// TODO: Set timeout\n\t\t// TODO: Use alarm on sleep\n\t\t// TODO: Send alarm to runner\n\t}\n\n\tasync getDatabase(_actorId: string): Promise<unknown | undefined> {\n\t\treturn undefined;\n\t}\n\n\t// Runner lifecycle callbacks\n\tasync #runnerOnActorStart(\n\t\tactorId: string,\n\t\tgeneration: number,\n\t\tconfig: RunnerActorConfig,\n\t): Promise<void> {\n\t\tlogger().debug(\"runner actor starting\", {\n\t\t\tactorId,\n\t\t\tname: config.name,\n\t\t\tkey: config.key,\n\t\t\tgeneration,\n\t\t});\n\n\t\t// Deserialize input\n\t\tlet input: any;\n\t\tif (config.input) {\n\t\t\tinput = cbor.decode(config.input);\n\t\t}\n\n\t\t// Get or create handler\n\t\tlet handler = this.#actors.get(actorId);\n\t\tif (!handler) {\n\t\t\thandler = {\n\t\t\t\tgenericConnGlobalState: new GenericConnGlobalState(),\n\t\t\t\tactorStartPromise: Promise.withResolvers(),\n\t\t\t\tpersistedData: serializeEmptyPersistData(input),\n\t\t\t};\n\t\t\tthis.#actors.set(actorId, handler);\n\t\t}\n\n\t\tconst name = config.name as string;\n\t\tinvariant(config.key, \"actor should have a key\");\n\t\tconst key = deserializeActorKey(config.key);\n\n\t\t// Create actor instance\n\t\tconst definition = lookupInRegistry(\n\t\t\tthis.#registryConfig,\n\t\t\tconfig.name as string, // TODO: Remove cast\n\t\t);\n\t\thandler.actor = definition.instantiate();\n\n\t\t// Start actor\n\t\tconst connDrivers = createGenericConnDrivers(\n\t\t\thandler.genericConnGlobalState,\n\t\t);\n\t\tawait handler.actor.start(\n\t\t\tconnDrivers,\n\t\t\tthis,\n\t\t\tthis.#inlineClient,\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t\t\"unknown\", // TODO: Add regions\n\t\t);\n\n\t\t// Resolve promise if waiting\n\t\thandler.actorStartPromise?.resolve();\n\t\thandler.actorStartPromise = undefined;\n\n\t\tlogger().debug(\"runner actor started\", { actorId, name, key });\n\t}\n\n\tasync #runnerOnActorStop(actorId: string, generation: number): Promise<void> {\n\t\tlogger().debug(\"runner actor stopping\", { actorId, generation });\n\n\t\tconst handler = this.#actors.get(actorId);\n\t\tif (handler?.actor) {\n\t\t\tawait handler.actor._stop();\n\t\t\tthis.#actors.delete(actorId);\n\t\t}\n\n\t\tlogger().debug(\"runner actor stopped\", { actorId });\n\t}\n\n\tasync #runnerFetch(actorId: string, request: Request): Promise<Response> {\n\t\tlogger().debug(\"runner fetch\", {\n\t\t\tactorId,\n\t\t\turl: request.url,\n\t\t\tmethod: request.method,\n\t\t});\n\t\treturn await this.#actorRouter.fetch(request, { actorId });\n\t}\n\n\tasync #runnerWebSocket(\n\t\tactorId: string,\n\t\twebsocketRaw: any,\n\t\trequest: Request,\n\t): Promise<void> {\n\t\tconst websocket = websocketRaw as UniversalWebSocket;\n\n\t\tlogger().debug(\"runner websocket\", { actorId, url: request.url });\n\n\t\tconst url = new URL(request.url);\n\n\t\t// Parse headers\n\t\tconst encodingRaw = request.headers.get(HEADER_ENCODING);\n\t\tconst connParamsRaw = request.headers.get(HEADER_CONN_PARAMS);\n\t\tconst authDataRaw = request.headers.get(HEADER_AUTH_DATA);\n\n\t\tconst encoding = EncodingSchema.parse(encodingRaw);\n\t\tconst connParams = connParamsRaw ? JSON.parse(connParamsRaw) : undefined;\n\t\tconst authData = authDataRaw ? JSON.parse(authDataRaw) : undefined;\n\n\t\t// Fetch WS handler\n\t\t//\n\t\t// We store the promise since we need to add WebSocket event listeners immediately that will wait for the promise to resolve\n\t\tlet wsHandlerPromise: Promise<UpgradeWebSocketArgs>;\n\t\tif (url.pathname === PATH_CONNECT_WEBSOCKET) {\n\t\t\twsHandlerPromise = handleWebSocketConnect(\n\t\t\t\trequest,\n\t\t\t\tthis.#runConfig,\n\t\t\t\tthis,\n\t\t\t\tactorId,\n\t\t\t\tencoding,\n\t\t\t\tconnParams,\n\t\t\t\tauthData,\n\t\t\t);\n\t\t} else if (url.pathname.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {\n\t\t\twsHandlerPromise = handleRawWebSocketHandler(\n\t\t\t\trequest,\n\t\t\t\turl.pathname + url.search,\n\t\t\t\tthis,\n\t\t\t\tactorId,\n\t\t\t\tauthData,\n\t\t\t);\n\t\t} else {\n\t\t\tthrow new Error(`Unreachable path: ${url.pathname}`);\n\t\t}\n\n\t\t// TODO: Add close\n\n\t\t// Connect the Hono WS hook to the adapter\n\t\tconst wsContext = new WSContext(websocket);\n\n\t\twsHandlerPromise.catch((err) => {\n\t\t\tlogger().error(\"building websocket handlers errored\", { err });\n\t\t\twsContext.close(1011, `${err}`);\n\t\t});\n\n\t\tif (websocket.readyState === 1) {\n\t\t\twsHandlerPromise.then((x) => x.onOpen?.(new Event(\"open\"), wsContext));\n\t\t} else {\n\t\t\twebsocket.addEventListener(\"open\", (event) => {\n\t\t\t\twsHandlerPromise.then((x) => x.onOpen?.(event, wsContext));\n\t\t\t});\n\t\t}\n\n\t\twebsocket.addEventListener(\"message\", (event) => {\n\t\t\twsHandlerPromise.then((x) => x.onMessage?.(event, wsContext));\n\t\t});\n\n\t\twebsocket.addEventListener(\"close\", (event) => {\n\t\t\twsHandlerPromise.then((x) => x.onClose?.(event, wsContext));\n\t\t});\n\n\t\twebsocket.addEventListener(\"error\", (event) => {\n\t\t\twsHandlerPromise.then((x) => x.onError?.(event, wsContext));\n\t\t});\n\t}\n\n\tasync sleep(actorId: string) {\n\t\tthis.#runner.sleepActor(actorId);\n\t}\n\n\tasync shutdown(immediate: boolean): Promise<void> {\n\t\tlogger().info(\"stopping engine actor driver\");\n\t\tawait this.#runner.shutdown(immediate);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry/run-config.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/registry/run-config.ts\";import type { cors } from \"hono/cors\";\nimport { z } from \"zod\";\nimport type { ActorDriverBuilder } from \"@/actor/driver\";\nimport { InspectorConfigSchema } from \"@/inspector/config\";\nimport type { ManagerDriverBuilder } from \"@/manager/driver\";\nimport type { UpgradeWebSocket } from \"@/utils\";\n\ntype CorsOptions = NonNullable<Parameters<typeof cors>[0]>;\n\nexport type GetUpgradeWebSocket = () => UpgradeWebSocket;\n\nexport const DriverConfigSchema = z.object({\n\t/** Machine-readable name to identify this driver by. */\n\tname: z.string(),\n\tmanager: z.custom<ManagerDriverBuilder>(),\n\tactor: z.custom<ActorDriverBuilder>(),\n});\n\nexport type DriverConfig = z.infer<typeof DriverConfigSchema>;\n\n/** Base config used for the actor config across all platforms. */\nexport const RunConfigSchema = z\n\t.object({\n\t\tdriver: DriverConfigSchema.optional(),\n\n\t\t/** Endpoint to connect to the Rivet engine. Can be configured via RIVET_ENGINE env var. */\n\t\tengine: z.string().optional(),\n\n\t\t// This is a function to allow for lazy configuration of upgradeWebSocket on the\n\t\t// fly. This is required since the dependencies that profie upgradeWebSocket\n\t\t// (specifically Node.js) can sometimes only be specified after the router is\n\t\t// created or must be imported async using `await import(...)`\n\t\tgetUpgradeWebSocket: z.custom<GetUpgradeWebSocket>().optional(),\n\n\t\trole: z.enum([\"all\", \"server\", \"runner\"]).optional().default(\"all\"),\n\n\t\t/** CORS configuration for the router. Uses Hono's CORS middleware options. */\n\t\tcors: z.custom<CorsOptions>().optional(),\n\n\t\tmaxIncomingMessageSize: z.number().optional().default(65_536),\n\n\t\tinspector: InspectorConfigSchema,\n\n\t\t/**\n\t\t * Base path for the router. This is used to prefix all routes.\n\t\t * For example, if the base path is `/api`, then the route `/actors` will be\n\t\t * available at `/api/actors`.\n\t\t */\n\t\tbasePath: z.string().optional().default(\"/\"),\n\t})\n\t.default({});\n\nexport type RunConfig = z.infer<typeof RunConfigSchema>;\nexport type RunConfigInput = z.input<typeof RunConfigSchema>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/config.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/config.ts\";import type { cors } from \"hono/cors\";\nimport { z } from \"zod\";\nimport { HEADER_ACTOR_QUERY } from \"@/driver-helpers/mod\";\nimport { getEnvUniversal } from \"@/utils\";\n\ntype CorsOptions = NonNullable<Parameters<typeof cors>[0]>;\n\nconst defaultTokenFn = () => {\n\tconst envToken = getEnvUniversal(\"RIVETKIT_INSPECTOR_TOKEN\");\n\n\tif (envToken) {\n\t\treturn envToken;\n\t}\n\n\treturn \"\";\n};\n\nconst defaultEnabled = () => {\n\treturn (\n\t\tgetEnvUniversal(\"NODE_ENV\") !== \"production\" ||\n\t\t!getEnvUniversal(\"RIVETKIT_INSPECTOR_DISABLE\")\n\t);\n};\n\nconst defaultInspectorOrigins = [\n\t\"http://localhost:43708\",\n\t\"https://studio.rivet.gg\",\n];\n\nconst defaultCors: CorsOptions = {\n\torigin: (origin) => {\n\t\tif (\n\t\t\tdefaultInspectorOrigins.includes(origin) ||\n\t\t\t(origin.startsWith(\"https://\") && origin.endsWith(\"rivet-gg.vercel.app\"))\n\t\t) {\n\t\t\treturn origin;\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t},\n\tallowMethods: [\"GET\", \"POST\", \"PUT\", \"PATCH\", \"DELETE\", \"OPTIONS\"],\n\tallowHeaders: [\n\t\t\"Content-Type\",\n\t\t\"Authorization\",\n\t\tHEADER_ACTOR_QUERY,\n\t\t\"last-event-id\",\n\t],\n\tmaxAge: 3600,\n\tcredentials: true,\n};\n\nexport const InspectorConfigSchema = z\n\t.object({\n\t\tenabled: z.boolean().optional().default(defaultEnabled),\n\t\t/** CORS configuration for the router. Uses Hono's CORS middleware options. */\n\t\tcors: z\n\t\t\t.custom<CorsOptions>()\n\t\t\t.optional()\n\t\t\t.default(() => defaultCors),\n\n\t\t/**\n\t\t * Token used to access the Inspector.\n\t\t */\n\t\ttoken: z\n\t\t\t.function()\n\t\t\t.returns(z.string())\n\t\t\t.optional()\n\t\t\t.default(() => defaultTokenFn),\n\n\t\t/**\n\t\t * Default RivetKit server endpoint for Rivet Inspector to connect to. This should be the same endpoint as what you use for your Rivet client to connect to RivetKit.\n\t\t *\n\t\t * This is a convenience property just for printing out the inspector URL.\n\t\t */\n\t\tdefaultEndpoint: z.string().optional(),\n\t})\n\t.optional()\n\t.default(() => ({\n\t\tenabled: defaultEnabled(),\n\t\ttoken: defaultTokenFn,\n\t\tcors: defaultCors,\n\t}));\nexport type InspectorConfig = z.infer<typeof InspectorConfigSchema>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/driver-helpers/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/driver-helpers\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/driver-helpers/utils.ts\";import * as cbor from \"cbor-x\";\nimport type * as schema from \"@/schemas/actor-persist/mod\";\nimport { PERSISTED_ACTOR_VERSIONED } from \"@/schemas/actor-persist/versioned\";\nimport { bufferToArrayBuffer } from \"@/utils\";\n\nexport function serializeEmptyPersistData(\n\tinput: unknown | undefined,\n): Uint8Array {\n\tconst persistData: schema.PersistedActor = {\n\t\tinput: input !== undefined ? bufferToArrayBuffer(cbor.encode(input)) : null,\n\t\thasInitialized: false,\n\t\tstate: bufferToArrayBuffer(cbor.encode(undefined)),\n\t\tconnections: [],\n\t\tscheduledEvents: [],\n\t};\n\treturn PERSISTED_ACTOR_VERSIONED.serializeWithEmbeddedVersion(persistData);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/keys.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/keys.ts\";import type { ActorKey } from \"@/mod\";\n\nexport const EMPTY_KEY = \"/\";\nexport const KEY_SEPARATOR = \"/\";\n\nexport function serializeActorKey(key: ActorKey): string {\n\t// Use a special marker for empty key arrays\n\tif (key.length === 0) {\n\t\treturn EMPTY_KEY;\n\t}\n\n\t// Escape each key part to handle the separator and the empty key marker\n\tconst escapedParts = key.map((part) => {\n\t\t// Handle empty strings by using a special marker\n\t\tif (part === \"\") {\n\t\t\treturn \"\\\\0\"; // Use \\0 as a marker for empty strings\n\t\t}\n\n\t\t// Escape backslashes first to avoid conflicts with our markers\n\t\tlet escaped = part.replace(/\\\\/g, \"\\\\\\\\\");\n\n\t\t// Then escape separators\n\t\tescaped = escaped.replace(/\\//g, `\\\\${KEY_SEPARATOR}`);\n\n\t\treturn escaped;\n\t});\n\n\treturn escapedParts.join(KEY_SEPARATOR);\n}\n\nexport function deserializeActorKey(keyString: string | undefined): ActorKey {\n\t// Check for special empty key marker\n\tif (\n\t\tkeyString === undefined ||\n\t\tkeyString === null ||\n\t\tkeyString === EMPTY_KEY\n\t) {\n\t\treturn [];\n\t}\n\n\t// Split by unescaped separators and unescape the escaped characters\n\tconst parts: string[] = [];\n\tlet currentPart = \"\";\n\tlet escaping = false;\n\tlet isEmptyStringMarker = false;\n\n\tfor (let i = 0; i < keyString.length; i++) {\n\t\tconst char = keyString[i];\n\n\t\tif (escaping) {\n\t\t\t// Handle special escape sequences\n\t\t\tif (char === \"0\") {\n\t\t\t\t// \\0 represents an empty string marker\n\t\t\t\tisEmptyStringMarker = true;\n\t\t\t} else {\n\t\t\t\t// This is an escaped character, add it directly\n\t\t\t\tcurrentPart += char;\n\t\t\t}\n\t\t\tescaping = false;\n\t\t} else if (char === \"\\\\\") {\n\t\t\t// Start of an escape sequence\n\t\t\tescaping = true;\n\t\t} else if (char === KEY_SEPARATOR) {\n\t\t\t// This is a separator\n\t\t\tif (isEmptyStringMarker) {\n\t\t\t\tparts.push(\"\");\n\t\t\t\tisEmptyStringMarker = false;\n\t\t\t} else {\n\t\t\t\tparts.push(currentPart);\n\t\t\t}\n\t\t\tcurrentPart = \"\";\n\t\t} else {\n\t\t\t// Regular character\n\t\t\tcurrentPart += char;\n\t\t}\n\t}\n\n\t// Add the last part\n\tif (escaping) {\n\t\t// Incomplete escape at the end - treat as literal backslash\n\t\tparts.push(currentPart + \"\\\\\");\n\t} else if (isEmptyStringMarker) {\n\t\tparts.push(\"\");\n\t} else if (currentPart !== \"\" || parts.length > 0) {\n\t\tparts.push(currentPart);\n\t}\n\n\treturn parts;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/kv.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/kv.ts\";export const KEYS = {\n\tPERSIST_DATA: Uint8Array.from([1, 1]),\n};\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/log.ts\";import { getLogger } from \"@/common/log\";\n\nexport const LOGGER_NAME = \"driver-engine\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/config.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/config.ts\";import type { Hono } from \"hono\";\nimport { z } from \"zod\";\nimport { getEnvUniversal } from \"@/utils\";\n\nexport const ConfigSchema = z\n\t.object({\n\t\tapp: z.custom<Hono>().optional(),\n\t\tendpoint: z\n\t\t\t.string()\n\t\t\t.default(\n\t\t\t\t() => getEnvUniversal(\"RIVET_ENGINE\") ?? \"http://localhost:7080\",\n\t\t\t),\n\t\tpegboardEndpoint: z.string().optional(),\n\t\tnamespace: z\n\t\t\t.string()\n\t\t\t.default(() => getEnvUniversal(\"RIVET_NAMESPACE\") ?? \"default\"),\n\t\trunnerName: z\n\t\t\t.string()\n\t\t\t.default(() => getEnvUniversal(\"RIVET_RUNNER\") ?? \"rivetkit\"),\n\t\t// TODO: Automatically attempt ot determine key by common env vars (e.g. k8s pod name)\n\t\trunnerKey: z\n\t\t\t.string()\n\t\t\t.default(\n\t\t\t\t() => getEnvUniversal(\"RIVET_RUNNER_KEY\") ?? crypto.randomUUID(),\n\t\t\t),\n\t\ttotalSlots: z.number().default(100_000),\n\t\taddresses: z\n\t\t\t.record(\n\t\t\t\tz.object({\n\t\t\t\t\thost: z.string(),\n\t\t\t\t\tport: z.number(),\n\t\t\t\t}),\n\t\t\t)\n\t\t\t.default({ main: { host: \"127.0.0.1\", port: 5051 } }),\n\t})\n\t.default({});\n\nexport type InputConfig = z.input<typeof ConfigSchema>;\nexport type Config = z.infer<typeof ConfigSchema>;\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/manager-driver.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/manager-driver.ts\";import * as cbor from \"cbor-x\";\nimport type { Context as HonoContext } from \"hono\";\nimport invariant from \"invariant\";\nimport { ActorAlreadyExists } from \"@/actor/errors\";\nimport {\n\tHEADER_AUTH_DATA,\n\tHEADER_CONN_PARAMS,\n\tHEADER_ENCODING,\n\tHEADER_EXPOSE_INTERNAL_ERROR,\n} from \"@/actor/router-endpoints\";\nimport { generateRandomString } from \"@/actor/utils\";\nimport { importWebSocket } from \"@/common/websocket\";\nimport type {\n\tActorOutput,\n\tCreateInput,\n\tGetForIdInput,\n\tGetOrCreateWithKeyInput,\n\tGetWithKeyInput,\n\tManagerDriver,\n} from \"@/driver-helpers/mod\";\nimport { type Encoding, noopNext, type RunConfig } from \"@/mod\";\nimport {\n\tcreateActor,\n\tdestroyActor,\n\tgetActor,\n\tgetActorById,\n\tgetOrCreateActorById,\n} from \"./api-endpoints\";\nimport { EngineApiError } from \"./api-utils\";\nimport type { Config } from \"./config\";\nimport { deserializeActorKey, serializeActorKey } from \"./keys\";\nimport { logger } from \"./log\";\nimport { createWebSocketProxy } from \"./ws-proxy\";\n\nexport class EngineManagerDriver implements ManagerDriver {\n\t#config: Config;\n\t#runConfig: RunConfig;\n\t#importWebSocketPromise: Promise<typeof WebSocket>;\n\n\tconstructor(config: Config, runConfig: RunConfig) {\n\t\tthis.#config = config;\n\t\tthis.#runConfig = runConfig;\n\t\tif (!this.#runConfig.inspector.token()) {\n\t\t\tconst token = generateRandomString();\n\t\t\tthis.#runConfig.inspector.token = () => token;\n\t\t}\n\t\tthis.#importWebSocketPromise = importWebSocket();\n\t}\n\n\tasync sendRequest(actorId: string, actorRequest: Request): Promise<Response> {\n\t\tlogger().debug(\"sending request to actor via guard\", {\n\t\t\tactorId,\n\t\t\tmethod: actorRequest.method,\n\t\t\turl: actorRequest.url,\n\t\t});\n\n\t\treturn this.#forwardHttpRequest(actorRequest, actorId);\n\t}\n\n\tasync openWebSocket(\n\t\tpath: string,\n\t\tactorId: string,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t): Promise<WebSocket> {\n\t\tconst WebSocket = await this.#importWebSocketPromise;\n\n\t\t// WebSocket connections go through guard\n\t\tconst guardUrl = `${this.#config.endpoint}${path}`;\n\n\t\tlogger().debug(\"opening websocket to actor via guard\", {\n\t\t\tactorId,\n\t\t\tpath,\n\t\t\tguardUrl,\n\t\t});\n\n\t\t// Create WebSocket connection\n\t\tconst ws = new WebSocket(guardUrl, {\n\t\t\theaders: buildGuardHeadersForWebSocket(actorId, encoding, params),\n\t\t});\n\n\t\tlogger().debug(\"websocket connection opened\", { actorId });\n\n\t\treturn ws;\n\t}\n\n\tasync proxyRequest(\n\t\t_c: HonoContext,\n\t\tactorRequest: Request,\n\t\tactorId: string,\n\t): Promise<Response> {\n\t\tlogger().debug(\"forwarding request to actor via guard\", {\n\t\t\tactorId,\n\t\t\tmethod: actorRequest.method,\n\t\t\turl: actorRequest.url,\n\t\t\thasBody: !!actorRequest.body,\n\t\t});\n\n\t\treturn this.#forwardHttpRequest(actorRequest, actorId);\n\t}\n\n\tasync proxyWebSocket(\n\t\tc: HonoContext,\n\t\tpath: string,\n\t\tactorId: string,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t\tauthData: unknown,\n\t): Promise<Response> {\n\t\tconst upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();\n\t\tinvariant(upgradeWebSocket, \"missing getUpgradeWebSocket\");\n\n\t\tconst guardUrl = `${this.#config.endpoint}${path}`;\n\t\tconst wsGuardUrl = guardUrl.replace(\"http://\", \"ws://\");\n\n\t\tlogger().debug(\"forwarding websocket to actor via guard\", {\n\t\t\tactorId,\n\t\t\tpath,\n\t\t\tguardUrl,\n\t\t});\n\n\t\t// Build headers\n\t\tconst headers = buildGuardHeadersForWebSocket(\n\t\t\tactorId,\n\t\t\tencoding,\n\t\t\tparams,\n\t\t\tauthData,\n\t\t);\n\t\tconst args = await createWebSocketProxy(c, wsGuardUrl, headers);\n\n\t\treturn await upgradeWebSocket(() => args)(c, noopNext());\n\t}\n\n\textraStartupLog() {\n\t\treturn {\n\t\t\tengine: this.#config.endpoint,\n\t\t\tnamespace: this.#config.namespace,\n\t\t\trunner: this.#config.runnerName,\n\t\t\taddress: Object.values(this.#config.addresses)\n\t\t\t\t.map((v) => `${v.host}:${v.port}`)\n\t\t\t\t.join(\", \"),\n\t\t};\n\t}\n\n\tasync getForId({\n\t\tc,\n\t\tname,\n\t\tactorId,\n\t}: GetForIdInput): Promise<ActorOutput | undefined> {\n\t\t// Fetch from API if not in cache\n\t\ttry {\n\t\t\tconst response = await getActor(this.#config, actorId);\n\n\t\t\t// Validate name matches\n\t\t\tif (response.actor.name !== name) {\n\t\t\t\tlogger().debug(\"actor name mismatch from api\", {\n\t\t\t\t\tactorId,\n\t\t\t\t\tapiName: response.actor.name,\n\t\t\t\t\trequestedName: name,\n\t\t\t\t});\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\tconst keyRaw = response.actor.key;\n\t\t\tinvariant(keyRaw, `actor ${actorId} should have key`);\n\t\t\tconst key = deserializeActorKey(keyRaw);\n\n\t\t\treturn {\n\t\t\t\tactorId,\n\t\t\t\tname,\n\t\t\t\tkey,\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tif (\n\t\t\t\terror instanceof EngineApiError &&\n\t\t\t\t(error as EngineApiError).group === \"actor\" &&\n\t\t\t\t(error as EngineApiError).code === \"not_found\"\n\t\t\t) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync getWithKey({\n\t\tc,\n\t\tname,\n\t\tkey,\n\t}: GetWithKeyInput): Promise<ActorOutput | undefined> {\n\t\tlogger().debug(\"getWithKey: searching for actor\", { name, key });\n\n\t\t// If not in local cache, fetch by key from API\n\t\ttry {\n\t\t\tconst response = await getActorById(this.#config, name, key);\n\n\t\t\tif (!response.actor_id) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\n\t\t\tconst actorId = response.actor_id;\n\n\t\t\tlogger().debug(\"getWithKey: found actor via api\", {\n\t\t\t\tactorId,\n\t\t\t\tname,\n\t\t\t\tkey,\n\t\t\t});\n\n\t\t\treturn {\n\t\t\t\tactorId,\n\t\t\t\tname,\n\t\t\t\tkey,\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tif (\n\t\t\t\terror instanceof EngineApiError &&\n\t\t\t\t(error as EngineApiError).group === \"actor\" &&\n\t\t\t\t(error as EngineApiError).code === \"not_found\"\n\t\t\t) {\n\t\t\t\treturn undefined;\n\t\t\t}\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync getOrCreateWithKey(\n\t\tinput: GetOrCreateWithKeyInput,\n\t): Promise<ActorOutput> {\n\t\tconst { c, name, key, input: actorInput, region } = input;\n\n\t\tlogger().info(\n\t\t\t\"getOrCreateWithKey: getting or creating actor via engine api\",\n\t\t\t{\n\t\t\t\tname,\n\t\t\t\tkey,\n\t\t\t},\n\t\t);\n\n\t\tconst response = await getOrCreateActorById(this.#config, {\n\t\t\tname,\n\t\t\tkey: serializeActorKey(key),\n\t\t\trunner_name_selector: this.#config.runnerName,\n\t\t\tinput: input ? cbor.encode(actorInput).toString(\"base64\") : undefined,\n\t\t\tcrash_policy: \"sleep\",\n\t\t});\n\n\t\tconst actorId = response.actor_id;\n\n\t\tlogger().info(\"getOrCreateWithKey: actor ready\", {\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t\tcreated: response.created,\n\t\t});\n\n\t\treturn {\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t};\n\t}\n\n\tasync createActor({\n\t\tc,\n\t\tname,\n\t\tkey,\n\t\tinput,\n\t}: CreateInput): Promise<ActorOutput> {\n\t\t// Check if actor with the same name and key already exists\n\t\tconst existingActor = await this.getWithKey({ c, name, key });\n\t\tif (existingActor) {\n\t\t\tthrow new ActorAlreadyExists(name, key);\n\t\t}\n\n\t\tlogger().info(\"creating actor via engine api\", { name, key });\n\n\t\t// Create actor via engine API\n\t\tconst result = await createActor(this.#config, {\n\t\t\tname,\n\t\t\trunner_name_selector: this.#config.runnerName,\n\t\t\tkey: serializeActorKey(key),\n\t\t\tinput: input ? cbor.encode(input).toString(\"base64\") : null,\n\t\t\tcrash_policy: \"sleep\",\n\t\t});\n\t\tconst actorId = result.actor.actor_id;\n\n\t\tlogger().info(\"actor created\", { actorId, name, key });\n\n\t\treturn {\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t};\n\t}\n\n\tasync destroyActor(actorId: string): Promise<void> {\n\t\tlogger().info(\"destroying actor via engine api\", { actorId });\n\n\t\tawait destroyActor(this.#config, actorId);\n\n\t\tlogger().info(\"actor destroyed\", { actorId });\n\t}\n\n\tasync #forwardHttpRequest(\n\t\tactorRequest: Request,\n\t\tactorId: string,\n\t): Promise<Response> {\n\t\t// Route through guard port\n\t\tconst url = new URL(actorRequest.url);\n\t\tconst guardUrl = `${this.#config.endpoint}${url.pathname}${url.search}`;\n\n\t\t// Handle body properly based on method and presence\n\t\tlet bodyToSend: ArrayBuffer | null = null;\n\t\tconst guardHeaders = buildGuardHeadersForHttp(actorRequest, actorId);\n\n\t\tif (\n\t\t\tactorRequest.body &&\n\t\t\tactorRequest.method !== \"GET\" &&\n\t\t\tactorRequest.method !== \"HEAD\"\n\t\t) {\n\t\t\tif (actorRequest.bodyUsed) {\n\t\t\t\tthrow new Error(\"Request body has already been consumed\");\n\t\t\t}\n\n\t\t\t// TODO: This buffers the entire request in memory every time. We\n\t\t\t// need to properly implement streaming bodies.\n\t\t\t// Clone and read the body to ensure it can be sent\n\t\t\tconst clonedRequest = actorRequest.clone();\n\t\t\tbodyToSend = await clonedRequest.arrayBuffer();\n\n\t\t\t// If this is a streaming request, we need to convert the headers\n\t\t\t// for the basic array buffer\n\t\t\tguardHeaders.delete(\"transfer-encoding\");\n\t\t\tguardHeaders.set(\n\t\t\t\t\"content-length\",\n\t\t\t\tString((bodyToSend as ArrayBuffer).byteLength),\n\t\t\t);\n\t\t}\n\n\t\tconst guardRequest = new Request(guardUrl, {\n\t\t\tmethod: actorRequest.method,\n\t\t\theaders: guardHeaders,\n\t\t\tbody: bodyToSend,\n\t\t});\n\n\t\treturn mutableResponse(await fetch(guardRequest));\n\t}\n}\n\nfunction mutableResponse(fetchRes: Response): Response {\n\t// We cannot return the raw response from `fetch` since the response type is not mutable.\n\t//\n\t// In order for middleware to be able to mutate the response, we need to build a new Response object that is mutable.\n\treturn new Response(fetchRes.body, fetchRes);\n}\n\nfunction buildGuardHeadersForHttp(\n\tactorRequest: Request,\n\tactorId: string,\n): Headers {\n\tconst headers = new Headers();\n\t// Copy all headers from the original request\n\tfor (const [key, value] of actorRequest.headers.entries()) {\n\t\theaders.set(key, value);\n\t}\n\t// Add guard-specific headers\n\theaders.set(\"x-rivet-target\", \"actor\");\n\theaders.set(\"x-rivet-actor\", actorId);\n\theaders.set(\"x-rivet-port\", \"main\");\n\treturn headers;\n}\n\nfunction buildGuardHeadersForWebSocket(\n\tactorId: string,\n\tencoding: Encoding,\n\tparams?: unknown,\n\tauthData?: unknown,\n): Record<string, string> {\n\tconst headers: Record<string, string> = {};\n\theaders[\"x-rivet-target\"] = \"actor\";\n\theaders[\"x-rivet-actor\"] = actorId;\n\theaders[\"x-rivet-port\"] = \"main\";\n\theaders[HEADER_EXPOSE_INTERNAL_ERROR] = \"true\";\n\theaders[HEADER_ENCODING] = encoding;\n\tif (params) {\n\t\theaders[HEADER_CONN_PARAMS] = JSON.stringify(params);\n\t}\n\tif (authData) {\n\t\theaders[HEADER_AUTH_DATA] = JSON.stringify(authData);\n\t}\n\treturn headers;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/websocket.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/websocket.ts\";import { logger } from \"@/client/log\";\n\n// Global singleton promise that will be reused for subsequent calls\nlet webSocketPromise: Promise<typeof WebSocket> | null = null;\n\nexport async function importWebSocket(): Promise<typeof WebSocket> {\n\t// Return existing promise if we already started loading\n\tif (webSocketPromise !== null) {\n\t\treturn webSocketPromise;\n\t}\n\n\t// Create and store the promise\n\twebSocketPromise = (async () => {\n\t\tlet _WebSocket: typeof WebSocket;\n\n\t\tif (typeof WebSocket !== \"undefined\") {\n\t\t\t// Browser environment\n\t\t\t_WebSocket = WebSocket as unknown as typeof WebSocket;\n\t\t\tlogger().debug(\"using native websocket\");\n\t\t} else {\n\t\t\t// Node.js environment\n\t\t\ttry {\n\t\t\t\tconst ws = await import(\"ws\");\n\t\t\t\t_WebSocket = ws.default as unknown as typeof WebSocket;\n\t\t\t\tlogger().debug(\"using websocket from npm\");\n\t\t\t} catch {\n\t\t\t\t// WS not available\n\t\t\t\t_WebSocket = class MockWebSocket {\n\t\t\t\t\tconstructor() {\n\t\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t\t'WebSocket support requires installing the \"ws\" peer dependency.',\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} as unknown as typeof WebSocket;\n\t\t\t\tlogger().debug(\"using mock websocket\");\n\t\t\t}\n\t\t}\n\n\t\treturn _WebSocket;\n\t})();\n\n\treturn webSocketPromise;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/api-utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/api-utils.ts\";import { logger } from \"./log\";\n\n// Error class for Engine API errors\nexport class EngineApiError extends Error {\n\tconstructor(\n\t\tpublic readonly group: string,\n\t\tpublic readonly code: string,\n\t\tmessage?: string,\n\t) {\n\t\tsuper(message || `Engine API error: ${group}/${code}`);\n\t\tthis.name = \"EngineApiError\";\n\t}\n}\n\n// Helper function for making API calls\nexport async function apiCall<TInput = unknown, TOutput = unknown>(\n\tendpoint: string,\n\tnamespace: string,\n\tmethod: \"GET\" | \"POST\" | \"PUT\" | \"DELETE\",\n\tpath: string,\n\tbody?: TInput,\n): Promise<TOutput> {\n\tconst url = `${endpoint}${path}${path.includes(\"?\") ? \"&\" : \"?\"}namespace=${encodeURIComponent(namespace)}`;\n\n\tconst options: RequestInit = {\n\t\tmethod,\n\t\theaders: {\n\t\t\t\"Content-Type\": \"application/json\",\n\t\t},\n\t};\n\n\tif (body !== undefined && method !== \"GET\") {\n\t\toptions.body = JSON.stringify(body);\n\t}\n\n\tlogger().debug(\"making api call\", { method, url });\n\n\tconst response = await fetch(url, options);\n\n\tif (!response.ok) {\n\t\tconst errorText = await response.text();\n\t\tlogger().error(\"api call failed\", {\n\t\t\tstatus: response.status,\n\t\t\tstatusText: response.statusText,\n\t\t\terror: errorText,\n\t\t\tmethod,\n\t\t\tpath,\n\t\t});\n\n\t\t// Try to parse error response\n\t\ttry {\n\t\t\tconst errorData = JSON.parse(errorText);\n\t\t\tif (errorData.kind === \"error\" && errorData.group && errorData.code) {\n\t\t\t\tthrow new EngineApiError(\n\t\t\t\t\terrorData.group,\n\t\t\t\t\terrorData.code,\n\t\t\t\t\terrorData.message,\n\t\t\t\t);\n\t\t\t}\n\t\t} catch (parseError) {\n\t\t\t// If parsing fails or it's not our expected error format, continue\n\t\t}\n\n\t\tthrow new Error(\n\t\t\t`API call failed: ${response.status} ${response.statusText}`,\n\t\t);\n\t}\n\n\treturn response.json() as Promise<TOutput>;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/api-endpoints.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/api-endpoints.ts\";import { apiCall } from \"./api-utils\";\nimport type { Config } from \"./config\";\nimport { serializeActorKey } from \"./keys\";\n\n// MARK: Common types\nexport type RivetId = string;\n\nexport interface Actor {\n\tactor_id: RivetId;\n\tname: string;\n\tkey: string;\n\tnamespace_id: RivetId;\n\trunner_name_selector: string;\n\tcreate_ts: number;\n\tconnectable_ts?: number | null;\n\tdestroy_ts?: number | null;\n\tsleep_ts?: number | null;\n\tstart_ts?: number | null;\n}\n\nexport interface ActorsGetResponse {\n\tactor: Actor;\n}\n\nexport interface ActorsGetByIdResponse {\n\tactor_id?: RivetId | null;\n}\n\nexport interface ActorsGetOrCreateResponse {\n\tactor: Actor;\n\tcreated: boolean;\n}\n\nexport interface ActorsGetOrCreateByIdResponse {\n\tactor_id: RivetId;\n\tcreated: boolean;\n}\n\nexport interface ActorsCreateRequest {\n\tname: string;\n\trunner_name_selector: string;\n\tcrash_policy: string;\n\tkey?: string | null;\n\tinput?: string | null;\n}\n\nexport interface ActorsCreateResponse {\n\tactor: Actor;\n}\n\n// MARK: Get actor\nexport async function getActor(\n\tconfig: Config,\n\tactorId: RivetId,\n): Promise<ActorsGetResponse> {\n\treturn apiCall<never, ActorsGetResponse>(\n\t\tconfig.endpoint,\n\t\tconfig.namespace,\n\t\t\"GET\",\n\t\t`/actors/${encodeURIComponent(actorId)}`,\n\t);\n}\n\n// MARK: Get actor by id\nexport async function getActorById(\n\tconfig: Config,\n\tname: string,\n\tkey: string[],\n): Promise<ActorsGetByIdResponse> {\n\tconst serializedKey = serializeActorKey(key);\n\treturn apiCall<never, ActorsGetByIdResponse>(\n\t\tconfig.endpoint,\n\t\tconfig.namespace,\n\t\t\"GET\",\n\t\t`/actors/by-id?name=${encodeURIComponent(name)}&key=${encodeURIComponent(serializedKey)}`,\n\t);\n}\n\n// MARK: Get or create actor by id\nexport interface ActorsGetOrCreateByIdRequest {\n\tname: string;\n\tkey: string;\n\trunner_name_selector: string;\n\tcrash_policy: string;\n\tinput?: string | null;\n}\n\nexport async function getOrCreateActorById(\n\tconfig: Config,\n\trequest: ActorsGetOrCreateByIdRequest,\n): Promise<ActorsGetOrCreateByIdResponse> {\n\treturn apiCall<ActorsGetOrCreateByIdRequest, ActorsGetOrCreateByIdResponse>(\n\t\tconfig.endpoint,\n\t\tconfig.namespace,\n\t\t\"PUT\",\n\t\t`/actors/by-id`,\n\t\trequest,\n\t);\n}\n\n// MARK: Create actor\nexport async function createActor(\n\tconfig: Config,\n\trequest: ActorsCreateRequest,\n): Promise<ActorsCreateResponse> {\n\treturn apiCall<ActorsCreateRequest, ActorsCreateResponse>(\n\t\tconfig.endpoint,\n\t\tconfig.namespace,\n\t\t\"POST\",\n\t\t`/actors`,\n\t\trequest,\n\t);\n}\n\n// MARK: Destroy actor\nexport type ActorsDeleteResponse = {};\n\nexport async function destroyActor(\n\tconfig: Config,\n\tactorId: RivetId,\n): Promise<ActorsDeleteResponse> {\n\treturn apiCall<never, ActorsDeleteResponse>(\n\t\tconfig.endpoint,\n\t\tconfig.namespace,\n\t\t\"DELETE\",\n\t\t`/actors/${encodeURIComponent(actorId)}`,\n\t);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/ws-proxy.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/ws-proxy.ts\";import type { Context as HonoContext } from \"hono\";\nimport type { WSContext } from \"hono/ws\";\nimport invariant from \"invariant\";\nimport type { CloseEvent } from \"ws\";\nimport { importWebSocket } from \"@/common/websocket\";\nimport type { UpgradeWebSocketArgs } from \"@/mod\";\nimport { logger } from \"./log\";\n\n/**\n * Returns Hono `upgradeWebSocket` args that will proxy requests from the client to a destination address.\n */\nexport async function createWebSocketProxy(\n\tc: HonoContext,\n\ttargetUrl: string,\n\theaders: Record<string, string>,\n): Promise<UpgradeWebSocketArgs> {\n\tconst WebSocket = await importWebSocket();\n\n\t// HACK: Sanitize WebSocket-specific headers. If we don't do this, some WebSocket implementations (i.e. native WebSocket in Node.js) will fail to connect.\n\tfor (const [k, v] of c.req.raw.headers.entries()) {\n\t\tif (!k.startsWith(\"sec-\") && k !== \"connection\" && k !== \"upgrade\") {\n\t\t\theaders[k] = v;\n\t\t}\n\t}\n\n\t// WebSocket state\n\tinterface WsState {\n\t\ttargetWs?: WebSocket;\n\t\tconnectPromise?: Promise<void>;\n\t}\n\tconst state: WsState = {};\n\n\treturn {\n\t\tonOpen: async (event: any, clientWs: WSContext) => {\n\t\t\tlogger().debug(\"client websocket connected\", { targetUrl });\n\n\t\t\tif (clientWs.readyState !== 1) {\n\t\t\t\tlogger().warn(\"client websocket not open on connection\", {\n\t\t\t\t\ttargetUrl,\n\t\t\t\t\treadyState: clientWs.readyState,\n\t\t\t\t});\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Create WebSocket\n\t\t\tconst targetWs = new WebSocket(targetUrl, { headers });\n\t\t\tstate.targetWs = targetWs;\n\n\t\t\t// Setup connection promise\n\t\t\tstate.connectPromise = new Promise<void>((resolve, reject) => {\n\t\t\t\ttargetWs.addEventListener(\"open\", () => {\n\t\t\t\t\tlogger().debug(\"target websocket connected\", { targetUrl });\n\n\t\t\t\t\tif (clientWs.readyState !== 1) {\n\t\t\t\t\t\tlogger().warn(\"client websocket closed before target connected\", {\n\t\t\t\t\t\t\ttargetUrl,\n\t\t\t\t\t\t\tclientReadyState: clientWs.readyState,\n\t\t\t\t\t\t});\n\t\t\t\t\t\ttargetWs.close(1001, \"Client disconnected\");\n\t\t\t\t\t\treject(new Error(\"Client disconnected\"));\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tresolve();\n\t\t\t\t});\n\n\t\t\t\ttargetWs.addEventListener(\"error\", (error) => {\n\t\t\t\t\tlogger().warn(\"target websocket error during connection\", {\n\t\t\t\t\t\ttargetUrl,\n\t\t\t\t\t});\n\t\t\t\t\treject(error);\n\t\t\t\t});\n\t\t\t});\n\n\t\t\t// Setup bidirectional forwarding\n\t\t\tstate.targetWs.addEventListener(\"message\", (event) => {\n\t\t\t\tif (\n\t\t\t\t\ttypeof event.data === \"string\" ||\n\t\t\t\t\tevent.data instanceof ArrayBuffer\n\t\t\t\t) {\n\t\t\t\t\tclientWs.send(event.data);\n\t\t\t\t} else if (event.data instanceof Blob) {\n\t\t\t\t\tevent.data.arrayBuffer().then((buffer) => {\n\t\t\t\t\t\tclientWs.send(buffer);\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t});\n\n\t\t\tstate.targetWs.addEventListener(\"close\", (event) => {\n\t\t\t\tlogger().debug(\"target websocket closed\", {\n\t\t\t\t\ttargetUrl,\n\t\t\t\t\tcode: event.code,\n\t\t\t\t\treason: event.reason,\n\t\t\t\t});\n\t\t\t\tcloseWebSocketIfOpen(clientWs, event.code, event.reason);\n\t\t\t});\n\n\t\t\tstate.targetWs.addEventListener(\"error\", (error) => {\n\t\t\t\tlogger().error(\"target websocket error\", { targetUrl, error });\n\t\t\t\tcloseWebSocketIfOpen(clientWs, 1011, \"Target WebSocket error\");\n\t\t\t});\n\t\t},\n\n\t\tonMessage: async (event: any, clientWs: WSContext) => {\n\t\t\tif (!state.targetWs || !state.connectPromise) {\n\t\t\t\tlogger().error(\"websocket state not initialized\", { targetUrl });\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tawait state.connectPromise;\n\t\t\t\tif (state.targetWs.readyState === WebSocket.OPEN) {\n\t\t\t\t\tstate.targetWs.send(event.data);\n\t\t\t\t} else {\n\t\t\t\t\tlogger().warn(\"target websocket not open\", {\n\t\t\t\t\t\ttargetUrl,\n\t\t\t\t\t\treadyState: state.targetWs.readyState,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"failed to connect to target websocket\", {\n\t\t\t\t\ttargetUrl,\n\t\t\t\t\terror,\n\t\t\t\t});\n\t\t\t\tcloseWebSocketIfOpen(clientWs, 1011, \"Failed to connect to target\");\n\t\t\t}\n\t\t},\n\n\t\tonClose: (event: any, clientWs: WSContext) => {\n\t\t\tlogger().debug(\"client websocket closed\", {\n\t\t\t\ttargetUrl,\n\t\t\t\tcode: event.code,\n\t\t\t\treason: event.reason,\n\t\t\t\twasClean: event.wasClean,\n\t\t\t});\n\n\t\t\tif (state.targetWs) {\n\t\t\t\tif (\n\t\t\t\t\tstate.targetWs.readyState === WebSocket.OPEN ||\n\t\t\t\t\tstate.targetWs.readyState === WebSocket.CONNECTING\n\t\t\t\t) {\n\t\t\t\t\tstate.targetWs.close(1000, event.reason || \"Client disconnected\");\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\n\t\tonError: (event: any, clientWs: WSContext) => {\n\t\t\tlogger().error(\"client websocket error\", { targetUrl, event });\n\n\t\t\tif (state.targetWs) {\n\t\t\t\tif (state.targetWs.readyState === WebSocket.OPEN) {\n\t\t\t\t\tstate.targetWs.close(1011, \"Client WebSocket error\");\n\t\t\t\t} else if (state.targetWs.readyState === WebSocket.CONNECTING) {\n\t\t\t\t\tstate.targetWs.close();\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t};\n}\n\nfunction closeWebSocketIfOpen(\n\tws: WebSocket | WSContext,\n\tcode: number,\n\treason: string,\n): void {\n\tif (ws.readyState === 1) {\n\t\tws.close(code, reason);\n\t} else if (\"close\" in ws && (ws as WebSocket).readyState === WebSocket.OPEN) {\n\t\tws.close(code, reason);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/mod.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/engine/mod.ts\";import type { Client } from \"@/client/client\";\nimport type { ManagerDriver } from \"@/manager/driver\";\nimport type { RegistryConfig } from \"@/registry/config\";\nimport type { DriverConfig, RunConfig } from \"@/registry/run-config\";\nimport { EngineActorDriver } from \"./actor-driver\";\nimport { ConfigSchema, type InputConfig } from \"./config\";\nimport { EngineManagerDriver } from \"./manager-driver\";\n\nexport { EngineActorDriver } from \"./actor-driver\";\nexport { type Config, ConfigSchema, type InputConfig } from \"./config\";\nexport { EngineManagerDriver } from \"./manager-driver\";\n\nexport function createEngineDriver(inputConfig?: InputConfig): DriverConfig {\n\tconst config = ConfigSchema.parse(inputConfig);\n\n\treturn {\n\t\tname: \"engine\",\n\t\tmanager: (_registryConfig, runConfig) => {\n\t\t\treturn new EngineManagerDriver(config, runConfig);\n\t\t},\n\t\tactor: (\n\t\t\tregistryConfig: RegistryConfig,\n\t\t\trunConfig: RunConfig,\n\t\t\tmanagerDriver: ManagerDriver,\n\t\t\tinlineClient: Client<any>,\n\t\t) => {\n\t\t\treturn new EngineActorDriver(\n\t\t\t\tregistryConfig,\n\t\t\t\trunConfig,\n\t\t\t\tmanagerDriver,\n\t\t\t\tinlineClient,\n\t\t\t\tconfig,\n\t\t\t);\n\t\t},\n\t};\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/actor.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/actor.ts\";import type { GenericConnGlobalState } from \"@/actor/generic-conn-driver\";\nimport { logger } from \"@/actor/log\";\nimport type { AnyClient } from \"@/client/client\";\nimport type {\n\tActorDriver,\n\tAnyActorInstance,\n\tManagerDriver,\n} from \"@/driver-helpers/mod\";\nimport type { RegistryConfig, RunConfig } from \"@/mod\";\nimport { bufferToArrayBuffer } from \"@/utils\";\nimport type { FileSystemGlobalState } from \"./global-state\";\n\nexport type ActorDriverContext = Record<never, never>;\n\n/**\n * File System implementation of the Actor Driver\n */\nexport class FileSystemActorDriver implements ActorDriver {\n\t#registryConfig: RegistryConfig;\n\t#runConfig: RunConfig;\n\t#managerDriver: ManagerDriver;\n\t#inlineClient: AnyClient;\n\t#state: FileSystemGlobalState;\n\n\tconstructor(\n\t\tregistryConfig: RegistryConfig,\n\t\trunConfig: RunConfig,\n\t\tmanagerDriver: ManagerDriver,\n\t\tinlineClient: AnyClient,\n\t\tstate: FileSystemGlobalState,\n\t) {\n\t\tthis.#registryConfig = registryConfig;\n\t\tthis.#runConfig = runConfig;\n\t\tthis.#managerDriver = managerDriver;\n\t\tthis.#inlineClient = inlineClient;\n\t\tthis.#state = state;\n\t}\n\n\tasync loadActor(actorId: string): Promise<AnyActorInstance> {\n\t\treturn this.#state.startActor(\n\t\t\tthis.#registryConfig,\n\t\t\tthis.#runConfig,\n\t\t\tthis.#inlineClient,\n\t\t\tthis,\n\t\t\tactorId,\n\t\t);\n\t}\n\n\tgetGenericConnGlobalState(actorId: string): GenericConnGlobalState {\n\t\treturn this.#state.getActorOrError(actorId).genericConnGlobalState;\n\t}\n\n\t/**\n\t * Get the current storage directory path\n\t */\n\tget storagePath(): string {\n\t\treturn this.#state.storagePath;\n\t}\n\n\tgetContext(_actorId: string): ActorDriverContext {\n\t\treturn {};\n\t}\n\n\tasync readPersistedData(actorId: string): Promise<Uint8Array | undefined> {\n\t\treturn new Uint8Array(\n\t\t\t(await this.#state.loadActorStateOrError(actorId)).persistedData,\n\t\t);\n\t}\n\n\tasync writePersistedData(actorId: string, data: Uint8Array): Promise<void> {\n\t\tconst state = await this.#state.loadActorStateOrError(actorId);\n\n\t\t// Save state to disk\n\t\tawait this.#state.writeActor(actorId, {\n\t\t\t...state,\n\t\t\tpersistedData: bufferToArrayBuffer(data),\n\t\t});\n\t}\n\n\tasync setAlarm(actor: AnyActorInstance, timestamp: number): Promise<void> {\n\t\tawait this.#state.setActorAlarm(actor.id, timestamp);\n\t}\n\n\tgetDatabase(actorId: string): Promise<unknown | undefined> {\n\t\treturn this.#state.createDatabase(actorId);\n\t}\n\n\tsleep(actorId: string): Promise<void> {\n\t\treturn this.#state.sleepActor(actorId);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/global-state.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/global-state.ts\";import * as crypto from \"node:crypto\";\nimport * as fsSync from \"node:fs\";\nimport * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport invariant from \"invariant\";\nimport { lookupInRegistry } from \"@/actor/definition\";\nimport { ActorAlreadyExists } from \"@/actor/errors\";\nimport {\n\tcreateGenericConnDrivers,\n\tGenericConnGlobalState,\n} from \"@/actor/generic-conn-driver\";\nimport type { AnyActorInstance } from \"@/actor/instance\";\nimport type { ActorKey } from \"@/actor/mod\";\nimport { generateRandomString } from \"@/actor/utils\";\nimport type { AnyClient } from \"@/client/client\";\nimport {\n\ttype ActorDriver,\n\tserializeEmptyPersistData,\n} from \"@/driver-helpers/mod\";\nimport type { RegistryConfig } from \"@/registry/config\";\nimport type { RunConfig } from \"@/registry/run-config\";\nimport type * as schema from \"@/schemas/file-system-driver/mod\";\nimport {\n\tACTOR_ALARM_VERSIONED,\n\tACTOR_STATE_VERSIONED,\n} from \"@/schemas/file-system-driver/versioned\";\nimport {\n\tbufferToArrayBuffer,\n\ttype LongTimeoutHandle,\n\tSinglePromiseQueue,\n\tsetLongTimeout,\n\tstringifyError,\n} from \"@/utils\";\nimport { logger } from \"./log\";\nimport {\n\tensureDirectoryExists,\n\tensureDirectoryExistsSync,\n\tgetStoragePath,\n} from \"./utils\";\n\n// Actor handler to track running instances\n\ninterface ActorEntry {\n\tid: string;\n\n\tstate?: schema.ActorState;\n\t/** Promise for loading the actor state. */\n\tloadPromise?: Promise<ActorEntry>;\n\n\tactor?: AnyActorInstance;\n\t/** Promise for starting the actor. */\n\tstartPromise?: PromiseWithResolvers<void>;\n\n\tgenericConnGlobalState: GenericConnGlobalState;\n\n\talarmTimeout?: LongTimeoutHandle;\n\t/** The timestamp currently scheduled for this actor's alarm (ms since epoch). */\n\talarmTimestamp?: number;\n\n\t/** Resolver for pending write operations that need to be notified when any write completes */\n\tpendingWriteResolver?: PromiseWithResolvers<void>;\n\n\t/** If the actor has been removed by destroy or sleep. */\n\tremoved: boolean;\n}\n\n/**\n * Global state for the file system driver\n */\nexport class FileSystemGlobalState {\n\t#storagePath: string;\n\t#stateDir: string;\n\t#dbsDir: string;\n\t#alarmsDir: string;\n\n\t#persist: boolean;\n\t#actors = new Map<string, ActorEntry>();\n\t#actorCountOnStartup: number = 0;\n\n\t#runnerParams?: {\n\t\tregistryConfig: RegistryConfig;\n\t\trunConfig: RunConfig;\n\t\tinlineClient: AnyClient;\n\t\tactorDriver: ActorDriver;\n\t};\n\n\tget storagePath() {\n\t\treturn this.#storagePath;\n\t}\n\n\tget actorCountOnStartup() {\n\t\treturn this.#actorCountOnStartup;\n\t}\n\n\tconstructor(persist: boolean = true, customPath?: string) {\n\t\tthis.#persist = persist;\n\t\tthis.#storagePath = persist ? getStoragePath(customPath) : \"/tmp\";\n\t\tthis.#stateDir = path.join(this.#storagePath, \"state\");\n\t\tthis.#dbsDir = path.join(this.#storagePath, \"databases\");\n\t\tthis.#alarmsDir = path.join(this.#storagePath, \"alarms\");\n\n\t\tif (this.#persist) {\n\t\t\t// Ensure storage directories exist synchronously during initialization\n\t\t\tensureDirectoryExistsSync(this.#stateDir);\n\t\t\tensureDirectoryExistsSync(this.#dbsDir);\n\t\t\tensureDirectoryExistsSync(this.#alarmsDir);\n\n\t\t\ttry {\n\t\t\t\tconst actorIds = fsSync.readdirSync(this.#stateDir);\n\t\t\t\tthis.#actorCountOnStartup = actorIds.length;\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"failed to count actors\", { error });\n\t\t\t}\n\n\t\t\tlogger().debug(\"file system driver ready\", {\n\t\t\t\tdir: this.#storagePath,\n\t\t\t\tactorCount: this.#actorCountOnStartup,\n\t\t\t});\n\n\t\t\t// Cleanup stale temp files on startup\n\t\t\ttry {\n\t\t\t\tthis.#cleanupTempFilesSync();\n\t\t\t} catch (err) {\n\t\t\t\tlogger().error(\"failed to cleanup temp files\", { error: err });\n\t\t\t}\n\t\t} else {\n\t\t\tlogger().debug(\"memory driver ready\");\n\t\t}\n\t}\n\n\tgetActorStatePath(actorId: string): string {\n\t\treturn path.join(this.#stateDir, actorId);\n\t}\n\n\tgetActorDbPath(actorId: string): string {\n\t\treturn path.join(this.#dbsDir, `${actorId}.db`);\n\t}\n\n\tgetActorAlarmPath(actorId: string): string {\n\t\treturn path.join(this.#alarmsDir, actorId);\n\t}\n\n\tasync *getActorsIterator(params: {\n\t\tcursor?: string;\n\t}): AsyncGenerator<schema.ActorState> {\n\t\tlet actorIds = Array.from(this.#actors.keys()).sort();\n\n\t\t// Check if state directory exists first\n\t\tif (fsSync.existsSync(this.#stateDir)) {\n\t\t\tactorIds = fsSync\n\t\t\t\t.readdirSync(this.#stateDir)\n\t\t\t\t.filter((id) => !id.includes(\".tmp\"))\n\t\t\t\t.sort();\n\t\t}\n\n\t\tconst startIndex = params.cursor ? actorIds.indexOf(params.cursor) + 1 : 0;\n\n\t\tfor (let i = startIndex; i < actorIds.length; i++) {\n\t\t\tconst actorId = actorIds[i];\n\t\t\tif (!actorId) {\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tconst state = await this.loadActorStateOrError(actorId);\n\t\t\t\tyield state;\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"failed to load actor state\", { actorId, error });\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Ensures an entry exists for this actor.\n\t *\n\t * Used for #createActor and #loadActor.\n\t */\n\t#upsertEntry(actorId: string): ActorEntry {\n\t\tlet entry = this.#actors.get(actorId);\n\t\tif (entry) {\n\t\t\treturn entry;\n\t\t}\n\n\t\tentry = {\n\t\t\tid: actorId,\n\t\t\tgenericConnGlobalState: new GenericConnGlobalState(),\n\t\t\tremoved: false,\n\t\t};\n\t\tthis.#actors.set(actorId, entry);\n\t\treturn entry;\n\t}\n\n\t/**\n\t * Creates a new actor and writes to file system.\n\t */\n\tasync createActor(\n\t\tactorId: string,\n\t\tname: string,\n\t\tkey: ActorKey,\n\t\tinput: unknown | undefined,\n\t): Promise<ActorEntry> {\n\t\t// TODO: Does not check if actor already exists on fs\n\n\t\tif (this.#actors.has(actorId)) {\n\t\t\tthrow new ActorAlreadyExists(name, key);\n\t\t}\n\n\t\tconst entry = this.#upsertEntry(actorId);\n\t\tentry.state = {\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t\tcreatedAt: BigInt(Date.now()),\n\t\t\tpersistedData: bufferToArrayBuffer(serializeEmptyPersistData(input)),\n\t\t};\n\t\tawait this.writeActor(actorId, entry.state);\n\t\treturn entry;\n\t}\n\n\t/**\n\t * Loads the actor from disk or returns the existing actor entry. This will return an entry even if the actor does not actually exist.\n\t */\n\tasync loadActor(actorId: string): Promise<ActorEntry> {\n\t\tconst entry = this.#upsertEntry(actorId);\n\n\t\t// Check if already loaded\n\t\tif (entry.state) {\n\t\t\treturn entry;\n\t\t}\n\n\t\t// If not persisted, then don't load from FS\n\t\tif (!this.#persist) {\n\t\t\treturn entry;\n\t\t}\n\n\t\t// If state is currently being loaded, wait for it\n\t\tif (entry.loadPromise) {\n\t\t\tawait entry.loadPromise;\n\t\t\treturn entry;\n\t\t}\n\n\t\t// Start loading state\n\t\tentry.loadPromise = this.loadActorState(entry);\n\t\treturn entry.loadPromise;\n\t}\n\n\tprivate async loadActorState(entry: ActorEntry) {\n\t\tconst stateFilePath = this.getActorStatePath(entry.id);\n\n\t\t// Read & parse file\n\t\ttry {\n\t\t\tconst stateData = await fs.readFile(stateFilePath);\n\n\t\t\t// Cache the loaded state in handler\n\t\t\tentry.state = ACTOR_STATE_VERSIONED.deserializeWithEmbeddedVersion(\n\t\t\t\tnew Uint8Array(stateData),\n\t\t\t);\n\n\t\t\treturn entry;\n\t\t} catch (innerError: any) {\n\t\t\t// File does not exist, meaning the actor does not exist\n\t\t\tif (innerError.code === \"ENOENT\") {\n\t\t\t\tentry.loadPromise = undefined;\n\t\t\t\treturn entry;\n\t\t\t}\n\n\t\t\t// For other errors, throw\n\t\t\tconst error = new Error(`Failed to load actor state: ${innerError}`);\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync loadOrCreateActor(\n\t\tactorId: string,\n\t\tname: string,\n\t\tkey: ActorKey,\n\t\tinput: unknown | undefined,\n\t): Promise<ActorEntry> {\n\t\t// Attempt to load actor\n\t\tconst entry = await this.loadActor(actorId);\n\n\t\t// If no state for this actor, then create & write state\n\t\tif (!entry.state) {\n\t\t\tentry.state = {\n\t\t\t\tactorId,\n\t\t\t\tname,\n\t\t\t\tkey: key as readonly string[],\n\t\t\t\tcreatedAt: BigInt(Date.now()),\n\t\t\t\tpersistedData: bufferToArrayBuffer(serializeEmptyPersistData(input)),\n\t\t\t};\n\t\t\tawait this.writeActor(actorId, entry.state);\n\t\t}\n\t\treturn entry;\n\t}\n\n\tasync sleepActor(actorId: string) {\n\t\tinvariant(\n\t\t\tthis.#persist,\n\t\t\t\"cannot sleep actor with memory driver, must use file system driver\",\n\t\t);\n\n\t\tconst actor = this.#actors.get(actorId);\n\t\tinvariant(actor, `tried to sleep ${actorId}, does not exist`);\n\n\t\t// Wait for actor to fully start before stopping it to avoid race conditions\n\t\tif (actor.loadPromise) await actor.loadPromise.catch();\n\t\tif (actor.startPromise?.promise) await actor.startPromise.promise.catch();\n\n\t\t// Mark as removed\n\t\tactor.removed = true;\n\n\t\t// Stop actor\n\t\tinvariant(actor.actor, \"actor should be loaded\");\n\t\tawait actor.actor._stop();\n\n\t\t// Remove from map after stop is complete\n\t\tthis.#actors.delete(actorId);\n\t}\n\n\t/**\n\t * Save actor state to disk.\n\t */\n\tasync writeActor(actorId: string, state: schema.ActorState): Promise<void> {\n\t\tif (!this.#persist) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst entry = this.#actors.get(actorId);\n\t\tinvariant(entry, \"actor entry does not exist\");\n\n\t\tawait this.#performWrite(actorId, state);\n\t}\n\n\tasync setActorAlarm(actorId: string, timestamp: number) {\n\t\tconst entry = this.#actors.get(actorId);\n\t\tinvariant(entry, \"actor entry does not exist\");\n\n\t\t// Persist alarm to disk\n\t\tif (this.#persist) {\n\t\t\tconst alarmPath = this.getActorAlarmPath(actorId);\n\t\t\tconst tempPath = `${alarmPath}.tmp.${crypto.randomUUID()}`;\n\t\t\ttry {\n\t\t\t\tawait ensureDirectoryExists(path.dirname(alarmPath));\n\t\t\t\tconst alarmData: schema.ActorAlarm = {\n\t\t\t\t\tactorId,\n\t\t\t\t\ttimestamp: BigInt(timestamp),\n\t\t\t\t};\n\t\t\t\tconst data =\n\t\t\t\t\tACTOR_ALARM_VERSIONED.serializeWithEmbeddedVersion(alarmData);\n\t\t\t\tawait fs.writeFile(tempPath, data);\n\t\t\t\tawait fs.rename(tempPath, alarmPath);\n\t\t\t} catch (error) {\n\t\t\t\ttry {\n\t\t\t\t\tawait fs.unlink(tempPath);\n\t\t\t\t} catch {}\n\t\t\t\tlogger().error(\"failed to write alarm\", { actorId, error });\n\t\t\t\tthrow new Error(`Failed to write alarm: ${error}`);\n\t\t\t}\n\t\t}\n\n\t\t// Schedule timeout\n\t\tthis.#scheduleAlarmTimeout(actorId, timestamp);\n\t}\n\n\t/**\n\t * Perform the actual write operation with atomic writes\n\t */\n\tasync #performWrite(\n\t\tactorId: string,\n\t\tstate: schema.ActorState,\n\t): Promise<void> {\n\t\tconst dataPath = this.getActorStatePath(actorId);\n\t\t// Generate unique temp filename to prevent any race conditions\n\t\tconst tempPath = `${dataPath}.tmp.${crypto.randomUUID()}`;\n\n\t\ttry {\n\t\t\t// Create directory if needed\n\t\t\tawait ensureDirectoryExists(path.dirname(dataPath));\n\n\t\t\t// Convert to BARE types for serialization\n\t\t\tconst bareState: schema.ActorState = {\n\t\t\t\tactorId: state.actorId,\n\t\t\t\tname: state.name,\n\t\t\t\tkey: state.key,\n\t\t\t\tcreatedAt: state.createdAt,\n\t\t\t\tpersistedData: state.persistedData,\n\t\t\t};\n\n\t\t\t// Perform atomic write\n\t\t\tconst serializedState =\n\t\t\t\tACTOR_STATE_VERSIONED.serializeWithEmbeddedVersion(bareState);\n\t\t\tawait fs.writeFile(tempPath, serializedState);\n\t\t\tawait fs.rename(tempPath, dataPath);\n\t\t} catch (error) {\n\t\t\t// Cleanup temp file on error\n\t\t\ttry {\n\t\t\t\tawait fs.unlink(tempPath);\n\t\t\t} catch {\n\t\t\t\t// Ignore cleanup errors\n\t\t\t}\n\t\t\tlogger().error(\"failed to save actor state\", { actorId, error });\n\t\t\tthrow new Error(`Failed to save actor state: ${error}`);\n\t\t}\n\t}\n\n\t/**\n\t * Call this method after the actor driver has been initiated.\n\t *\n\t * This will trigger all initial alarms from the file system.\n\t *\n\t * This needs to be sync since DriverConfig.actor is sync\n\t */\n\tonRunnerStart(\n\t\tregistryConfig: RegistryConfig,\n\t\trunConfig: RunConfig,\n\t\tinlineClient: AnyClient,\n\t\tactorDriver: ActorDriver,\n\t) {\n\t\tif (this.#runnerParams) {\n\t\t\tlogger().warn(\"already called onRunnerStart\");\n\t\t\treturn;\n\t\t}\n\n\t\t// Save runner params for future use\n\t\tthis.#runnerParams = {\n\t\t\tregistryConfig,\n\t\t\trunConfig,\n\t\t\tinlineClient,\n\t\t\tactorDriver,\n\t\t};\n\n\t\t// Load alarms from disk and schedule timeouts\n\t\ttry {\n\t\t\tthis.#loadAlarmsSync();\n\t\t} catch (err) {\n\t\t\tlogger().error(\"failed to load alarms on startup\", { error: err });\n\t\t}\n\t}\n\n\tasync startActor(\n\t\tregistryConfig: RegistryConfig,\n\t\trunConfig: RunConfig,\n\t\tinlineClient: AnyClient,\n\t\tactorDriver: ActorDriver,\n\t\tactorId: string,\n\t): Promise<AnyActorInstance> {\n\t\t// Get the actor metadata\n\t\tconst entry = await this.loadActor(actorId);\n\t\tif (!entry.state) {\n\t\t\tthrow new Error(`Actor does exist and cannot be started: ${actorId}`);\n\t\t}\n\n\t\t// Actor already starting\n\t\tif (entry.startPromise) {\n\t\t\tawait entry.startPromise.promise;\n\t\t\tinvariant(entry.actor, \"actor should have loaded\");\n\t\t\treturn entry.actor;\n\t\t}\n\n\t\t// Actor already loaded\n\t\tif (entry.actor) {\n\t\t\treturn entry.actor;\n\t\t}\n\n\t\t// Create start promise\n\t\tentry.startPromise = Promise.withResolvers();\n\n\t\ttry {\n\t\t\t// Create actor\n\t\t\tconst definition = lookupInRegistry(registryConfig, entry.state.name);\n\t\t\tentry.actor = definition.instantiate();\n\n\t\t\t// Start actor\n\t\t\tconst connDrivers = createGenericConnDrivers(\n\t\t\t\tentry.genericConnGlobalState,\n\t\t\t);\n\t\t\tawait entry.actor.start(\n\t\t\t\tconnDrivers,\n\t\t\t\tactorDriver,\n\t\t\t\tinlineClient,\n\t\t\t\tactorId,\n\t\t\t\tentry.state.name,\n\t\t\t\tentry.state.key as string[],\n\t\t\t\t\"unknown\",\n\t\t\t);\n\n\t\t\t// Finish\n\t\t\tentry.startPromise.resolve();\n\t\t\tentry.startPromise = undefined;\n\n\t\t\treturn entry.actor;\n\t\t} catch (innerError) {\n\t\t\tconst error = new Error(\n\t\t\t\t`Failed to start actor ${actorId}: ${innerError}`,\n\t\t\t\t{ cause: innerError },\n\t\t\t);\n\t\t\tentry.startPromise?.reject(error);\n\t\t\tentry.startPromise = undefined;\n\t\t\tthrow error;\n\t\t}\n\t}\n\n\tasync loadActorStateOrError(actorId: string): Promise<schema.ActorState> {\n\t\tconst state = (await this.loadActor(actorId)).state;\n\t\tif (!state) throw new Error(`Actor does not exist: ${actorId}`);\n\t\treturn state;\n\t}\n\n\tgetActorOrError(actorId: string): ActorEntry {\n\t\tconst entry = this.#actors.get(actorId);\n\t\tif (!entry) throw new Error(`No entry for actor: ${actorId}`);\n\t\treturn entry;\n\t}\n\n\tasync createDatabase(actorId: string): Promise<string | undefined> {\n\t\treturn this.getActorDbPath(actorId);\n\t}\n\n\t/**\n\t * Load all persisted alarms from disk and schedule their timers.\n\t */\n\t#loadAlarmsSync(): void {\n\t\ttry {\n\t\t\tconst files = fsSync.existsSync(this.#alarmsDir)\n\t\t\t\t? fsSync.readdirSync(this.#alarmsDir)\n\t\t\t\t: [];\n\t\t\tfor (const file of files) {\n\t\t\t\t// Skip temp files\n\t\t\t\tif (file.includes(\".tmp.\")) continue;\n\t\t\t\tconst fullPath = path.join(this.#alarmsDir, file);\n\t\t\t\ttry {\n\t\t\t\t\tconst buf = fsSync.readFileSync(fullPath);\n\t\t\t\t\tconst alarmData =\n\t\t\t\t\t\tACTOR_ALARM_VERSIONED.deserializeWithEmbeddedVersion(\n\t\t\t\t\t\t\tnew Uint8Array(buf),\n\t\t\t\t\t\t);\n\t\t\t\t\tconst timestamp = Number(alarmData.timestamp);\n\t\t\t\t\tif (Number.isFinite(timestamp)) {\n\t\t\t\t\t\tthis.#scheduleAlarmTimeout(alarmData.actorId, timestamp);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tlogger().debug(\"invalid alarm file contents\", { file });\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\tlogger().error(\"failed to read alarm file\", {\n\t\t\t\t\t\tfile,\n\t\t\t\t\t\terror: stringifyError(err),\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\tlogger().error(\"failed to list alarms directory\", { error: err });\n\t\t}\n\t}\n\n\t/**\n\t * Schedule an alarm timer for an actor without writing to disk.\n\t */\n\t#scheduleAlarmTimeout(actorId: string, timestamp: number) {\n\t\tconst entry = this.#upsertEntry(actorId);\n\n\t\t// If there's already an earlier alarm scheduled, do not override it.\n\t\tif (\n\t\t\tentry.alarmTimestamp !== undefined &&\n\t\t\ttimestamp >= entry.alarmTimestamp\n\t\t) {\n\t\t\tlogger().debug(\"skipping alarm schedule (later than existing)\", {\n\t\t\t\tactorId,\n\t\t\t\ttimestamp,\n\t\t\t\tcurrent: entry.alarmTimestamp,\n\t\t\t});\n\t\t\treturn;\n\t\t}\n\n\t\tlogger().debug(\"scheduling alarm\", { actorId, timestamp });\n\n\t\t// Cancel existing timeout and update the current scheduled timestamp\n\t\tentry.alarmTimeout?.abort();\n\t\tentry.alarmTimestamp = timestamp;\n\n\t\tconst delay = Math.max(0, timestamp - Date.now());\n\t\tentry.alarmTimeout = setLongTimeout(async () => {\n\t\t\t// Clear currently scheduled timestamp as this alarm is firing now\n\t\t\tentry.alarmTimestamp = undefined;\n\t\t\t// On trigger: remove persisted alarm file\n\t\t\tif (this.#persist) {\n\t\t\t\ttry {\n\t\t\t\t\tawait fs.unlink(this.getActorAlarmPath(actorId));\n\t\t\t\t} catch (err: any) {\n\t\t\t\t\tif (err?.code !== \"ENOENT\") {\n\t\t\t\t\t\tlogger().debug(\"failed to remove alarm file\", {\n\t\t\t\t\t\t\tactorId,\n\t\t\t\t\t\t\terror: stringifyError(err),\n\t\t\t\t\t\t});\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tlogger().debug(\"triggering alarm\", { actorId, timestamp });\n\n\t\t\t\t// Ensure actor state exists and start actor if needed\n\t\t\t\tconst loaded = await this.loadActor(actorId);\n\t\t\t\tif (!loaded.state) throw new Error(`Actor does not exist: ${actorId}`);\n\n\t\t\t\t// Start actor if not already running\n\t\t\t\tconst runnerParams = this.#runnerParams;\n\t\t\t\tinvariant(runnerParams, \"missing runner params\");\n\t\t\t\tif (!loaded.actor) {\n\t\t\t\t\tawait this.startActor(\n\t\t\t\t\t\trunnerParams.registryConfig,\n\t\t\t\t\t\trunnerParams.runConfig,\n\t\t\t\t\t\trunnerParams.inlineClient,\n\t\t\t\t\t\trunnerParams.actorDriver,\n\t\t\t\t\t\tactorId,\n\t\t\t\t\t);\n\t\t\t\t}\n\n\t\t\t\tinvariant(loaded.actor, \"actor should be loaded after wake\");\n\t\t\t\tawait loaded.actor._onAlarm();\n\t\t\t} catch (err) {\n\t\t\t\tlogger().error(\"failed to handle alarm\", {\n\t\t\t\t\tactorId,\n\t\t\t\t\terror: stringifyError(err),\n\t\t\t\t});\n\t\t\t}\n\t\t}, delay);\n\t}\n\n\tgetOrCreateInspectorAccessToken(): string {\n\t\tconst tokenPath = path.join(this.#storagePath, \"inspector-token\");\n\t\tif (fsSync.existsSync(tokenPath)) {\n\t\t\treturn fsSync.readFileSync(tokenPath, \"utf-8\");\n\t\t}\n\n\t\tconst newToken = generateRandomString();\n\t\tfsSync.writeFileSync(tokenPath, newToken);\n\t\treturn newToken;\n\t}\n\n\t/**\n\t * Cleanup stale temp files on startup (synchronous)\n\t */\n\t#cleanupTempFilesSync(): void {\n\t\ttry {\n\t\t\tconst files = fsSync.readdirSync(this.#stateDir);\n\t\t\tconst tempFiles = files.filter((f) => f.includes(\".tmp.\"));\n\n\t\t\tconst oneHourAgo = Date.now() - 3600000; // 1 hour in ms\n\n\t\t\tfor (const tempFile of tempFiles) {\n\t\t\t\ttry {\n\t\t\t\t\tconst fullPath = path.join(this.#stateDir, tempFile);\n\t\t\t\t\tconst stat = fsSync.statSync(fullPath);\n\n\t\t\t\t\t// Remove if older than 1 hour\n\t\t\t\t\tif (stat.mtimeMs < oneHourAgo) {\n\t\t\t\t\t\tfsSync.unlinkSync(fullPath);\n\t\t\t\t\t\tlogger().info(\"cleaned up stale temp file\", { file: tempFile });\n\t\t\t\t\t}\n\t\t\t\t} catch (err) {\n\t\t\t\t\tlogger().debug(\"failed to cleanup temp file\", {\n\t\t\t\t\t\tfile: tempFile,\n\t\t\t\t\t\terror: err,\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t}\n\t\t} catch (err) {\n\t\t\tlogger().error(\"failed to read actors directory for cleanup\", {\n\t\t\t\terror: err,\n\t\t\t});\n\t\t}\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/file-system-driver/v1.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/dist/schemas/file-system-driver\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/dist/schemas/file-system-driver/v1.ts\";import * as bare from \"@bare-ts/lib\"\n\nconst config = /* @__PURE__ */ bare.Config({})\n\nexport type u64 = bigint\nexport type uint = bigint\n\nfunction read0(bc: bare.ByteCursor): readonly string[] {\n    const len = bare.readUintSafe(bc)\n    if (len === 0) { return [] }\n    const result = [bare.readString(bc)]\n    for (let i = 1; i < len; i++) {\n        result[i] = bare.readString(bc)\n    }\n    return result\n}\n\nfunction write0(bc: bare.ByteCursor, x: readonly string[]): void {\n    bare.writeUintSafe(bc, x.length)\n    for (let i = 0; i < x.length; i++) {\n        bare.writeString(bc, x[i])\n    }\n}\n\nexport type ActorState = {\n    readonly actorId: string,\n    readonly name: string,\n    readonly key: readonly string[],\n    readonly persistedData: ArrayBuffer,\n    readonly createdAt: u64,\n}\n\nexport function readActorState(bc: bare.ByteCursor): ActorState {\n    return {\n        actorId: bare.readString(bc),\n        name: bare.readString(bc),\n        key: read0(bc),\n        persistedData: bare.readData(bc),\n        createdAt: bare.readU64(bc),\n    }\n}\n\nexport function writeActorState(bc: bare.ByteCursor, x: ActorState): void {\n    bare.writeString(bc, x.actorId)\n    bare.writeString(bc, x.name)\n    write0(bc, x.key)\n    bare.writeData(bc, x.persistedData)\n    bare.writeU64(bc, x.createdAt)\n}\n\nexport function encodeActorState(x: ActorState): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeActorState(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeActorState(bytes: Uint8Array): ActorState {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readActorState(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n\nexport type ActorAlarm = {\n    readonly actorId: string,\n    readonly timestamp: uint,\n}\n\nexport function readActorAlarm(bc: bare.ByteCursor): ActorAlarm {\n    return {\n        actorId: bare.readString(bc),\n        timestamp: bare.readUint(bc),\n    }\n}\n\nexport function writeActorAlarm(bc: bare.ByteCursor, x: ActorAlarm): void {\n    bare.writeString(bc, x.actorId)\n    bare.writeUint(bc, x.timestamp)\n}\n\nexport function encodeActorAlarm(x: ActorAlarm): Uint8Array {\n    const bc = new bare.ByteCursor(\n        new Uint8Array(config.initialBufferLength),\n        config\n    )\n    writeActorAlarm(bc, x)\n    return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset)\n}\n\nexport function decodeActorAlarm(bytes: Uint8Array): ActorAlarm {\n    const bc = new bare.ByteCursor(bytes, config)\n    const result = readActorAlarm(bc)\n    if (bc.offset < bc.view.byteLength) {\n        throw new bare.BareError(bc.offset, \"remaining bytes\")\n    }\n    return result\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/file-system-driver/versioned.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/schemas/file-system-driver\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/schemas/file-system-driver/versioned.ts\";import {\n\tcreateVersionedDataHandler,\n\ttype MigrationFn,\n} from \"@/common/versioned-data\";\nimport * as v1 from \"../../../dist/schemas/file-system-driver/v1\";\n\nexport const CURRENT_VERSION = 1;\n\nexport type CurrentActorState = v1.ActorState;\nexport type CurrentActorAlarm = v1.ActorAlarm;\n\nconst migrations = new Map<number, MigrationFn<any, any>>();\n\nexport const ACTOR_STATE_VERSIONED =\n\tcreateVersionedDataHandler<CurrentActorState>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeActorState(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeActorState(bytes),\n\t});\n\nexport const ACTOR_ALARM_VERSIONED =\n\tcreateVersionedDataHandler<CurrentActorAlarm>({\n\t\tcurrentVersion: CURRENT_VERSION,\n\t\tmigrations,\n\t\tserializeVersion: (data) => v1.encodeActorAlarm(data),\n\t\tdeserializeVersion: (bytes) => v1.decodeActorAlarm(bytes),\n\t});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/log.ts\";import { getLogger } from \"@/common/log\";\n\nexport const LOGGER_NAME = \"driver-fs\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/utils.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/utils.ts\";import * as crypto from \"node:crypto\";\nimport * as fsSync from \"node:fs\";\nimport * as fs from \"node:fs/promises\";\nimport * as os from \"node:os\";\nimport * as path from \"node:path\";\nimport type { ActorKey } from \"@/actor/mod\";\n\n/**\n * Generate a deterministic actor ID from name and key\n */\nexport function generateActorId(name: string, key: ActorKey): string {\n\t// Generate deterministic key string\n\tconst jsonString = JSON.stringify([name, key]);\n\n\t// Hash to ensure safe file system names\n\tconst hash = crypto\n\t\t.createHash(\"sha256\")\n\t\t.update(jsonString)\n\t\t.digest(\"hex\")\n\t\t.substring(0, 16);\n\n\treturn hash;\n}\n\n/**\n * Create a hash for a path, normalizing it first\n */\nfunction createHashForPath(dirPath: string): string {\n\t// Normalize the path first\n\tconst normalizedPath = path.normalize(dirPath);\n\n\t// Extract the last path component for readability\n\tconst lastComponent = path.basename(normalizedPath);\n\n\t// Create SHA-256 hash\n\tconst hash = crypto\n\t\t.createHash(\"sha256\")\n\t\t.update(normalizedPath)\n\t\t.digest(\"hex\")\n\t\t.substring(0, 8); // Take first 8 characters for brevity\n\n\treturn `${lastComponent}-${hash}`;\n}\n\n/**\n * Get the storage path for the current working directory or a specified path\n */\nexport function getStoragePath(customPath?: string): string {\n\tconst dataPath = getDataPath(\"rivetkit\");\n\tconst pathToHash = customPath || process.cwd();\n\tconst dirHash = createHashForPath(pathToHash);\n\treturn path.join(dataPath, dirHash);\n}\n\n/**\n * Check if a path exists\n */\nexport async function pathExists(path: string): Promise<boolean> {\n\ttry {\n\t\tawait fs.access(path);\n\t\treturn true;\n\t} catch {\n\t\treturn false;\n\t}\n}\n\n/**\n * Ensure a directory exists, creating it if necessary\n */\nexport async function ensureDirectoryExists(\n\tdirectoryPath: string,\n): Promise<void> {\n\tif (!(await pathExists(directoryPath))) {\n\t\tawait fs.mkdir(directoryPath, { recursive: true });\n\t}\n}\n\n/**\n * Ensure a directory exists synchronously - only used during initialization\n * All other operations use the async version\n */\nexport function ensureDirectoryExistsSync(directoryPath: string): void {\n\tif (!fsSync.existsSync(directoryPath)) {\n\t\tfsSync.mkdirSync(directoryPath, { recursive: true });\n\t}\n}\n\n/**\n * Returns platform-specific data directory\n */\nfunction getDataPath(appName: string): string {\n\tconst platform = process.platform;\n\tconst homeDir = os.homedir();\n\n\tswitch (platform) {\n\t\tcase \"win32\":\n\t\t\treturn path.join(\n\t\t\t\tprocess.env.APPDATA || path.join(homeDir, \"AppData\", \"Roaming\"),\n\t\t\t\tappName,\n\t\t\t);\n\t\tcase \"darwin\":\n\t\t\treturn path.join(homeDir, \"Library\", \"Application Support\", appName);\n\t\tdefault: // linux and others\n\t\t\treturn path.join(\n\t\t\t\tprocess.env.XDG_DATA_HOME || path.join(homeDir, \".local\", \"share\"),\n\t\t\t\tappName,\n\t\t\t);\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/manager.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/manager.ts\";import type { Context as HonoContext } from \"hono\";\nimport invariant from \"invariant\";\nimport { type ActorRouter, createActorRouter } from \"@/actor/router\";\nimport {\n\thandleRawWebSocketHandler,\n\thandleWebSocketConnect,\n} from \"@/actor/router-endpoints\";\nimport { createClientWithDriver } from \"@/client/client\";\nimport { InlineWebSocketAdapter2 } from \"@/common/inline-websocket-adapter2\";\nimport { noopNext } from \"@/common/utils\";\nimport type {\n\tActorDriver,\n\tActorOutput,\n\tCreateInput,\n\tGetForIdInput,\n\tGetOrCreateWithKeyInput,\n\tGetWithKeyInput,\n\tManagerDriver,\n} from \"@/driver-helpers/mod\";\nimport { createInlineClientDriver } from \"@/inline-client-driver/mod\";\nimport { ManagerInspector } from \"@/inspector/manager\";\nimport { type Actor, ActorFeature, type ActorId } from \"@/inspector/mod\";\nimport {\n\ttype DriverConfig,\n\ttype Encoding,\n\tPATH_CONNECT_WEBSOCKET,\n\tPATH_RAW_WEBSOCKET_PREFIX,\n\ttype RegistryConfig,\n\ttype RunConfig,\n} from \"@/mod\";\nimport type * as schema from \"@/schemas/file-system-driver/mod\";\nimport type { FileSystemGlobalState } from \"./global-state\";\nimport { logger } from \"./log\";\nimport { generateActorId } from \"./utils\";\n\nexport class FileSystemManagerDriver implements ManagerDriver {\n\t#registryConfig: RegistryConfig;\n\t#runConfig: RunConfig;\n\t#state: FileSystemGlobalState;\n\t#driverConfig: DriverConfig;\n\n\t#actorDriver: ActorDriver;\n\t#actorRouter: ActorRouter;\n\n\tinspector?: ManagerInspector;\n\n\tconstructor(\n\t\tregistryConfig: RegistryConfig,\n\t\trunConfig: RunConfig,\n\t\tstate: FileSystemGlobalState,\n\t\tdriverConfig: DriverConfig,\n\t) {\n\t\tthis.#registryConfig = registryConfig;\n\t\tthis.#runConfig = runConfig;\n\t\tthis.#state = state;\n\t\tthis.#driverConfig = driverConfig;\n\n\t\tif (runConfig.inspector.enabled) {\n\t\t\tif (!this.#runConfig.inspector.token()) {\n\t\t\t\tthis.#runConfig.inspector.token = () =>\n\t\t\t\t\tthis.#state.getOrCreateInspectorAccessToken();\n\t\t\t}\n\t\t\tconst startedAt = new Date().toISOString();\n\t\t\tfunction transformActor(actorState: schema.ActorState): Actor {\n\t\t\t\treturn {\n\t\t\t\t\tid: actorState.actorId as ActorId,\n\t\t\t\t\tname: actorState.name,\n\t\t\t\t\tkey: actorState.key as string[],\n\t\t\t\t\tstartedAt: startedAt,\n\t\t\t\t\tcreatedAt: new Date(Number(actorState.createdAt)).toISOString(),\n\t\t\t\t\tfeatures: [\n\t\t\t\t\t\tActorFeature.State,\n\t\t\t\t\t\tActorFeature.Connections,\n\t\t\t\t\t\tActorFeature.Console,\n\t\t\t\t\t\tActorFeature.EventsMonitoring,\n\t\t\t\t\t\tActorFeature.Database,\n\t\t\t\t\t],\n\t\t\t\t};\n\t\t\t}\n\n\t\t\tthis.inspector = new ManagerInspector(() => {\n\t\t\t\treturn {\n\t\t\t\t\tgetAllActors: async ({ cursor, limit }) => {\n\t\t\t\t\t\tconst itr = this.#state.getActorsIterator({ cursor });\n\t\t\t\t\t\tconst actors: Actor[] = [];\n\n\t\t\t\t\t\tfor await (const actor of itr) {\n\t\t\t\t\t\t\tactors.push(transformActor(actor));\n\t\t\t\t\t\t\tif (limit && actors.length >= limit) {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn actors;\n\t\t\t\t\t},\n\t\t\t\t\tgetActorById: async (id) => {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst result = await this.#state.loadActorStateOrError(id);\n\t\t\t\t\t\t\treturn transformActor(result);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t\tgetBuilds: async () => {\n\t\t\t\t\t\treturn Object.keys(this.#registryConfig.use).map((name) => ({\n\t\t\t\t\t\t\tname,\n\t\t\t\t\t\t}));\n\t\t\t\t\t},\n\t\t\t\t\tcreateActor: async (input) => {\n\t\t\t\t\t\tconst { actorId } = await this.createActor(input);\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tconst result = await this.#state.loadActorStateOrError(actorId);\n\t\t\t\t\t\t\treturn transformActor(result);\n\t\t\t\t\t\t} catch {\n\t\t\t\t\t\t\treturn null;\n\t\t\t\t\t\t}\n\t\t\t\t\t},\n\t\t\t\t};\n\t\t\t});\n\t\t}\n\n\t\t// Actors run on the same node as the manager, so we create a dummy actor router that we route requests to\n\t\tconst inlineClient = createClientWithDriver(createInlineClientDriver(this));\n\t\tthis.#actorDriver = this.#driverConfig.actor(\n\t\t\tregistryConfig,\n\t\t\trunConfig,\n\t\t\tthis,\n\t\t\tinlineClient,\n\t\t);\n\t\tthis.#actorRouter = createActorRouter(this.#runConfig, this.#actorDriver);\n\t}\n\n\tasync sendRequest(actorId: string, actorRequest: Request): Promise<Response> {\n\t\treturn await this.#actorRouter.fetch(actorRequest, {\n\t\t\tactorId,\n\t\t});\n\t}\n\n\tasync openWebSocket(\n\t\tpath: string,\n\t\tactorId: string,\n\t\tencoding: Encoding,\n\t\tparams: unknown,\n\t): Promise<WebSocket> {\n\t\t// TODO:\n\n\t\t// Handle raw WebSocket paths\n\t\tif (path === PATH_CONNECT_WEBSOCKET) {\n\t\t\t// Handle standard connect\n\t\t\tconst wsHandler = await handleWebSocketConnect(\n\t\t\t\tundefined,\n\t\t\t\tthis.#runConfig,\n\t\t\t\tthis.#actorDriver,\n\t\t\t\tactorId,\n\t\t\t\tencoding,\n\t\t\t\tparams,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\treturn new InlineWebSocketAdapter2(wsHandler);\n\t\t} else if (path.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {\n\t\t\t// Handle websocket proxy\n\t\t\tconst wsHandler = await handleRawWebSocketHandler(\n\t\t\t\tundefined,\n\t\t\t\tpath,\n\t\t\t\tthis.#actorDriver,\n\t\t\t\tactorId,\n\t\t\t\tundefined,\n\t\t\t);\n\t\t\treturn new InlineWebSocketAdapter2(wsHandler);\n\t\t} else {\n\t\t\tthrow new Error(`Unreachable path: ${path}`);\n\t\t}\n\t}\n\n\tasync proxyRequest(\n\t\tc: HonoContext,\n\t\tactorRequest: Request,\n\t\tactorId: string,\n\t): Promise<Response> {\n\t\treturn await this.#actorRouter.fetch(actorRequest, {\n\t\t\tactorId,\n\t\t});\n\t}\n\n\tasync proxyWebSocket(\n\t\tc: HonoContext,\n\t\tpath: string,\n\t\tactorId: string,\n\t\tencoding: Encoding,\n\t\tconnParams: unknown,\n\t\tauthData: unknown,\n\t): Promise<Response> {\n\t\tconst upgradeWebSocket = this.#runConfig.getUpgradeWebSocket?.();\n\t\tinvariant(upgradeWebSocket, \"missing getUpgradeWebSocket\");\n\n\t\t// Handle raw WebSocket paths\n\t\tif (path === PATH_CONNECT_WEBSOCKET) {\n\t\t\t// Handle standard connect\n\t\t\tconst wsHandler = await handleWebSocketConnect(\n\t\t\t\tc.req.raw,\n\t\t\t\tthis.#runConfig,\n\t\t\t\tthis.#actorDriver,\n\t\t\t\tactorId,\n\t\t\t\tencoding,\n\t\t\t\tconnParams,\n\t\t\t\tauthData,\n\t\t\t);\n\n\t\t\treturn upgradeWebSocket(() => wsHandler)(c, noopNext());\n\t\t} else if (path.startsWith(PATH_RAW_WEBSOCKET_PREFIX)) {\n\t\t\t// Handle websocket proxy\n\t\t\tconst wsHandler = await handleRawWebSocketHandler(\n\t\t\t\tc.req.raw,\n\t\t\t\tpath,\n\t\t\t\tthis.#actorDriver,\n\t\t\t\tactorId,\n\t\t\t\tauthData,\n\t\t\t);\n\n\t\t\treturn upgradeWebSocket(() => wsHandler)(c, noopNext());\n\t\t} else {\n\t\t\tthrow new Error(`Unreachable path: ${path}`);\n\t\t}\n\t}\n\n\tasync getForId({ actorId }: GetForIdInput): Promise<ActorOutput | undefined> {\n\t\t// Validate the actor exists\n\t\tconst actor = await this.#state.loadActor(actorId);\n\t\tif (!actor.state) {\n\t\t\treturn undefined;\n\t\t}\n\n\t\ttry {\n\t\t\t// Load actor state\n\t\t\treturn {\n\t\t\t\tactorId,\n\t\t\t\tname: actor.state.name,\n\t\t\t\tkey: actor.state.key as string[],\n\t\t\t};\n\t\t} catch (error) {\n\t\t\tlogger().error(\"failed to read actor state\", { actorId, error });\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tasync getWithKey({\n\t\tname,\n\t\tkey,\n\t}: GetWithKeyInput): Promise<ActorOutput | undefined> {\n\t\t// Generate the deterministic actor ID\n\t\tconst actorId = generateActorId(name, key);\n\n\t\t// Check if actor exists\n\t\tconst actor = await this.#state.loadActor(actorId);\n\t\tif (actor.state) {\n\t\t\treturn {\n\t\t\t\tactorId,\n\t\t\t\tname,\n\t\t\t\tkey,\n\t\t\t};\n\t\t}\n\n\t\treturn undefined;\n\t}\n\n\tasync getOrCreateWithKey(\n\t\tinput: GetOrCreateWithKeyInput,\n\t): Promise<ActorOutput> {\n\t\t// Generate the deterministic actor ID\n\t\tconst actorId = generateActorId(input.name, input.key);\n\n\t\t// Use the atomic getOrCreateActor method\n\t\tconst actorEntry = await this.#state.loadOrCreateActor(\n\t\t\tactorId,\n\t\t\tinput.name,\n\t\t\tinput.key,\n\t\t\tinput.input,\n\t\t);\n\t\tinvariant(actorEntry.state, \"must have state\");\n\n\t\treturn {\n\t\t\tactorId: actorEntry.state.actorId,\n\t\t\tname: actorEntry.state.name,\n\t\t\tkey: actorEntry.state.key as string[],\n\t\t};\n\t}\n\n\tasync createActor({ name, key, input }: CreateInput): Promise<ActorOutput> {\n\t\t// Generate the deterministic actor ID\n\t\tconst actorId = generateActorId(name, key);\n\n\t\tawait this.#state.createActor(actorId, name, key, input);\n\n\t\treturn {\n\t\t\tactorId,\n\t\t\tname,\n\t\t\tkey,\n\t\t};\n\t}\n\n\textraStartupLog() {\n\t\treturn {\n\t\t\tinstances: this.#state.actorCountOnStartup,\n\t\t\tdata: this.#state.storagePath,\n\t\t};\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver/mod.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver/mod.ts\";import * as cbor from \"cbor-x\";\nimport type { Context as HonoContext } from \"hono\";\nimport invariant from \"invariant\";\nimport onChange from \"on-change\";\nimport type { WebSocket } from \"ws\";\nimport * as errors from \"@/actor/errors\";\nimport type { Encoding } from \"@/actor/protocol/serde\";\nimport {\n\tPATH_CONNECT_WEBSOCKET,\n\tPATH_RAW_WEBSOCKET_PREFIX,\n} from \"@/actor/router\";\nimport {\n\tHEADER_CONN_ID,\n\tHEADER_CONN_PARAMS,\n\tHEADER_CONN_TOKEN,\n\tHEADER_ENCODING,\n\tHEADER_EXPOSE_INTERNAL_ERROR,\n} from \"@/actor/router-endpoints\";\nimport { assertUnreachable } from \"@/actor/utils\";\nimport type { ClientDriver } from \"@/client/client\";\nimport { ActorError as ClientActorError } from \"@/client/errors\";\nimport { sendHttpRequest } from \"@/client/utils\";\nimport { importEventSource } from \"@/common/eventsource\";\nimport type { UniversalEventSource } from \"@/common/eventsource-interface\";\nimport { deconstructError } from \"@/common/utils\";\nimport type { ManagerDriver } from \"@/manager/driver\";\nimport type { ActorQuery } from \"@/manager/protocol/query\";\nimport type { RunConfig } from \"@/mod\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport {\n\tHTTP_ACTION_REQUEST_VERSIONED,\n\tHTTP_ACTION_RESPONSE_VERSIONED,\n\tTO_CLIENT_VERSIONED,\n\tTO_SERVER_VERSIONED,\n} from \"@/schemas/client-protocol/versioned\";\nimport { bufferToArrayBuffer, httpUserAgent } from \"@/utils\";\nimport { logger } from \"./log\";\n\n/**\n * Client driver that calls the manager driver inline.\n *\n * This is only applicable to standalone & coordinated topologies.\n *\n * This driver can access private resources.\n *\n * This driver serves a double purpose as:\n * - Providing the client for the internal requests\n * - Provide the driver for the manager HTTP router (see manager/router.ts)\n */\nexport function createInlineClientDriver(\n\tmanagerDriver: ManagerDriver,\n): ClientDriver {\n\tconst driver: ClientDriver = {\n\t\taction: async <Args extends Array<unknown> = unknown[], Response = unknown>(\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\tencoding: Encoding,\n\t\t\tparams: unknown,\n\t\t\tactionName: string,\n\t\t\targs: Args,\n\t\t\topts: { signal?: AbortSignal },\n\t\t): Promise<Response> => {\n\t\t\ttry {\n\t\t\t\t// Get the actor ID\n\t\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\t\tlogger().debug(\"found actor for action\", { actorId });\n\t\t\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t\t\t// Invoke the action\n\t\t\t\tlogger().debug(\"handling action\", { actionName, encoding });\n\t\t\t\tconst responseData = await sendHttpRequest<\n\t\t\t\t\tprotocol.HttpActionRequest,\n\t\t\t\t\tprotocol.HttpActionResponse\n\t\t\t\t>({\n\t\t\t\t\turl: `http://actor/action/${encodeURIComponent(actionName)}`,\n\t\t\t\t\tmethod: \"POST\",\n\t\t\t\t\theaders: {\n\t\t\t\t\t\t[HEADER_ENCODING]: encoding,\n\t\t\t\t\t\t...(params !== undefined\n\t\t\t\t\t\t\t? { [HEADER_CONN_PARAMS]: JSON.stringify(params) }\n\t\t\t\t\t\t\t: {}),\n\t\t\t\t\t\t[HEADER_EXPOSE_INTERNAL_ERROR]: \"true\",\n\t\t\t\t\t},\n\t\t\t\t\tbody: {\n\t\t\t\t\t\targs: bufferToArrayBuffer(cbor.encode(args)),\n\t\t\t\t\t} satisfies protocol.HttpActionRequest,\n\t\t\t\t\tencoding: encoding,\n\t\t\t\t\tcustomFetch: managerDriver.sendRequest.bind(managerDriver, actorId),\n\t\t\t\t\tsignal: opts?.signal,\n\t\t\t\t\trequestVersionedDataHandler: HTTP_ACTION_REQUEST_VERSIONED,\n\t\t\t\t\tresponseVersionedDataHandler: HTTP_ACTION_RESPONSE_VERSIONED,\n\t\t\t\t});\n\n\t\t\t\treturn cbor.decode(new Uint8Array(responseData.output));\n\t\t\t} catch (err) {\n\t\t\t\t// Standardize to ClientActorError instead of the native backend error\n\t\t\t\tconst { code, message, metadata } = deconstructError(\n\t\t\t\t\terr,\n\t\t\t\t\tlogger(),\n\t\t\t\t\t{},\n\t\t\t\t\ttrue,\n\t\t\t\t);\n\t\t\t\tconst x = new ClientActorError(code, message, metadata);\n\t\t\t\tthrow new ClientActorError(code, message, metadata);\n\t\t\t}\n\t\t},\n\n\t\tresolveActorId: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\t_encodingKind: Encoding,\n\t\t): Promise<string> => {\n\t\t\t// Get the actor ID\n\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\tlogger().debug(\"resolved actor\", { actorId });\n\t\t\tinvariant(actorId, \"missing actor ID\");\n\n\t\t\treturn actorId;\n\t\t},\n\n\t\tconnectWebSocket: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\tencodingKind: Encoding,\n\t\t\tparams?: unknown,\n\t\t): Promise<WebSocket> => {\n\t\t\t// Get the actor ID\n\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\tlogger().debug(\"found actor for action\", { actorId });\n\t\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t\t// Invoke the action\n\t\t\tlogger().debug(\"opening websocket\", { actorId, encoding: encodingKind });\n\n\t\t\t// Open WebSocket\n\t\t\tconst ws = await managerDriver.openWebSocket(\n\t\t\t\tPATH_CONNECT_WEBSOCKET,\n\t\t\t\tactorId,\n\t\t\t\tencodingKind,\n\t\t\t\tparams,\n\t\t\t);\n\n\t\t\t// Node & browser WebSocket types are incompatible\n\t\t\treturn ws as any;\n\t\t},\n\n\t\tconnectSse: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\tencodingKind: Encoding,\n\t\t\tparams: unknown,\n\t\t): Promise<UniversalEventSource> => {\n\t\t\t// Get the actor ID\n\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\tlogger().debug(\"found actor for sse connection\", { actorId });\n\t\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t\tlogger().debug(\"opening sse connection\", {\n\t\t\t\tactorId,\n\t\t\t\tencoding: encodingKind,\n\t\t\t});\n\n\t\t\tconst EventSourceClass = await importEventSource();\n\n\t\t\tconst eventSource = new EventSourceClass(\"http://actor/connect/sse\", {\n\t\t\t\tfetch: (input, init) => {\n\t\t\t\t\treturn fetch(input, {\n\t\t\t\t\t\t...init,\n\t\t\t\t\t\theaders: {\n\t\t\t\t\t\t\t...init?.headers,\n\t\t\t\t\t\t\t\"User-Agent\": httpUserAgent(),\n\t\t\t\t\t\t\t[HEADER_ENCODING]: encodingKind,\n\t\t\t\t\t\t\t...(params !== undefined\n\t\t\t\t\t\t\t\t? { [HEADER_CONN_PARAMS]: JSON.stringify(params) }\n\t\t\t\t\t\t\t\t: {}),\n\t\t\t\t\t\t\t[HEADER_EXPOSE_INTERNAL_ERROR]: \"true\",\n\t\t\t\t\t\t},\n\t\t\t\t\t});\n\t\t\t\t},\n\t\t\t}) as UniversalEventSource;\n\n\t\t\treturn eventSource;\n\t\t},\n\n\t\tsendHttpMessage: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorId: string,\n\t\t\tencoding: Encoding,\n\t\t\tconnectionId: string,\n\t\t\tconnectionToken: string,\n\t\t\tmessage: protocol.ToServer,\n\t\t): Promise<void> => {\n\t\t\tlogger().debug(\"sending http message\", { actorId, connectionId });\n\n\t\t\t// Send an HTTP request to the connections endpoint\n\t\t\tawait sendHttpRequest({\n\t\t\t\turl: \"http://actor/connections/message\",\n\t\t\t\tmethod: \"POST\",\n\t\t\t\theaders: {\n\t\t\t\t\t[HEADER_ENCODING]: encoding,\n\t\t\t\t\t[HEADER_CONN_ID]: connectionId,\n\t\t\t\t\t[HEADER_CONN_TOKEN]: connectionToken,\n\t\t\t\t\t[HEADER_EXPOSE_INTERNAL_ERROR]: \"true\",\n\t\t\t\t},\n\t\t\t\tbody: message,\n\t\t\t\tencoding,\n\t\t\t\tskipParseResponse: true,\n\t\t\t\tcustomFetch: managerDriver.sendRequest.bind(managerDriver, actorId),\n\t\t\t\trequestVersionedDataHandler: TO_SERVER_VERSIONED,\n\t\t\t\tresponseVersionedDataHandler: TO_CLIENT_VERSIONED,\n\t\t\t});\n\t\t},\n\n\t\trawHttpRequest: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\tencoding: Encoding,\n\t\t\tparams: unknown,\n\t\t\tpath: string,\n\t\t\tinit: RequestInit,\n\t\t): Promise<Response> => {\n\t\t\ttry {\n\t\t\t\t// Get the actor ID\n\t\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\t\tlogger().debug(\"found actor for raw http\", { actorId });\n\t\t\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t\t\t// Build the URL with normalized path\n\t\t\t\tconst normalizedPath = path.startsWith(\"/\") ? path.slice(1) : path;\n\t\t\t\tconst url = new URL(`http://actor/raw/http/${normalizedPath}`);\n\n\t\t\t\t// Forward conn params if provided\n\t\t\t\tconst proxyRequestHeaders = new Headers(init.headers);\n\t\t\t\tif (params) {\n\t\t\t\t\tproxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(params));\n\t\t\t\t}\n\n\t\t\t\t// Forward the request to the actor\n\t\t\t\tconst proxyRequest = new Request(url, {\n\t\t\t\t\t...init,\n\t\t\t\t\theaders: proxyRequestHeaders,\n\t\t\t\t});\n\n\t\t\t\treturn await managerDriver.sendRequest(actorId, proxyRequest);\n\t\t\t} catch (err) {\n\t\t\t\t// Standardize to ClientActorError instead of the native backend error\n\t\t\t\tconst { code, message, metadata } = deconstructError(\n\t\t\t\t\terr,\n\t\t\t\t\tlogger(),\n\t\t\t\t\t{},\n\t\t\t\t\ttrue,\n\t\t\t\t);\n\t\t\t\tthrow new ClientActorError(code, message, metadata);\n\t\t\t}\n\t\t},\n\n\t\trawWebSocket: async (\n\t\t\tc: HonoContext | undefined,\n\t\t\tactorQuery: ActorQuery,\n\t\t\tencoding: Encoding,\n\t\t\tparams: unknown,\n\t\t\tpath: string,\n\t\t\tprotocols: string | string[] | undefined,\n\t\t): Promise<WebSocket> => {\n\t\t\t// Get the actor ID\n\t\t\tconst { actorId } = await queryActor(c, actorQuery, managerDriver);\n\t\t\tlogger().debug(\"found actor for action\", { actorId });\n\t\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t\t// Normalize path to match raw HTTP behavior\n\t\t\tconst normalizedPath = path.startsWith(\"/\") ? path.slice(1) : path;\n\t\t\tlogger().debug(\"opening websocket\", {\n\t\t\t\tactorId,\n\t\t\t\tencoding,\n\t\t\t\tpath: normalizedPath,\n\t\t\t});\n\n\t\t\t// Open WebSocket\n\t\t\tconst ws = await managerDriver.openWebSocket(\n\t\t\t\t`${PATH_RAW_WEBSOCKET_PREFIX}${normalizedPath}`,\n\t\t\t\tactorId,\n\t\t\t\tencoding,\n\t\t\t\tparams,\n\t\t\t);\n\n\t\t\t// Node & browser WebSocket types are incompatible\n\t\t\treturn ws as any;\n\t\t},\n\t};\n\n\treturn driver;\n}\n\n/**\n * Query the manager driver to get or create a actor based on the provided query\n */\nexport async function queryActor(\n\tc: HonoContext | undefined,\n\tquery: ActorQuery,\n\tdriver: ManagerDriver,\n): Promise<{ actorId: string }> {\n\tlogger().debug(\"querying actor\", { query });\n\tlet actorOutput: { actorId: string };\n\tif (\"getForId\" in query) {\n\t\tconst output = await driver.getForId({\n\t\t\tc,\n\t\t\tname: query.getForId.name,\n\t\t\tactorId: query.getForId.actorId,\n\t\t});\n\t\tif (!output) throw new errors.ActorNotFound(query.getForId.actorId);\n\t\tactorOutput = output;\n\t} else if (\"getForKey\" in query) {\n\t\tconst existingActor = await driver.getWithKey({\n\t\t\tc,\n\t\t\tname: query.getForKey.name,\n\t\t\tkey: query.getForKey.key,\n\t\t});\n\t\tif (!existingActor) {\n\t\t\tthrow new errors.ActorNotFound(\n\t\t\t\t`${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`,\n\t\t\t);\n\t\t}\n\t\tactorOutput = existingActor;\n\t} else if (\"getOrCreateForKey\" in query) {\n\t\tconst getOrCreateOutput = await driver.getOrCreateWithKey({\n\t\t\tc,\n\t\t\tname: query.getOrCreateForKey.name,\n\t\t\tkey: query.getOrCreateForKey.key,\n\t\t\tinput: query.getOrCreateForKey.input,\n\t\t\tregion: query.getOrCreateForKey.region,\n\t\t});\n\t\tactorOutput = {\n\t\t\tactorId: getOrCreateOutput.actorId,\n\t\t};\n\t} else if (\"create\" in query) {\n\t\tconst createOutput = await driver.createActor({\n\t\t\tc,\n\t\t\tname: query.create.name,\n\t\t\tkey: query.create.key,\n\t\t\tinput: query.create.input,\n\t\t\tregion: query.create.region,\n\t\t});\n\t\tactorOutput = {\n\t\t\tactorId: createOutput.actorId,\n\t\t};\n\t} else {\n\t\tthrow new errors.InvalidRequest(\"Invalid query format\");\n\t}\n\n\tlogger().debug(\"actor query result\", {\n\t\tactorId: actorOutput.actorId,\n\t});\n\treturn { actorId: actorOutput.actorId };\n}\n\n/**\n * Removes the on-change library's proxy recursively from a value so we can clone it with `structuredClone`.\n */\nfunction unproxyRecursive<T>(objProxied: T): T {\n\tconst obj = onChange.target<any>(objProxied);\n\n\t// Short circuit if this object was proxied\n\t//\n\t// If the reference is different, then this value was proxied and no\n\t// nested values are proxied\n\tif (obj !== objProxied) return obj;\n\n\t// Handle null/undefined\n\tif (!obj || typeof obj !== \"object\") {\n\t\treturn obj;\n\t}\n\n\t// Handle arrays\n\tif (Array.isArray(obj)) {\n\t\treturn obj.map((x) => unproxyRecursive<any>(x)) as T;\n\t}\n\n\t// Handle objects\n\tconst result: any = {};\n\tfor (const key in obj) {\n\t\tresult[key] = unproxyRecursive<any>(obj[key]);\n\t}\n\n\treturn result;\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common/eventsource.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/common\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/common/eventsource.ts\";import type { EventSource } from \"eventsource\";\nimport { logger } from \"@/client/log\";\n\n// Global singleton promise that will be reused for subsequent calls\nlet eventSourcePromise: Promise<typeof EventSource> | null = null;\n\n/**\n * Import `eventsource` from the custom `eventsource` library. We need a custom implemnetation since we need to attach our own custom headers to the request.\n **/\nexport async function importEventSource(): Promise<typeof EventSource> {\n\t// Return existing promise if we already started loading\n\tif (eventSourcePromise !== null) {\n\t\treturn eventSourcePromise;\n\t}\n\n\t// Create and store the promise\n\teventSourcePromise = (async () => {\n\t\tlet _EventSource: typeof EventSource;\n\n\t\t// Node.js environment\n\t\ttry {\n\t\t\tconst es = await import(\"eventsource\");\n\t\t\t_EventSource = es.EventSource;\n\t\t\tlogger().debug(\"using eventsource from npm\");\n\t\t} catch (err) {\n\t\t\t// EventSource not available\n\t\t\t_EventSource = class MockEventSource {\n\t\t\t\tconstructor() {\n\t\t\t\t\tthrow new Error(\n\t\t\t\t\t\t'EventSource support requires installing the \"eventsource\" peer dependency.',\n\t\t\t\t\t);\n\t\t\t\t}\n\t\t\t} as unknown as typeof EventSource;\n\t\t\tlogger().debug(\"using mock eventsource\");\n\t\t}\n\n\t\treturn _EventSource;\n\t})();\n\n\treturn eventSourcePromise;\n}\n\n//export async function importEventSource(): Promise<typeof EventSource> {\n//\t// Return existing promise if we already started loading\n//\tif (eventSourcePromise !== null) {\n//\t\treturn eventSourcePromise;\n//\t}\n//\n//\t// Create and store the promise\n//\teventSourcePromise = (async () => {\n//\t\tlet _EventSource: typeof EventSource;\n//\n//\t\tif (typeof EventSource !== \"undefined\") {\n//\t\t\t// Browser environment\n//\t\t\t_EventSource = EventSource;\n//\t\t\tlogger().debug(\"using native eventsource\");\n//\t\t} else {\n//\t\t\t// Node.js environment\n//\t\t\ttry {\n//\t\t\t\tconst es = await import(\"eventsource\");\n//\t\t\t\t_EventSource = es.EventSource;\n//\t\t\t\tlogger().debug(\"using eventsource from npm\");\n//\t\t\t} catch (err) {\n//\t\t\t\t// EventSource not available\n//\t\t\t\t_EventSource = class MockEventSource {\n//\t\t\t\t\tconstructor() {\n//\t\t\t\t\t\tthrow new Error(\n//\t\t\t\t\t\t\t'EventSource support requires installing the \"eventsource\" peer dependency.',\n//\t\t\t\t\t\t);\n//\t\t\t\t\t}\n//\t\t\t\t} as unknown as typeof EventSource;\n//\t\t\t\tlogger().debug(\"using mock eventsource\");\n//\t\t\t}\n//\t\t}\n//\n//\t\treturn _EventSource;\n//\t})();\n//\n//\treturn eventSourcePromise;\n//}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inline-client-driver/log.ts\";import { getLogger } from \"@/common//log\";\n\nexport const LOGGER_NAME = \"inline-client-driver\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector/manager.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/inspector\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/inspector/manager.ts\";import { sValidator } from \"@hono/standard-validator\";\nimport { Hono } from \"hono\";\nimport invariant from \"invariant\";\nimport type { CreateInput } from \"@/manager/driver\";\nimport { inspectorLogger } from \"./log\";\nimport { type Actor, type Builds, CreateActorSchema } from \"./protocol/common\";\n\nexport type ManagerInspectorRouterEnv = {\n\tVariables: {\n\t\tinspector: ManagerInspector;\n\t};\n};\n\n/**\n * Create a router for the Manager Inspector.\n * @internal\n */\nexport function createManagerInspectorRouter() {\n\treturn new Hono<ManagerInspectorRouterEnv>()\n\t\t.get(\"/ping\", (c) => {\n\t\t\treturn c.json({ message: \"pong\" }, 200);\n\t\t})\n\t\t.get(\"/actors\", async (c) => {\n\t\t\tconst limit = Number.parseInt(c.req.query(\"limit\") ?? \"\") || undefined;\n\t\t\tconst cursor = c.req.query(\"cursor\") || undefined;\n\n\t\t\tif (!limit || (limit && limit <= 0)) {\n\t\t\t\treturn c.json(\"Invalid limit\", 400);\n\t\t\t}\n\n\t\t\ttry {\n\t\t\t\tconst actors = await c.var.inspector.accessors.getAllActors({\n\t\t\t\t\tlimit,\n\t\t\t\t\tcursor,\n\t\t\t\t});\n\t\t\t\treturn c.json(actors, 200);\n\t\t\t} catch (error) {\n\t\t\t\tinspectorLogger().error(\"Failed to fetch actors\", error);\n\t\t\t\treturn c.json(\"Failed to fetch actors\", 500);\n\t\t\t}\n\t\t})\n\n\t\t.post(\"/actors\", sValidator(\"json\", CreateActorSchema), async (c) => {\n\t\t\tconst actor = await c.var.inspector.accessors.createActor(\n\t\t\t\tc.req.valid(\"json\"),\n\t\t\t);\n\t\t\treturn c.json(actor, 201);\n\t\t})\n\t\t.get(\"/builds\", async (c) => {\n\t\t\tconst builds = await c.var.inspector.accessors.getBuilds();\n\t\t\treturn c.json(builds, 200);\n\t\t})\n\t\t.get(\"/actor/:id\", async (c) => {\n\t\t\tconst id = c.req.param(\"id\");\n\t\t\tconst actor = await c.var.inspector.accessors.getActorById(id);\n\t\t\tif (!actor) {\n\t\t\t\treturn c.json({ error: \"Actor not found\" }, 404);\n\t\t\t}\n\t\t\treturn c.json(actor, 200);\n\t\t})\n\t\t.get(\"/bootstrap\", async (c) => {\n\t\t\tconst actors = await c.var.inspector.accessors.getAllActors({\n\t\t\t\tlimit: 10,\n\t\t\t});\n\t\t\treturn c.json({ actors }, 200);\n\t\t});\n}\n\ninterface ManagerInspectorAccessors {\n\tgetAllActors: (param: { cursor?: string; limit: number }) => Promise<Actor[]>;\n\tgetActorById: (id: string) => Promise<Actor | null>;\n\tgetBuilds: () => Promise<Builds>;\n\tcreateActor: (input: CreateInput) => Promise<Actor | null>;\n}\n\n/**\n * Provides a unified interface for inspecting actor external and internal state.\n */\nexport class ManagerInspector {\n\tpublic readonly accessors: ManagerInspectorAccessors;\n\n\tconstructor(accessors: () => ManagerInspectorAccessors) {\n\t\tthis.accessors = accessors();\n\t\tinspectorLogger().debug(\"Manager Inspector enabled and ready\");\n\t}\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/mod.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/file-system/mod.ts\";import type { DriverConfig } from \"@/registry/run-config\";\nimport { FileSystemActorDriver } from \"./actor\";\nimport { FileSystemGlobalState } from \"./global-state\";\nimport { FileSystemManagerDriver } from \"./manager\";\n\nexport { FileSystemActorDriver } from \"./actor\";\nexport { FileSystemGlobalState } from \"./global-state\";\nexport { FileSystemManagerDriver } from \"./manager\";\nexport { getStoragePath } from \"./utils\";\n\nexport function createFileSystemOrMemoryDriver(\n\tpersist: boolean = true,\n\tcustomPath?: string,\n): DriverConfig {\n\tconst state = new FileSystemGlobalState(persist, customPath);\n\tconst driverConfig: DriverConfig = {\n\t\tname: persist ? \"file-system\" : \"memory\",\n\t\tmanager: (registryConfig, runConfig) =>\n\t\t\tnew FileSystemManagerDriver(\n\t\t\t\tregistryConfig,\n\t\t\t\trunConfig,\n\t\t\t\tstate,\n\t\t\t\tdriverConfig,\n\t\t\t),\n\t\tactor: (registryConfig, runConfig, managerDriver, inlineClient) => {\n\t\t\tconst actorDriver = new FileSystemActorDriver(\n\t\t\t\tregistryConfig,\n\t\t\t\trunConfig,\n\t\t\t\tmanagerDriver,\n\t\t\t\tinlineClient,\n\t\t\t\tstate,\n\t\t\t);\n\n\t\t\tstate.onRunnerStart(registryConfig, runConfig, inlineClient, actorDriver);\n\n\t\t\treturn actorDriver;\n\t\t},\n\t};\n\treturn driverConfig;\n}\n\nexport function createFileSystemDriver(opts?: { path?: string }): DriverConfig {\n\treturn createFileSystemOrMemoryDriver(true, opts?.path);\n}\n\nexport function createMemoryDriver(): DriverConfig {\n\treturn createFileSystemOrMemoryDriver(false);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers/default.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/drivers\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/drivers/default.ts\";import { UserError } from \"@/actor/errors\";\nimport { logger } from \"@/actor/log\";\nimport { createEngineDriver } from \"@/drivers/engine/mod\";\nimport { createFileSystemOrMemoryDriver } from \"@/drivers/file-system/mod\";\nimport type { DriverConfig, RunConfig } from \"@/registry/run-config\";\nimport { getEnvUniversal } from \"@/utils\";\n\n/**\n * Chooses the appropriate driver based on the run configuration.\n */\nexport function chooseDefaultDriver(runConfig: RunConfig): DriverConfig {\n\tconst engineEndpoint = runConfig.engine || getEnvUniversal(\"RIVET_ENGINE\");\n\n\tif (engineEndpoint && runConfig.driver) {\n\t\tthrow new UserError(\n\t\t\t\"Cannot specify both 'engine' and 'driver' in configuration\",\n\t\t);\n\t}\n\n\tif (runConfig.driver) {\n\t\treturn runConfig.driver;\n\t}\n\n\tif (engineEndpoint) {\n\t\tlogger().debug(\"using rivet engine driver\", { endpoint: engineEndpoint });\n\t\treturn createEngineDriver({ endpoint: engineEndpoint });\n\t}\n\n\tlogger().debug(\"using default file system driver\");\n\treturn createFileSystemOrMemoryDriver(true);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/router.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/manager/router.ts\";import { createRoute, OpenAPIHono } from \"@hono/zod-openapi\";\nimport * as cbor from \"cbor-x\";\nimport {\n\tHono,\n\ttype Context as HonoContext,\n\ttype MiddlewareHandler,\n} from \"hono\";\nimport { cors } from \"hono/cors\";\nimport { streamSSE } from \"hono/streaming\";\nimport type { WSContext } from \"hono/ws\";\nimport invariant from \"invariant\";\nimport type { CloseEvent, MessageEvent, WebSocket } from \"ws\";\nimport { z } from \"zod\";\nimport * as errors from \"@/actor/errors\";\nimport type { Transport } from \"@/actor/protocol/old\";\nimport type { Encoding } from \"@/actor/protocol/serde\";\nimport {\n\tPATH_CONNECT_WEBSOCKET,\n\tPATH_RAW_WEBSOCKET_PREFIX,\n} from \"@/actor/router\";\nimport {\n\tALLOWED_PUBLIC_HEADERS,\n\tgetRequestEncoding,\n\tgetRequestQuery,\n\tHEADER_ACTOR_ID,\n\tHEADER_ACTOR_QUERY,\n\tHEADER_AUTH_DATA,\n\tHEADER_CONN_ID,\n\tHEADER_CONN_PARAMS,\n\tHEADER_CONN_TOKEN,\n\tHEADER_ENCODING,\n} from \"@/actor/router-endpoints\";\nimport type { ClientDriver } from \"@/client/client\";\nimport {\n\thandleRouteError,\n\thandleRouteNotFound,\n\tloggerMiddleware,\n} from \"@/common/router\";\nimport {\n\ttype DeconstructedError,\n\tdeconstructError,\n\tnoopNext,\n\tstringifyError,\n} from \"@/common/utils\";\nimport { createManagerInspectorRouter } from \"@/inspector/manager\";\nimport { secureInspector } from \"@/inspector/utils\";\nimport type { UpgradeWebSocketArgs } from \"@/mod\";\nimport type { RegistryConfig } from \"@/registry/config\";\nimport type { RunConfig } from \"@/registry/run-config\";\nimport type * as protocol from \"@/schemas/client-protocol/mod\";\nimport {\n\tHTTP_RESOLVE_RESPONSE_VERSIONED,\n\tTO_CLIENT_VERSIONED,\n} from \"@/schemas/client-protocol/versioned\";\nimport { serializeWithEncoding } from \"@/serde\";\nimport { bufferToArrayBuffer } from \"@/utils\";\nimport { authenticateEndpoint } from \"./auth\";\nimport type { ManagerDriver } from \"./driver\";\nimport { logger } from \"./log\";\nimport type { ActorQuery } from \"./protocol/query\";\nimport {\n\tActorQuerySchema,\n\tConnectRequestSchema,\n\tConnectWebSocketRequestSchema,\n\tConnMessageRequestSchema,\n\tResolveRequestSchema,\n} from \"./protocol/query\";\n\n/**\n * Parse WebSocket protocol headers for query and connection parameters\n */\nfunction parseWebSocketProtocols(protocols: string | undefined): {\n\tqueryRaw: string | undefined;\n\tencodingRaw: string | undefined;\n\tconnParamsRaw: string | undefined;\n} {\n\tlet queryRaw: string | undefined;\n\tlet encodingRaw: string | undefined;\n\tlet connParamsRaw: string | undefined;\n\n\tif (protocols) {\n\t\tconst protocolList = protocols.split(\",\").map((p) => p.trim());\n\t\tfor (const protocol of protocolList) {\n\t\t\tif (protocol.startsWith(\"query.\")) {\n\t\t\t\tqueryRaw = decodeURIComponent(protocol.substring(\"query.\".length));\n\t\t\t} else if (protocol.startsWith(\"encoding.\")) {\n\t\t\t\tencodingRaw = protocol.substring(\"encoding.\".length);\n\t\t\t} else if (protocol.startsWith(\"conn_params.\")) {\n\t\t\t\tconnParamsRaw = decodeURIComponent(\n\t\t\t\t\tprotocol.substring(\"conn_params.\".length),\n\t\t\t\t);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn { queryRaw, encodingRaw, connParamsRaw };\n}\n\nconst OPENAPI_ENCODING = z.string().openapi({\n\tdescription: \"The encoding format to use for the response (json, cbor)\",\n\texample: \"json\",\n});\n\nconst OPENAPI_ACTOR_QUERY = z.string().openapi({\n\tdescription: \"Actor query information\",\n});\n\nconst OPENAPI_CONN_PARAMS = z.string().openapi({\n\tdescription: \"Connection parameters\",\n});\n\nconst OPENAPI_ACTOR_ID = z.string().openapi({\n\tdescription: \"Actor ID (used in some endpoints)\",\n\texample: \"actor-123456\",\n});\n\nconst OPENAPI_CONN_ID = z.string().openapi({\n\tdescription: \"Connection ID\",\n\texample: \"conn-123456\",\n});\n\nconst OPENAPI_CONN_TOKEN = z.string().openapi({\n\tdescription: \"Connection token\",\n});\n\nfunction buildOpenApiResponses<T>(schema: T, validateBody: boolean) {\n\treturn {\n\t\t200: {\n\t\t\tdescription: \"Success\",\n\t\t\tcontent: validateBody\n\t\t\t\t? {\n\t\t\t\t\t\t\"application/json\": {\n\t\t\t\t\t\t\tschema,\n\t\t\t\t\t\t},\n\t\t\t\t\t}\n\t\t\t\t: {},\n\t\t},\n\t\t400: {\n\t\t\tdescription: \"User error\",\n\t\t},\n\t\t500: {\n\t\t\tdescription: \"Internal error\",\n\t\t},\n\t};\n}\n\n/**\n * Only use `validateBody` to `true` if you need to export OpenAPI JSON.\n *\n * If left enabled for production, this will cause errors. We disable JSON validation since:\n * - It prevents us from proxying requests, since validating the body requires consuming the body so we can't forward the body\n * - We validate all types at the actor router layer since most requests are proxied\n */\nexport function createManagerRouter(\n\tregistryConfig: RegistryConfig,\n\trunConfig: RunConfig,\n\tinlineClientDriver: ClientDriver,\n\tmanagerDriver: ManagerDriver,\n\tvalidateBody: boolean,\n): { router: Hono; openapi: OpenAPIHono } {\n\tconst router = new OpenAPIHono({ strict: false }).basePath(\n\t\trunConfig.basePath,\n\t);\n\n\trouter.use(\"*\", loggerMiddleware(logger()));\n\n\tif (runConfig.cors || runConfig.inspector?.cors) {\n\t\trouter.use(\"*\", async (c, next) => {\n\t\t\t// Don't apply to WebSocket routes\n\t\t\t// HACK: This could be insecure if we had a varargs path. We have to check the path suffix for WS since we don't know the path that this router was mounted.\n\t\t\t// HACK: Checking \"/websocket/\" is not safe, but there is no other way to handle this if we don't know the base path this is\n\t\t\t// mounted on\n\t\t\tconst path = c.req.path;\n\t\t\tif (\n\t\t\t\tpath.endsWith(\"/actors/connect/websocket\") ||\n\t\t\t\tpath.includes(\"/actors/raw/websocket/\") ||\n\t\t\t\t// inspectors implement their own CORS handling\n\t\t\t\tpath.endsWith(\"/inspect\") ||\n\t\t\t\tpath.endsWith(\"/actors/inspect\")\n\t\t\t) {\n\t\t\t\treturn next();\n\t\t\t}\n\n\t\t\treturn cors({\n\t\t\t\t...(runConfig.cors ?? {}),\n\t\t\t\t...(runConfig.inspector?.cors ?? {}),\n\t\t\t\torigin: (origin, c) => {\n\t\t\t\t\tconst inspectorOrigin = runConfig.inspector?.cors?.origin;\n\n\t\t\t\t\tif (inspectorOrigin !== undefined) {\n\t\t\t\t\t\tif (typeof inspectorOrigin === \"function\") {\n\t\t\t\t\t\t\tconst allowed = inspectorOrigin(origin, c);\n\t\t\t\t\t\t\tif (allowed) return allowed;\n\t\t\t\t\t\t\t// Proceed to next CORS config if none provided\n\t\t\t\t\t\t} else if (Array.isArray(inspectorOrigin)) {\n\t\t\t\t\t\t\treturn inspectorOrigin.includes(origin) ? origin : undefined;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn inspectorOrigin;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (runConfig.cors?.origin !== undefined) {\n\t\t\t\t\t\tif (typeof runConfig.cors.origin === \"function\") {\n\t\t\t\t\t\t\tconst allowed = runConfig.cors.origin(origin, c);\n\t\t\t\t\t\t\tif (allowed) return allowed;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\treturn runConfig.cors.origin as string;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\n\t\t\t\t\treturn null;\n\t\t\t\t},\n\t\t\t\tallowMethods: (origin, c) => {\n\t\t\t\t\tconst inspectorMethods = runConfig.inspector?.cors?.allowMethods;\n\t\t\t\t\tif (inspectorMethods) {\n\t\t\t\t\t\tif (typeof inspectorMethods === \"function\") {\n\t\t\t\t\t\t\treturn inspectorMethods(origin, c);\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn inspectorMethods;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (runConfig.cors?.allowMethods) {\n\t\t\t\t\t\tif (typeof runConfig.cors.allowMethods === \"function\") {\n\t\t\t\t\t\t\treturn runConfig.cors.allowMethods(origin, c);\n\t\t\t\t\t\t}\n\t\t\t\t\t\treturn runConfig.cors.allowMethods;\n\t\t\t\t\t}\n\n\t\t\t\t\treturn [];\n\t\t\t\t},\n\t\t\t\tallowHeaders: [\n\t\t\t\t\t...(runConfig.cors?.allowHeaders ?? []),\n\t\t\t\t\t...(runConfig.inspector?.cors?.allowHeaders ?? []),\n\t\t\t\t\t...ALLOWED_PUBLIC_HEADERS,\n\t\t\t\t\t\"Content-Type\",\n\t\t\t\t\t\"User-Agent\",\n\t\t\t\t],\n\t\t\t\tcredentials:\n\t\t\t\t\trunConfig.cors?.credentials ??\n\t\t\t\t\trunConfig.inspector?.cors?.credentials ??\n\t\t\t\t\ttrue,\n\t\t\t})(c, next);\n\t\t});\n\t}\n\n\t// GET /\n\trouter.get(\"/\", (c: HonoContext) => {\n\t\treturn c.text(\n\t\t\t\"This is an RivetKit registry.\\n\\nLearn more at https://rivetkit.org\",\n\t\t);\n\t});\n\n\t// POST /actors/resolve\n\t{\n\t\tconst ResolveQuerySchema = z\n\t\t\t.object({\n\t\t\t\tquery: z.any().openapi({\n\t\t\t\t\texample: { getForId: { actorId: \"actor-123\" } },\n\t\t\t\t}),\n\t\t\t})\n\t\t\t.openapi(\"ResolveQuery\");\n\n\t\tconst ResolveResponseSchema = z\n\t\t\t.object({\n\t\t\t\ti: z.string().openapi({\n\t\t\t\t\texample: \"actor-123\",\n\t\t\t\t}),\n\t\t\t})\n\t\t\t.openapi(\"ResolveResponse\");\n\n\t\tconst resolveRoute = createRoute({\n\t\t\tmethod: \"post\",\n\t\t\tpath: \"/actors/resolve\",\n\t\t\trequest: {\n\t\t\t\tbody: {\n\t\t\t\t\tcontent: validateBody\n\t\t\t\t\t\t? {\n\t\t\t\t\t\t\t\t\"application/json\": {\n\t\t\t\t\t\t\t\t\tschema: ResolveQuerySchema,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t: {},\n\t\t\t\t},\n\t\t\t\theaders: z.object({\n\t\t\t\t\t[HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY,\n\t\t\t\t}),\n\t\t\t},\n\t\t\tresponses: buildOpenApiResponses(ResolveResponseSchema, validateBody),\n\t\t});\n\n\t\trouter.openapi(resolveRoute, (c) =>\n\t\t\thandleResolveRequest(c, registryConfig, managerDriver),\n\t\t);\n\t}\n\n\t// GET /actors/connect/websocket\n\t{\n\t\t// HACK: WebSockets don't work with mounts, so we need to dynamically match the trailing path\n\t\trouter.use(\"*\", (c, next) => {\n\t\t\tif (c.req.path.endsWith(\"/actors/connect/websocket\")) {\n\t\t\t\treturn handleWebSocketConnectRequest(\n\t\t\t\t\tc,\n\t\t\t\t\tregistryConfig,\n\t\t\t\t\trunConfig,\n\t\t\t\t\tmanagerDriver,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\treturn next();\n\t\t});\n\n\t\t// This route is a noop, just used to generate docs\n\t\tconst wsRoute = createRoute({\n\t\t\tmethod: \"get\",\n\t\t\tpath: \"/actors/connect/websocket\",\n\t\t\tresponses: {\n\t\t\t\t101: {\n\t\t\t\t\tdescription: \"WebSocket upgrade\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\n\t\trouter.openapi(wsRoute, () => {\n\t\t\tthrow new Error(\"Should be unreachable\");\n\t\t});\n\t}\n\n\t// GET /actors/connect/sse\n\t{\n\t\tconst sseRoute = createRoute({\n\t\t\tmethod: \"get\",\n\t\t\tpath: \"/actors/connect/sse\",\n\t\t\trequest: {\n\t\t\t\theaders: z.object({\n\t\t\t\t\t[HEADER_ENCODING]: OPENAPI_ENCODING,\n\t\t\t\t\t[HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY,\n\t\t\t\t\t[HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional(),\n\t\t\t\t}),\n\t\t\t},\n\t\t\tresponses: {\n\t\t\t\t200: {\n\t\t\t\t\tdescription: \"SSE stream\",\n\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\"text/event-stream\": {\n\t\t\t\t\t\t\tschema: z.unknown(),\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\n\t\trouter.openapi(sseRoute, (c) =>\n\t\t\thandleSseConnectRequest(c, registryConfig, runConfig, managerDriver),\n\t\t);\n\t}\n\n\t// POST /actors/action/:action\n\t{\n\t\tconst ActionParamsSchema = z\n\t\t\t.object({\n\t\t\t\taction: z.string().openapi({\n\t\t\t\t\tparam: {\n\t\t\t\t\t\tname: \"action\",\n\t\t\t\t\t\tin: \"path\",\n\t\t\t\t\t},\n\t\t\t\t\texample: \"myAction\",\n\t\t\t\t}),\n\t\t\t})\n\t\t\t.openapi(\"ActionParams\");\n\n\t\tconst ActionRequestSchema = z\n\t\t\t.object({\n\t\t\t\tquery: z.any().openapi({\n\t\t\t\t\texample: { getForId: { actorId: \"actor-123\" } },\n\t\t\t\t}),\n\t\t\t\tbody: z\n\t\t\t\t\t.any()\n\t\t\t\t\t.optional()\n\t\t\t\t\t.openapi({\n\t\t\t\t\t\texample: { param1: \"value1\", param2: 123 },\n\t\t\t\t\t}),\n\t\t\t})\n\t\t\t.openapi(\"ActionRequest\");\n\n\t\tconst ActionResponseSchema = z.any().openapi(\"ActionResponse\");\n\n\t\tconst actionRoute = createRoute({\n\t\t\tmethod: \"post\",\n\t\t\tpath: \"/actors/actions/{action}\",\n\t\t\trequest: {\n\t\t\t\tparams: ActionParamsSchema,\n\t\t\t\tbody: {\n\t\t\t\t\tcontent: validateBody\n\t\t\t\t\t\t? {\n\t\t\t\t\t\t\t\t\"application/json\": {\n\t\t\t\t\t\t\t\t\tschema: ActionRequestSchema,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t: {},\n\t\t\t\t},\n\t\t\t\theaders: z.object({\n\t\t\t\t\t[HEADER_ENCODING]: OPENAPI_ENCODING,\n\t\t\t\t\t[HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional(),\n\t\t\t\t}),\n\t\t\t},\n\t\t\tresponses: buildOpenApiResponses(ActionResponseSchema, validateBody),\n\t\t});\n\n\t\trouter.openapi(actionRoute, (c) =>\n\t\t\thandleActionRequest(c, registryConfig, runConfig, managerDriver),\n\t\t);\n\t}\n\n\t// POST /actors/message\n\t{\n\t\tconst ConnectionMessageRequestSchema = z\n\t\t\t.object({\n\t\t\t\tmessage: z.any().openapi({\n\t\t\t\t\texample: { type: \"message\", content: \"Hello, actor!\" },\n\t\t\t\t}),\n\t\t\t})\n\t\t\t.openapi(\"ConnectionMessageRequest\");\n\n\t\tconst ConnectionMessageResponseSchema = z\n\t\t\t.any()\n\t\t\t.openapi(\"ConnectionMessageResponse\");\n\n\t\tconst messageRoute = createRoute({\n\t\t\tmethod: \"post\",\n\t\t\tpath: \"/actors/message\",\n\t\t\trequest: {\n\t\t\t\tbody: {\n\t\t\t\t\tcontent: validateBody\n\t\t\t\t\t\t? {\n\t\t\t\t\t\t\t\t\"application/json\": {\n\t\t\t\t\t\t\t\t\tschema: ConnectionMessageRequestSchema,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t: {},\n\t\t\t\t},\n\t\t\t\theaders: z.object({\n\t\t\t\t\t[HEADER_ACTOR_ID]: OPENAPI_ACTOR_ID,\n\t\t\t\t\t[HEADER_CONN_ID]: OPENAPI_CONN_ID,\n\t\t\t\t\t[HEADER_ENCODING]: OPENAPI_ENCODING,\n\t\t\t\t\t[HEADER_CONN_TOKEN]: OPENAPI_CONN_TOKEN,\n\t\t\t\t}),\n\t\t\t},\n\t\t\tresponses: buildOpenApiResponses(\n\t\t\t\tConnectionMessageResponseSchema,\n\t\t\t\tvalidateBody,\n\t\t\t),\n\t\t});\n\n\t\trouter.openapi(messageRoute, (c) =>\n\t\t\thandleMessageRequest(c, registryConfig, runConfig, managerDriver),\n\t\t);\n\t}\n\n\t// Raw HTTP endpoints - /actors/raw/http/*\n\t{\n\t\tconst RawHttpRequestBodySchema = z.any().optional().openapi({\n\t\t\tdescription: \"Raw request body (can be any content type)\",\n\t\t});\n\n\t\tconst RawHttpResponseSchema = z.any().openapi({\n\t\t\tdescription: \"Raw response from actor's onFetch handler\",\n\t\t});\n\n\t\t// Define common route config\n\t\tconst rawHttpRouteConfig = {\n\t\t\tpath: \"/actors/raw/http/*\",\n\t\t\trequest: {\n\t\t\t\theaders: z.object({\n\t\t\t\t\t[HEADER_ACTOR_QUERY]: OPENAPI_ACTOR_QUERY.optional(),\n\t\t\t\t\t[HEADER_CONN_PARAMS]: OPENAPI_CONN_PARAMS.optional(),\n\t\t\t\t}),\n\t\t\t\tbody: {\n\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\"*/*\": {\n\t\t\t\t\t\t\tschema: RawHttpRequestBodySchema,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t},\n\t\t\tresponses: {\n\t\t\t\t200: {\n\t\t\t\t\tdescription: \"Success - response from actor's onFetch handler\",\n\t\t\t\t\tcontent: {\n\t\t\t\t\t\t\"*/*\": {\n\t\t\t\t\t\t\tschema: RawHttpResponseSchema,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t},\n\t\t\t\t404: {\n\t\t\t\t\tdescription: \"Actor does not have an onFetch handler\",\n\t\t\t\t},\n\t\t\t\t500: {\n\t\t\t\t\tdescription: \"Internal server error or invalid response from actor\",\n\t\t\t\t},\n\t\t\t},\n\t\t};\n\n\t\t// Create routes for each HTTP method\n\t\tconst httpMethods = [\n\t\t\t\"get\",\n\t\t\t\"post\",\n\t\t\t\"put\",\n\t\t\t\"delete\",\n\t\t\t\"patch\",\n\t\t\t\"head\",\n\t\t\t\"options\",\n\t\t] as const;\n\t\tfor (const method of httpMethods) {\n\t\t\tconst route = createRoute({\n\t\t\t\tmethod,\n\t\t\t\t...rawHttpRouteConfig,\n\t\t\t});\n\n\t\t\trouter.openapi(route, async (c) => {\n\t\t\t\treturn handleRawHttpRequest(\n\t\t\t\t\tc,\n\t\t\t\t\tregistryConfig,\n\t\t\t\t\trunConfig,\n\t\t\t\t\tmanagerDriver,\n\t\t\t\t);\n\t\t\t});\n\t\t}\n\t}\n\n\t// Raw WebSocket endpoint - /actors/raw/websocket/*\n\t{\n\t\t// HACK: WebSockets don't work with mounts, so we need to dynamically match the trailing path\n\t\trouter.use(\"*\", async (c, next) => {\n\t\t\tif (c.req.path.includes(\"/raw/websocket/\")) {\n\t\t\t\treturn handleRawWebSocketRequest(\n\t\t\t\t\tc,\n\t\t\t\t\tregistryConfig,\n\t\t\t\t\trunConfig,\n\t\t\t\t\tmanagerDriver,\n\t\t\t\t);\n\t\t\t}\n\n\t\t\treturn next();\n\t\t});\n\n\t\t// This route is a noop, just used to generate docs\n\t\tconst rawWebSocketRoute = createRoute({\n\t\t\tmethod: \"get\",\n\t\t\tpath: \"/actors/raw/websocket/*\",\n\t\t\trequest: {},\n\t\t\tresponses: {\n\t\t\t\t101: {\n\t\t\t\t\tdescription: \"WebSocket upgrade successful\",\n\t\t\t\t},\n\t\t\t\t400: {\n\t\t\t\t\tdescription: \"WebSockets not enabled or invalid request\",\n\t\t\t\t},\n\t\t\t\t404: {\n\t\t\t\t\tdescription: \"Actor does not have an onWebSocket handler\",\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\n\t\trouter.openapi(rawWebSocketRoute, () => {\n\t\t\tthrow new Error(\"Should be unreachable\");\n\t\t});\n\t}\n\n\tif (runConfig.inspector?.enabled) {\n\t\trouter.route(\n\t\t\t\"/actors/inspect\",\n\t\t\tnew Hono()\n\t\t\t\t.use(\n\t\t\t\t\tcors(runConfig.inspector.cors),\n\t\t\t\t\tsecureInspector(runConfig),\n\t\t\t\t\tuniversalActorProxy({\n\t\t\t\t\t\tregistryConfig,\n\t\t\t\t\t\trunConfig,\n\t\t\t\t\t\tdriver: managerDriver,\n\t\t\t\t\t}),\n\t\t\t\t)\n\t\t\t\t.all(\"/\", (c) =>\n\t\t\t\t\t// this should be handled by the actor proxy, but just in case\n\t\t\t\t\tc.text(\"Unreachable.\", 404),\n\t\t\t\t),\n\t\t);\n\t\trouter.route(\n\t\t\t\"/inspect\",\n\t\t\tnew Hono()\n\t\t\t\t.use(\n\t\t\t\t\tcors(runConfig.inspector.cors),\n\t\t\t\t\tsecureInspector(runConfig),\n\t\t\t\t\tasync (c, next) => {\n\t\t\t\t\t\tconst inspector = managerDriver.inspector;\n\t\t\t\t\t\tinvariant(inspector, \"inspector not supported on this platform\");\n\n\t\t\t\t\t\tc.set(\"inspector\", inspector);\n\t\t\t\t\t\tawait next();\n\t\t\t\t\t},\n\t\t\t\t)\n\t\t\t\t.route(\"/\", createManagerInspectorRouter()),\n\t\t);\n\t}\n\n\tif (registryConfig.test.enabled) {\n\t\t// Add HTTP endpoint to test the inline client\n\t\t//\n\t\t// We have to do this in a router since this needs to run in the same server as the RivetKit registry. Some test contexts to not run in the same server.\n\t\trouter.post(\".test/inline-driver/call\", async (c) => {\n\t\t\t// TODO: use openapi instead\n\t\t\tconst buffer = await c.req.arrayBuffer();\n\t\t\tconst { encoding, transport, method, args }: TestInlineDriverCallRequest =\n\t\t\t\tcbor.decode(new Uint8Array(buffer));\n\n\t\t\tlogger().debug(\"received inline request\", {\n\t\t\t\tencoding,\n\t\t\t\ttransport,\n\t\t\t\tmethod,\n\t\t\t\targs,\n\t\t\t});\n\n\t\t\t// Forward inline driver request\n\t\t\tlet response: TestInlineDriverCallResponse<unknown>;\n\t\t\ttry {\n\t\t\t\tconst output = await ((inlineClientDriver as any)[method] as any)(\n\t\t\t\t\t...args,\n\t\t\t\t);\n\t\t\t\tresponse = { ok: output };\n\t\t\t} catch (rawErr) {\n\t\t\t\tconst err = deconstructError(rawErr, logger(), {}, true);\n\t\t\t\tresponse = { err };\n\t\t\t}\n\n\t\t\treturn c.body(cbor.encode(response));\n\t\t});\n\n\t\trouter.get(\".test/inline-driver/connect-websocket\", async (c) => {\n\t\t\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\t\t\tinvariant(upgradeWebSocket, \"websockets not supported on this platform\");\n\n\t\t\treturn upgradeWebSocket(async (c: any) => {\n\t\t\t\tconst {\n\t\t\t\t\tactorQuery: actorQueryRaw,\n\t\t\t\t\tparams: paramsRaw,\n\t\t\t\t\tencodingKind,\n\t\t\t\t} = c.req.query() as {\n\t\t\t\t\tactorQuery: string;\n\t\t\t\t\tparams?: string;\n\t\t\t\t\tencodingKind: Encoding;\n\t\t\t\t};\n\t\t\t\tconst actorQuery = JSON.parse(actorQueryRaw);\n\t\t\t\tconst params =\n\t\t\t\t\tparamsRaw !== undefined ? JSON.parse(paramsRaw) : undefined;\n\n\t\t\t\tlogger().debug(\"received test inline driver websocket\", {\n\t\t\t\t\tactorQuery,\n\t\t\t\t\tparams,\n\t\t\t\t\tencodingKind,\n\t\t\t\t});\n\n\t\t\t\t// Connect to the actor using the inline client driver - this returns a Promise<WebSocket>\n\t\t\t\tconst clientWsPromise = inlineClientDriver.connectWebSocket(\n\t\t\t\t\tundefined,\n\t\t\t\t\tactorQuery,\n\t\t\t\t\tencodingKind,\n\t\t\t\t\tparams,\n\t\t\t\t\tundefined,\n\t\t\t\t);\n\n\t\t\t\treturn await createTestWebSocketProxy(clientWsPromise, \"standard\");\n\t\t\t})(c, noopNext());\n\t\t});\n\n\t\trouter.get(\".test/inline-driver/raw-websocket\", async (c) => {\n\t\t\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\t\t\tinvariant(upgradeWebSocket, \"websockets not supported on this platform\");\n\n\t\t\treturn upgradeWebSocket(async (c: any) => {\n\t\t\t\tconst {\n\t\t\t\t\tactorQuery: actorQueryRaw,\n\t\t\t\t\tparams: paramsRaw,\n\t\t\t\t\tencodingKind,\n\t\t\t\t\tpath,\n\t\t\t\t\tprotocols: protocolsRaw,\n\t\t\t\t} = c.req.query() as {\n\t\t\t\t\tactorQuery: string;\n\t\t\t\t\tparams?: string;\n\t\t\t\t\tencodingKind: Encoding;\n\t\t\t\t\tpath: string;\n\t\t\t\t\tprotocols?: string;\n\t\t\t\t};\n\t\t\t\tconst actorQuery = JSON.parse(actorQueryRaw);\n\t\t\t\tconst params =\n\t\t\t\t\tparamsRaw !== undefined ? JSON.parse(paramsRaw) : undefined;\n\t\t\t\tconst protocols =\n\t\t\t\t\tprotocolsRaw !== undefined ? JSON.parse(protocolsRaw) : undefined;\n\n\t\t\t\tlogger().debug(\"received test inline driver raw websocket\", {\n\t\t\t\t\tactorQuery,\n\t\t\t\t\tparams,\n\t\t\t\t\tencodingKind,\n\t\t\t\t\tpath,\n\t\t\t\t\tprotocols,\n\t\t\t\t});\n\n\t\t\t\t// Connect to the actor using the inline client driver - this returns a Promise<WebSocket>\n\t\t\t\tlogger().debug(\"calling inlineClientDriver.rawWebSocket\");\n\t\t\t\tconst clientWsPromise = inlineClientDriver.rawWebSocket(\n\t\t\t\t\tundefined,\n\t\t\t\t\tactorQuery,\n\t\t\t\t\tencodingKind,\n\t\t\t\t\tparams,\n\t\t\t\t\tpath,\n\t\t\t\t\tprotocols,\n\t\t\t\t\tundefined,\n\t\t\t\t);\n\n\t\t\t\tlogger().debug(\"calling createTestWebSocketProxy\");\n\t\t\t\treturn await createTestWebSocketProxy(clientWsPromise, \"raw\");\n\t\t\t})(c, noopNext());\n\t\t});\n\n\t\t// Raw HTTP endpoint for test inline driver\n\t\trouter.all(\".test/inline-driver/raw-http/*\", async (c) => {\n\t\t\t// Extract parameters from headers\n\t\t\tconst actorQueryHeader = c.req.header(HEADER_ACTOR_QUERY);\n\t\t\tconst paramsHeader = c.req.header(HEADER_CONN_PARAMS);\n\t\t\tconst encodingHeader = c.req.header(HEADER_ENCODING);\n\n\t\t\tif (!actorQueryHeader || !encodingHeader) {\n\t\t\t\treturn c.text(\"Missing required headers\", 400);\n\t\t\t}\n\n\t\t\tconst actorQuery = JSON.parse(actorQueryHeader);\n\t\t\tconst params = paramsHeader ? JSON.parse(paramsHeader) : undefined;\n\t\t\tconst encoding = encodingHeader as Encoding;\n\n\t\t\t// Extract the path after /raw-http/\n\t\t\tconst fullPath = c.req.path;\n\t\t\tconst pathOnly =\n\t\t\t\tfullPath.split(\"/.test/inline-driver/raw-http/\")[1] || \"\";\n\n\t\t\t// Include query string\n\t\t\tconst url = new URL(c.req.url);\n\t\t\tconst pathWithQuery = pathOnly + url.search;\n\n\t\t\tlogger().debug(\"received test inline driver raw http\", {\n\t\t\t\tactorQuery,\n\t\t\t\tparams,\n\t\t\t\tencoding,\n\t\t\t\tpath: pathWithQuery,\n\t\t\t\tmethod: c.req.method,\n\t\t\t});\n\n\t\t\ttry {\n\t\t\t\t// Forward the request using the inline client driver\n\t\t\t\tconst response = await inlineClientDriver.rawHttpRequest(\n\t\t\t\t\tundefined,\n\t\t\t\t\tactorQuery,\n\t\t\t\t\tencoding,\n\t\t\t\t\tparams,\n\t\t\t\t\tpathWithQuery,\n\t\t\t\t\t{\n\t\t\t\t\t\tmethod: c.req.method,\n\t\t\t\t\t\theaders: c.req.raw.headers,\n\t\t\t\t\t\tbody: c.req.raw.body,\n\t\t\t\t\t},\n\t\t\t\t\tundefined,\n\t\t\t\t);\n\n\t\t\t\t// Return the response directly\n\t\t\t\treturn response;\n\t\t\t} catch (error) {\n\t\t\t\tlogger().error(\"error in test inline raw http\", {\n\t\t\t\t\terror: stringifyError(error),\n\t\t\t\t});\n\n\t\t\t\t// Return error response\n\t\t\t\tconst err = deconstructError(error, logger(), {}, true);\n\t\t\t\treturn c.json(\n\t\t\t\t\t{\n\t\t\t\t\t\terror: {\n\t\t\t\t\t\t\tcode: err.code,\n\t\t\t\t\t\t\tmessage: err.message,\n\t\t\t\t\t\t\tmetadata: err.metadata,\n\t\t\t\t\t\t},\n\t\t\t\t\t},\n\t\t\t\t\terr.statusCode,\n\t\t\t\t);\n\t\t\t}\n\t\t});\n\t}\n\n\tmanagerDriver.modifyManagerRouter?.(\n\t\tregistryConfig,\n\t\trouter as unknown as Hono,\n\t);\n\n\t// Mount on both / and /registry\n\t//\n\t// We do this because the default requests are to `/registry/*`.\n\t//\n\t// If using `app.fetch` directly in a non-hono router, paths\n\t// might not be truncated so they'll come to this router as\n\t// `/registry/*`. If mounted correctly in Hono, requests will\n\t// come in at the root as `/*`.\n\tconst mountedRouter = new Hono();\n\tmountedRouter.route(\"/\", router);\n\tmountedRouter.route(\"/registry\", router);\n\n\t// IMPORTANT: These must be on `mountedRouter` instead of `router` or else they will not be called.\n\tmountedRouter.notFound(handleRouteNotFound);\n\tmountedRouter.onError(handleRouteError.bind(undefined, {}));\n\n\treturn { router: mountedRouter, openapi: router };\n}\n\nexport interface TestInlineDriverCallRequest {\n\tencoding: Encoding;\n\ttransport: Transport;\n\tmethod: string;\n\targs: unknown[];\n}\n\nexport type TestInlineDriverCallResponse<T> =\n\t| {\n\t\t\tok: T;\n\t  }\n\t| {\n\t\t\terr: DeconstructedError;\n\t  };\n\n/**\n * Query the manager driver to get or create a actor based on the provided query\n */\nexport async function queryActor(\n\tc: HonoContext,\n\tquery: ActorQuery,\n\tdriver: ManagerDriver,\n): Promise<{ actorId: string }> {\n\tlogger().debug(\"querying actor\", { query });\n\tlet actorOutput: { actorId: string };\n\tif (\"getForId\" in query) {\n\t\tconst output = await driver.getForId({\n\t\t\tc,\n\t\t\tname: query.getForId.name,\n\t\t\tactorId: query.getForId.actorId,\n\t\t});\n\t\tif (!output) throw new errors.ActorNotFound(query.getForId.actorId);\n\t\tactorOutput = output;\n\t} else if (\"getForKey\" in query) {\n\t\tconst existingActor = await driver.getWithKey({\n\t\t\tc,\n\t\t\tname: query.getForKey.name,\n\t\t\tkey: query.getForKey.key,\n\t\t});\n\t\tif (!existingActor) {\n\t\t\tthrow new errors.ActorNotFound(\n\t\t\t\t`${query.getForKey.name}:${JSON.stringify(query.getForKey.key)}`,\n\t\t\t);\n\t\t}\n\t\tactorOutput = existingActor;\n\t} else if (\"getOrCreateForKey\" in query) {\n\t\tconst getOrCreateOutput = await driver.getOrCreateWithKey({\n\t\t\tc,\n\t\t\tname: query.getOrCreateForKey.name,\n\t\t\tkey: query.getOrCreateForKey.key,\n\t\t\tinput: query.getOrCreateForKey.input,\n\t\t\tregion: query.getOrCreateForKey.region,\n\t\t});\n\t\tactorOutput = {\n\t\t\tactorId: getOrCreateOutput.actorId,\n\t\t};\n\t} else if (\"create\" in query) {\n\t\tconst createOutput = await driver.createActor({\n\t\t\tc,\n\t\t\tname: query.create.name,\n\t\t\tkey: query.create.key,\n\t\t\tinput: query.create.input,\n\t\t\tregion: query.create.region,\n\t\t});\n\t\tactorOutput = {\n\t\t\tactorId: createOutput.actorId,\n\t\t};\n\t} else {\n\t\tthrow new errors.InvalidRequest(\"Invalid query format\");\n\t}\n\n\tlogger().debug(\"actor query result\", {\n\t\tactorId: actorOutput.actorId,\n\t});\n\treturn { actorId: actorOutput.actorId };\n}\n\n/**\n * Creates a WebSocket proxy for test endpoints that forwards messages between server and client WebSockets\n */\nasync function createTestWebSocketProxy(\n\tclientWsPromise: Promise<WebSocket>,\n\tconnectionType: string,\n): Promise<UpgradeWebSocketArgs> {\n\t// Store a reference to the resolved WebSocket\n\tlet clientWs: WebSocket | null = null;\n\ttry {\n\t\t// Resolve the client WebSocket promise\n\t\tlogger().debug(\"awaiting client websocket promise\");\n\t\tconst ws = await clientWsPromise;\n\t\tclientWs = ws;\n\t\tlogger().debug(\"client websocket promise resolved\", {\n\t\t\tconstructor: ws?.constructor.name,\n\t\t});\n\n\t\t// Wait for ws to open\n\t\tawait new Promise<void>((resolve, reject) => {\n\t\t\tconst onOpen = () => {\n\t\t\t\tlogger().debug(\"test websocket connection opened\");\n\t\t\t\tresolve();\n\t\t\t};\n\t\t\tconst onError = (error: any) => {\n\t\t\t\tlogger().error(\"test websocket connection failed\", { error });\n\t\t\t\treject(\n\t\t\t\t\tnew Error(`Failed to open WebSocket: ${error.message || error}`),\n\t\t\t\t);\n\t\t\t};\n\t\t\tws.addEventListener(\"open\", onOpen);\n\t\t\tws.addEventListener(\"error\", onError);\n\t\t});\n\t} catch (error) {\n\t\tlogger().error(\n\t\t\t`failed to establish client ${connectionType} websocket connection`,\n\t\t\t{ error },\n\t\t);\n\t\treturn {\n\t\t\tonOpen: (_evt, serverWs) => {\n\t\t\t\tserverWs.close(1011, \"Failed to establish connection\");\n\t\t\t},\n\t\t\tonMessage: () => {},\n\t\t\tonError: () => {},\n\t\t\tonClose: () => {},\n\t\t};\n\t}\n\n\t// Create WebSocket proxy handlers to relay messages between client and server\n\treturn {\n\t\tonOpen: (_evt: any, serverWs: WSContext) => {\n\t\t\tlogger().debug(`test ${connectionType} websocket connection opened`);\n\n\t\t\t// Check WebSocket type\n\t\t\tlogger().debug(\"clientWs info\", {\n\t\t\t\tconstructor: clientWs.constructor.name,\n\t\t\t\thasAddEventListener: typeof clientWs.addEventListener === \"function\",\n\t\t\t\treadyState: clientWs.readyState,\n\t\t\t});\n\n\t\t\t// Add message handler to forward messages from client to server\n\t\t\tclientWs.addEventListener(\"message\", (clientEvt: MessageEvent) => {\n\t\t\t\tlogger().debug(\n\t\t\t\t\t`test ${connectionType} websocket connection message from client`,\n\t\t\t\t\t{\n\t\t\t\t\t\tdataType: typeof clientEvt.data,\n\t\t\t\t\t\tisBlob: clientEvt.data instanceof Blob,\n\t\t\t\t\t\tisArrayBuffer: clientEvt.data instanceof ArrayBuffer,\n\t\t\t\t\t\tdataConstructor: clientEvt.data?.constructor?.name,\n\t\t\t\t\t\tdataStr:\n\t\t\t\t\t\t\ttypeof clientEvt.data === \"string\"\n\t\t\t\t\t\t\t\t? clientEvt.data.substring(0, 100)\n\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t},\n\t\t\t\t);\n\n\t\t\t\tif (serverWs.readyState === 1) {\n\t\t\t\t\t// OPEN\n\t\t\t\t\t// Handle Blob data\n\t\t\t\t\tif (clientEvt.data instanceof Blob) {\n\t\t\t\t\t\tclientEvt.data\n\t\t\t\t\t\t\t.arrayBuffer()\n\t\t\t\t\t\t\t.then((buffer) => {\n\t\t\t\t\t\t\t\tlogger().debug(\n\t\t\t\t\t\t\t\t\t\"converted client blob to arraybuffer, sending to server\",\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tbufferSize: buffer.byteLength,\n\t\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\tserverWs.send(buffer as any);\n\t\t\t\t\t\t\t})\n\t\t\t\t\t\t\t.catch((error) => {\n\t\t\t\t\t\t\t\tlogger().error(\"failed to convert blob to arraybuffer\", {\n\t\t\t\t\t\t\t\t\terror,\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t});\n\t\t\t\t\t} else {\n\t\t\t\t\t\tlogger().debug(\"sending client data directly to server\", {\n\t\t\t\t\t\t\tdataType: typeof clientEvt.data,\n\t\t\t\t\t\t\tdataLength:\n\t\t\t\t\t\t\t\ttypeof clientEvt.data === \"string\"\n\t\t\t\t\t\t\t\t\t? clientEvt.data.length\n\t\t\t\t\t\t\t\t\t: undefined,\n\t\t\t\t\t\t});\n\t\t\t\t\t\tserverWs.send(clientEvt.data as any);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// Add close handler to close server when client closes\n\t\t\tclientWs.addEventListener(\"close\", (clientEvt: CloseEvent) => {\n\t\t\t\tlogger().debug(`test ${connectionType} websocket connection closed`);\n\n\t\t\t\tif (serverWs.readyState !== 3) {\n\t\t\t\t\t// Not CLOSED\n\t\t\t\t\tserverWs.close(clientEvt.code, clientEvt.reason);\n\t\t\t\t}\n\t\t\t});\n\n\t\t\t// Add error handler\n\t\t\tclientWs.addEventListener(\"error\", () => {\n\t\t\t\tlogger().debug(`test ${connectionType} websocket connection error`);\n\n\t\t\t\tif (serverWs.readyState !== 3) {\n\t\t\t\t\t// Not CLOSED\n\t\t\t\t\tserverWs.close(1011, \"Error in client websocket\");\n\t\t\t\t}\n\t\t\t});\n\t\t},\n\t\tonMessage: (evt: { data: any }) => {\n\t\t\tlogger().debug(\"received message from server\", {\n\t\t\t\tdataType: typeof evt.data,\n\t\t\t\tisBlob: evt.data instanceof Blob,\n\t\t\t\tisArrayBuffer: evt.data instanceof ArrayBuffer,\n\t\t\t\tdataConstructor: evt.data?.constructor?.name,\n\t\t\t\tdataStr:\n\t\t\t\t\ttypeof evt.data === \"string\" ? evt.data.substring(0, 100) : undefined,\n\t\t\t});\n\n\t\t\t// Forward messages from server websocket to client websocket\n\t\t\tif (clientWs.readyState === 1) {\n\t\t\t\t// OPEN\n\t\t\t\t// Handle Blob data\n\t\t\t\tif (evt.data instanceof Blob) {\n\t\t\t\t\tevt.data\n\t\t\t\t\t\t.arrayBuffer()\n\t\t\t\t\t\t.then((buffer) => {\n\t\t\t\t\t\t\tlogger().debug(\"converted blob to arraybuffer, sending\", {\n\t\t\t\t\t\t\t\tbufferSize: buffer.byteLength,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\tclientWs.send(buffer);\n\t\t\t\t\t\t})\n\t\t\t\t\t\t.catch((error) => {\n\t\t\t\t\t\t\tlogger().error(\"failed to convert blob to arraybuffer\", {\n\t\t\t\t\t\t\t\terror,\n\t\t\t\t\t\t\t});\n\t\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\tlogger().debug(\"sending data directly\", {\n\t\t\t\t\t\tdataType: typeof evt.data,\n\t\t\t\t\t\tdataLength:\n\t\t\t\t\t\t\ttypeof evt.data === \"string\" ? evt.data.length : undefined,\n\t\t\t\t\t});\n\t\t\t\t\tclientWs.send(evt.data);\n\t\t\t\t}\n\t\t\t}\n\t\t},\n\t\tonClose: (\n\t\t\tevent: {\n\t\t\t\twasClean: boolean;\n\t\t\t\tcode: number;\n\t\t\t\treason: string;\n\t\t\t},\n\t\t\tserverWs: WSContext,\n\t\t) => {\n\t\t\tlogger().debug(`server ${connectionType} websocket closed`, {\n\t\t\t\twasClean: event.wasClean,\n\t\t\t\tcode: event.code,\n\t\t\t\treason: event.reason,\n\t\t\t});\n\n\t\t\t// HACK: Close socket in order to fix bug with Cloudflare leaving WS in closing state\n\t\t\t// https://github.com/cloudflare/workerd/issues/2569\n\t\t\tserverWs.close(1000, \"hack_force_close\");\n\n\t\t\t// Close the client websocket when the server websocket closes\n\t\t\tif (\n\t\t\t\tclientWs &&\n\t\t\t\tclientWs.readyState !== clientWs.CLOSED &&\n\t\t\t\tclientWs.readyState !== clientWs.CLOSING\n\t\t\t) {\n\t\t\t\t// Don't pass code/message since this may affect how close events are triggered\n\t\t\t\tclientWs.close(1000, event.reason);\n\t\t\t}\n\t\t},\n\t\tonError: (error: unknown) => {\n\t\t\tlogger().error(`error in server ${connectionType} websocket`, { error });\n\n\t\t\t// Close the client websocket on error\n\t\t\tif (\n\t\t\t\tclientWs &&\n\t\t\t\tclientWs.readyState !== clientWs.CLOSED &&\n\t\t\t\tclientWs.readyState !== clientWs.CLOSING\n\t\t\t) {\n\t\t\t\tclientWs.close(1011, \"Error in server websocket\");\n\t\t\t}\n\t\t},\n\t};\n}\n\n/**\n * Handle SSE connection request\n */\nasync function handleSseConnectRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\t_runConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\tlet encoding: Encoding | undefined;\n\ttry {\n\t\tencoding = getRequestEncoding(c.req);\n\t\tlogger().debug(\"sse connection request received\", { encoding });\n\n\t\tconst params = ConnectRequestSchema.safeParse({\n\t\t\tquery: getRequestQuery(c),\n\t\t\tencoding: c.req.header(HEADER_ENCODING),\n\t\t\tconnParams: c.req.header(HEADER_CONN_PARAMS),\n\t\t});\n\n\t\tif (!params.success) {\n\t\t\tlogger().error(\"invalid connection parameters\", {\n\t\t\t\terror: params.error,\n\t\t\t});\n\t\t\tthrow new errors.InvalidRequest(params.error);\n\t\t}\n\n\t\tconst query = params.data.query;\n\n\t\t// Parse connection parameters for authentication\n\t\tconst connParams = params.data.connParams\n\t\t\t? JSON.parse(params.data.connParams)\n\t\t\t: undefined;\n\n\t\t// Authenticate the request\n\t\tconst authData = await authenticateEndpoint(\n\t\t\tc,\n\t\t\tdriver,\n\t\t\tregistryConfig,\n\t\t\tquery,\n\t\t\t[\"connect\"],\n\t\t\tconnParams,\n\t\t);\n\n\t\t// Get the actor ID\n\t\tconst { actorId } = await queryActor(c, query, driver);\n\t\tinvariant(actorId, \"Missing actor ID\");\n\t\tlogger().debug(\"sse connection to actor\", { actorId });\n\n\t\t// Handle based on mode\n\t\tlogger().debug(\"using custom proxy mode for sse connection\");\n\t\tconst url = new URL(\"http://actor/connect/sse\");\n\n\t\t// Always build fresh request to prevent forwarding unwanted headers\n\t\tconst proxyRequestHeaderes = new Headers();\n\t\tproxyRequestHeaderes.set(HEADER_ENCODING, params.data.encoding);\n\t\tif (params.data.connParams) {\n\t\t\tproxyRequestHeaderes.set(HEADER_CONN_PARAMS, params.data.connParams);\n\t\t}\n\t\tif (authData) {\n\t\t\tproxyRequestHeaderes.set(HEADER_AUTH_DATA, JSON.stringify(authData));\n\t\t}\n\n\t\tconst proxyRequest = new Request(url, { headers: proxyRequestHeaderes });\n\n\t\treturn await driver.proxyRequest(c, proxyRequest, actorId);\n\t} catch (error) {\n\t\t// If we receive an error during setup, we send the error and close the socket immediately\n\t\t//\n\t\t// We have to return the error over SSE since SSE clients cannot read vanilla HTTP responses\n\n\t\tconst { code, message, metadata } = deconstructError(error, logger(), {\n\t\t\tsseEvent: \"setup\",\n\t\t});\n\n\t\treturn streamSSE(c, async (stream) => {\n\t\t\ttry {\n\t\t\t\tif (encoding) {\n\t\t\t\t\t// Serialize and send the connection error\n\t\t\t\t\tconst errorMsg: protocol.ToClient = {\n\t\t\t\t\t\tbody: {\n\t\t\t\t\t\t\ttag: \"Error\",\n\t\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\t\tcode,\n\t\t\t\t\t\t\t\tmessage,\n\t\t\t\t\t\t\t\tmetadata: bufferToArrayBuffer(cbor.encode(metadata)),\n\t\t\t\t\t\t\t\tactionId: null,\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t},\n\t\t\t\t\t};\n\n\t\t\t\t\t// Send the error message to the client\n\t\t\t\t\tconst serialized = serializeWithEncoding(\n\t\t\t\t\t\tencoding,\n\t\t\t\t\t\terrorMsg,\n\t\t\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t\t\t);\n\t\t\t\t\tawait stream.writeSSE({\n\t\t\t\t\t\tdata:\n\t\t\t\t\t\t\ttypeof serialized === \"string\"\n\t\t\t\t\t\t\t\t? serialized\n\t\t\t\t\t\t\t\t: Buffer.from(serialized).toString(\"base64\"),\n\t\t\t\t\t});\n\t\t\t\t} else {\n\t\t\t\t\t// We don't know the encoding, send an error and close\n\t\t\t\t\tawait stream.writeSSE({\n\t\t\t\t\t\tdata: code,\n\t\t\t\t\t\tevent: \"error\",\n\t\t\t\t\t});\n\t\t\t\t}\n\t\t\t} catch (serializeError) {\n\t\t\t\tlogger().error(\"failed to send error to sse client\", {\n\t\t\t\t\terror: serializeError,\n\t\t\t\t});\n\t\t\t\tawait stream.writeSSE({\n\t\t\t\t\tdata: \"internal error during error handling\",\n\t\t\t\t\tevent: \"error\",\n\t\t\t\t});\n\t\t\t}\n\n\t\t\t// Stream will exit completely once function exits\n\t\t});\n\t}\n}\n\n/**\n * Handle WebSocket connection request\n */\nasync function handleWebSocketConnectRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\trunConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\tif (!upgradeWebSocket) {\n\t\treturn c.text(\n\t\t\t\"WebSockets are not enabled for this driver. Use SSE instead.\",\n\t\t\t400,\n\t\t);\n\t}\n\n\tlet encoding: Encoding | undefined;\n\ttry {\n\t\tlogger().debug(\"websocket connection request received\");\n\n\t\t// Parse configuration from Sec-WebSocket-Protocol header\n\t\t//\n\t\t// We use this instead of query parameters since this is more secure than\n\t\t// query parameters. Query parameters often get logged.\n\t\t//\n\t\t// Browsers don't support using headers, so this is the only way to\n\t\t// pass data securely.\n\t\tconst protocols = c.req.header(\"sec-websocket-protocol\");\n\t\tconst { queryRaw, encodingRaw, connParamsRaw } =\n\t\t\tparseWebSocketProtocols(protocols);\n\n\t\t// Parse query\n\t\tlet queryUnvalidated: unknown;\n\t\ttry {\n\t\t\tqueryUnvalidated = JSON.parse(queryRaw!);\n\t\t} catch (error) {\n\t\t\tlogger().error(\"invalid query json\", { error });\n\t\t\tthrow new errors.InvalidQueryJSON(error);\n\t\t}\n\n\t\t// Parse conn params\n\t\tlet connParamsUnvalidated: unknown = null;\n\t\ttry {\n\t\t\tif (connParamsRaw) {\n\t\t\t\tconnParamsUnvalidated = JSON.parse(connParamsRaw!);\n\t\t\t}\n\t\t} catch (error) {\n\t\t\tlogger().error(\"invalid conn params\", { error });\n\t\t\tthrow new errors.InvalidParams(\n\t\t\t\t`Invalid params JSON: ${stringifyError(error)}`,\n\t\t\t);\n\t\t}\n\n\t\t// We can't use the standard headers with WebSockets\n\t\t//\n\t\t// All other information will be sent over the socket itself, since that data needs to be E2EE\n\t\tconst params = ConnectWebSocketRequestSchema.safeParse({\n\t\t\tquery: queryUnvalidated,\n\t\t\tencoding: encodingRaw,\n\t\t\tconnParams: connParamsUnvalidated,\n\t\t});\n\t\tif (!params.success) {\n\t\t\tlogger().error(\"invalid connection parameters\", {\n\t\t\t\terror: params.error,\n\t\t\t});\n\t\t\tthrow new errors.InvalidRequest(params.error);\n\t\t}\n\t\tencoding = params.data.encoding;\n\n\t\t// Authenticate endpoint\n\t\tconst authData = await authenticateEndpoint(\n\t\t\tc,\n\t\t\tdriver,\n\t\t\tregistryConfig,\n\t\t\tparams.data.query,\n\t\t\t[\"connect\"],\n\t\t\tconnParamsRaw,\n\t\t);\n\n\t\t// Get the actor ID\n\t\tconst { actorId } = await queryActor(c, params.data.query, driver);\n\t\tlogger().debug(\"found actor for websocket connection\", {\n\t\t\tactorId,\n\t\t});\n\t\tinvariant(actorId, \"missing actor id\");\n\n\t\t// Proxy the WebSocket connection to the actor\n\t\t//\n\t\t// The proxyWebSocket handler will:\n\t\t// 1. Validate the WebSocket upgrade request\n\t\t// 2. Forward the request to the actor with the appropriate path\n\t\t// 3. Handle the WebSocket pair and proxy messages between client and actor\n\t\treturn await driver.proxyWebSocket(\n\t\t\tc,\n\t\t\tPATH_CONNECT_WEBSOCKET,\n\t\t\tactorId,\n\t\t\tparams.data.encoding,\n\t\t\tparams.data.connParams,\n\t\t\tauthData,\n\t\t);\n\t} catch (error) {\n\t\t// If we receive an error during setup, we send the error and close the socket immediately\n\t\t//\n\t\t// We have to return the error over WS since WebSocket clients cannot read vanilla HTTP responses\n\n\t\tconst { code, message, metadata } = deconstructError(error, logger(), {\n\t\t\twsEvent: \"setup\",\n\t\t});\n\n\t\treturn await upgradeWebSocket(() => ({\n\t\t\tonOpen: (_evt: unknown, ws: WSContext) => {\n\t\t\t\tif (encoding) {\n\t\t\t\t\ttry {\n\t\t\t\t\t\t// Serialize and send the connection error\n\t\t\t\t\t\tconst errorMsg: protocol.ToClient = {\n\t\t\t\t\t\t\tbody: {\n\t\t\t\t\t\t\t\ttag: \"Error\",\n\t\t\t\t\t\t\t\tval: {\n\t\t\t\t\t\t\t\t\tcode,\n\t\t\t\t\t\t\t\t\tmessage,\n\t\t\t\t\t\t\t\t\tmetadata: bufferToArrayBuffer(cbor.encode(metadata)),\n\t\t\t\t\t\t\t\t\tactionId: null,\n\t\t\t\t\t\t\t\t},\n\t\t\t\t\t\t\t},\n\t\t\t\t\t\t};\n\n\t\t\t\t\t\t// Send the error message to the client\n\t\t\t\t\t\tconst serialized = serializeWithEncoding(\n\t\t\t\t\t\t\tencoding,\n\t\t\t\t\t\t\terrorMsg,\n\t\t\t\t\t\t\tTO_CLIENT_VERSIONED,\n\t\t\t\t\t\t);\n\t\t\t\t\t\tws.send(serialized);\n\n\t\t\t\t\t\t// Close the connection with an error code\n\t\t\t\t\t\tws.close(1011, code);\n\t\t\t\t\t} catch (serializeError) {\n\t\t\t\t\t\tlogger().error(\"failed to send error to websocket client\", {\n\t\t\t\t\t\t\terror: serializeError,\n\t\t\t\t\t\t});\n\t\t\t\t\t\tws.close(1011, \"internal error during error handling\");\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// We don't know the encoding so we send what we can\n\t\t\t\t\tws.close(1011, code);\n\t\t\t\t}\n\t\t\t},\n\t\t}))(c, noopNext());\n\t}\n}\n\n/**\n * Handle a connection message request to a actor\n *\n * There is no authentication handler on this request since the connection\n * token is used to authenticate the message.\n */\nasync function handleMessageRequest(\n\tc: HonoContext,\n\t_registryConfig: RegistryConfig,\n\t_runConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\tlogger().debug(\"connection message request received\");\n\ttry {\n\t\tconst params = ConnMessageRequestSchema.safeParse({\n\t\t\tactorId: c.req.header(HEADER_ACTOR_ID),\n\t\t\tconnId: c.req.header(HEADER_CONN_ID),\n\t\t\tencoding: c.req.header(HEADER_ENCODING),\n\t\t\tconnToken: c.req.header(HEADER_CONN_TOKEN),\n\t\t});\n\t\tif (!params.success) {\n\t\t\tlogger().error(\"invalid connection parameters\", {\n\t\t\t\terror: params.error,\n\t\t\t});\n\t\t\tthrow new errors.InvalidRequest(params.error);\n\t\t}\n\t\tconst { actorId, connId, encoding, connToken } = params.data;\n\n\t\t// TODO: This endpoint can be used to exhause resources (DoS attack) on an actor if you know the actor ID:\n\t\t// 1. Get the actor ID (usually this is reasonably secure, but we don't assume actor ID is sensitive)\n\t\t// 2. Spam messages to the actor (the conn token can be invalid)\n\t\t// 3. The actor will be exhausted processing messages \u2014 even if the token is invalid\n\t\t//\n\t\t// The solution is we need to move the authorization of the connection token to this request handler\n\t\t// AND include the actor ID in the connection token so we can verify that it has permission to send\n\t\t// a message to that actor. This would require changing the token to a JWT so we can include a secure\n\t\t// payload, but this requires managing a private key & managing key rotations.\n\t\t//\n\t\t// All other solutions (e.g. include the actor name as a header or include the actor name in the actor ID)\n\t\t// have exploits that allow the caller to send messages to arbitrary actors.\n\t\t//\n\t\t// Currently, we assume this is not a critical problem because requests will likely get rate\n\t\t// limited before enough messages are passed to the actor to exhaust resources.\n\n\t\tconst url = new URL(\"http://actor/connections/message\");\n\n\t\t// Always build fresh request to prevent forwarding unwanted headers\n\t\tconst proxyRequestHeaders = new Headers();\n\t\tproxyRequestHeaders.set(HEADER_ENCODING, encoding);\n\t\tproxyRequestHeaders.set(HEADER_CONN_ID, connId);\n\t\tproxyRequestHeaders.set(HEADER_CONN_TOKEN, connToken);\n\n\t\tconst proxyRequest = new Request(url, {\n\t\t\tmethod: \"POST\",\n\t\t\tbody: c.req.raw.body,\n\t\t\tduplex: \"half\",\n\t\t\theaders: proxyRequestHeaders,\n\t\t});\n\n\t\treturn await driver.proxyRequest(c, proxyRequest, actorId);\n\t} catch (error) {\n\t\tlogger().error(\"error proxying connection message\", { error });\n\n\t\t// Use ProxyError if it's not already an ActorError\n\t\tif (!errors.ActorError.isActorError(error)) {\n\t\t\tthrow new errors.ProxyError(\"connection message\", error);\n\t\t} else {\n\t\t\tthrow error;\n\t\t}\n\t}\n}\n\n/**\n * Handle an action request to a actor\n */\nasync function handleActionRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\t_runConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\ttry {\n\t\tconst actionName = c.req.param(\"action\");\n\t\tlogger().debug(\"action call received\", { actionName });\n\n\t\tconst params = ConnectRequestSchema.safeParse({\n\t\t\tquery: getRequestQuery(c),\n\t\t\tencoding: c.req.header(HEADER_ENCODING),\n\t\t\tconnParams: c.req.header(HEADER_CONN_PARAMS),\n\t\t});\n\n\t\tif (!params.success) {\n\t\t\tlogger().error(\"invalid connection parameters\", {\n\t\t\t\terror: params.error,\n\t\t\t});\n\t\t\tthrow new errors.InvalidRequest(params.error);\n\t\t}\n\n\t\t// Parse connection parameters for authentication\n\t\tconst connParams = params.data.connParams\n\t\t\t? JSON.parse(params.data.connParams)\n\t\t\t: undefined;\n\n\t\t// Authenticate the request\n\t\tconst authData = await authenticateEndpoint(\n\t\t\tc,\n\t\t\tdriver,\n\t\t\tregistryConfig,\n\t\t\tparams.data.query,\n\t\t\t[\"action\"],\n\t\t\tconnParams,\n\t\t);\n\n\t\t// Get the actor ID\n\t\tconst { actorId } = await queryActor(c, params.data.query, driver);\n\t\tlogger().debug(\"found actor for action\", { actorId });\n\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\tconst url = new URL(\n\t\t\t`http://actor/action/${encodeURIComponent(actionName)}`,\n\t\t);\n\n\t\t// Always build fresh request to prevent forwarding unwanted headers\n\t\tconst proxyRequestHeaders = new Headers();\n\t\tproxyRequestHeaders.set(HEADER_ENCODING, params.data.encoding);\n\t\tif (params.data.connParams) {\n\t\t\tproxyRequestHeaders.set(HEADER_CONN_PARAMS, params.data.connParams);\n\t\t}\n\t\tif (authData) {\n\t\t\tproxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));\n\t\t}\n\n\t\tconst proxyRequest = new Request(url, {\n\t\t\tmethod: \"POST\",\n\t\t\tbody: c.req.raw.body,\n\t\t\theaders: proxyRequestHeaders,\n\t\t});\n\n\t\treturn await driver.proxyRequest(c, proxyRequest, actorId);\n\t} catch (error) {\n\t\tlogger().error(\"error in action handler\", { error: stringifyError(error) });\n\n\t\t// Use ProxyError if it's not already an ActorError\n\t\tif (!errors.ActorError.isActorError(error)) {\n\t\t\tthrow new errors.ProxyError(\"Action call\", error);\n\t\t} else {\n\t\t\tthrow error;\n\t\t}\n\t}\n}\n\n/**\n * Handle the resolve request to get a actor ID from a query\n */\nasync function handleResolveRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\tconst encoding = getRequestEncoding(c.req);\n\tlogger().debug(\"resolve request encoding\", { encoding });\n\n\tconst params = ResolveRequestSchema.safeParse({\n\t\tquery: getRequestQuery(c),\n\t\tconnParams: c.req.header(HEADER_CONN_PARAMS),\n\t});\n\tif (!params.success) {\n\t\tlogger().error(\"invalid connection parameters\", {\n\t\t\terror: params.error,\n\t\t});\n\t\tthrow new errors.InvalidRequest(params.error);\n\t}\n\n\t// Parse connection parameters for authentication\n\tconst connParams = params.data.connParams\n\t\t? JSON.parse(params.data.connParams)\n\t\t: undefined;\n\n\tconst query = params.data.query;\n\n\t// Authenticate the request\n\tawait authenticateEndpoint(c, driver, registryConfig, query, [], connParams);\n\n\t// Get the actor ID\n\tconst { actorId } = await queryActor(c, query, driver);\n\tlogger().debug(\"resolved actor\", { actorId });\n\tinvariant(actorId, \"Missing actor ID\");\n\n\t// Format response according to protocol\n\tconst response: protocol.HttpResolveResponse = {\n\t\tactorId,\n\t};\n\tconst serialized = serializeWithEncoding(\n\t\tencoding,\n\t\tresponse,\n\t\tHTTP_RESOLVE_RESPONSE_VERSIONED,\n\t);\n\treturn c.body(serialized);\n}\n\n/**\n * Handle raw HTTP requests to an actor\n */\nasync function handleRawHttpRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\t_runConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\ttry {\n\t\tconst subpath = c.req.path.split(\"/raw/http/\")[1] || \"\";\n\t\tlogger().debug(\"raw http request received\", { subpath });\n\n\t\t// Get actor query from header (consistent with other endpoints)\n\t\tconst queryHeader = c.req.header(HEADER_ACTOR_QUERY);\n\t\tif (!queryHeader) {\n\t\t\tthrow new errors.InvalidRequest(\"Missing actor query header\");\n\t\t}\n\t\tconst query: ActorQuery = JSON.parse(queryHeader);\n\n\t\t// Parse connection parameters for authentication\n\t\tconst connParamsHeader = c.req.header(HEADER_CONN_PARAMS);\n\t\tconst connParams = connParamsHeader\n\t\t\t? JSON.parse(connParamsHeader)\n\t\t\t: undefined;\n\n\t\t// Authenticate the request\n\t\tconst authData = await authenticateEndpoint(\n\t\t\tc,\n\t\t\tdriver,\n\t\t\tregistryConfig,\n\t\t\tquery,\n\t\t\t[\"action\"],\n\t\t\tconnParams,\n\t\t);\n\n\t\t// Get the actor ID\n\t\tconst { actorId } = await queryActor(c, query, driver);\n\t\tlogger().debug(\"found actor for raw http\", { actorId });\n\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\t// Preserve the original URL's query parameters\n\t\tconst originalUrl = new URL(c.req.url);\n\t\tconst url = new URL(\n\t\t\t`http://actor/raw/http/${subpath}${originalUrl.search}`,\n\t\t);\n\n\t\t// Forward the request to the actor\n\n\t\tlogger().debug(\"rewriting http url\", {\n\t\t\tfrom: c.req.url,\n\t\t\tto: url,\n\t\t});\n\n\t\tconst proxyRequestHeaders = new Headers(c.req.raw.headers);\n\t\tif (connParams) {\n\t\t\tproxyRequestHeaders.set(HEADER_CONN_PARAMS, JSON.stringify(connParams));\n\t\t}\n\t\tif (authData) {\n\t\t\tproxyRequestHeaders.set(HEADER_AUTH_DATA, JSON.stringify(authData));\n\t\t}\n\n\t\tconst proxyRequest = new Request(url, {\n\t\t\tmethod: c.req.method,\n\t\t\theaders: proxyRequestHeaders,\n\t\t\tbody: c.req.raw.body,\n\t\t});\n\n\t\treturn await driver.proxyRequest(c, proxyRequest, actorId);\n\t} catch (error) {\n\t\tlogger().error(\"error in raw http handler\", {\n\t\t\terror: stringifyError(error),\n\t\t});\n\n\t\t// Use ProxyError if it's not already an ActorError\n\t\tif (!errors.ActorError.isActorError(error)) {\n\t\t\tthrow new errors.ProxyError(\"Raw HTTP request\", error);\n\t\t} else {\n\t\t\tthrow error;\n\t\t}\n\t}\n}\n\n/**\n * Handle raw WebSocket requests to an actor\n */\nasync function handleRawWebSocketRequest(\n\tc: HonoContext,\n\tregistryConfig: RegistryConfig,\n\trunConfig: RunConfig,\n\tdriver: ManagerDriver,\n): Promise<Response> {\n\tconst upgradeWebSocket = runConfig.getUpgradeWebSocket?.();\n\tif (!upgradeWebSocket) {\n\t\treturn c.text(\"WebSockets are not enabled for this driver.\", 400);\n\t}\n\n\ttry {\n\t\tconst subpath = c.req.path.split(\"/raw/websocket/\")[1] || \"\";\n\t\tlogger().debug(\"raw websocket request received\", { subpath });\n\n\t\t// Parse protocols from Sec-WebSocket-Protocol header\n\t\tconst protocols = c.req.header(\"sec-websocket-protocol\");\n\t\tconst {\n\t\t\tqueryRaw: queryFromProtocol,\n\t\t\tconnParamsRaw: connParamsFromProtocol,\n\t\t} = parseWebSocketProtocols(protocols);\n\n\t\tif (!queryFromProtocol) {\n\t\t\tthrow new errors.InvalidRequest(\"Missing query in WebSocket protocol\");\n\t\t}\n\t\tconst query = JSON.parse(queryFromProtocol);\n\n\t\t// Parse connection parameters from protocol\n\t\tlet connParams: unknown;\n\t\tif (connParamsFromProtocol) {\n\t\t\tconnParams = JSON.parse(connParamsFromProtocol);\n\t\t}\n\n\t\t// Authenticate the request\n\t\tconst authData = await authenticateEndpoint(\n\t\t\tc,\n\t\t\tdriver,\n\t\t\tregistryConfig,\n\t\t\tquery,\n\t\t\t[\"action\"],\n\t\t\tconnParams,\n\t\t);\n\n\t\t// Get the actor ID\n\t\tconst { actorId } = await queryActor(c, query, driver);\n\t\tlogger().debug(\"found actor for raw websocket\", { actorId });\n\t\tinvariant(actorId, \"Missing actor ID\");\n\n\t\tlogger().debug(\"using custom proxy mode for raw websocket\");\n\n\t\t// Preserve the original URL's query parameters\n\t\tconst originalUrl = new URL(c.req.url);\n\t\tconst proxyPath = `${PATH_RAW_WEBSOCKET_PREFIX}${subpath}${originalUrl.search}`;\n\n\t\tlogger().debug(\"manager router proxyWebSocket\", {\n\t\t\toriginalUrl: c.req.url,\n\t\t\tsubpath,\n\t\t\tsearch: originalUrl.search,\n\t\t\tproxyPath,\n\t\t});\n\n\t\t// For raw WebSocket, we need to use proxyWebSocket instead of proxyRequest\n\t\treturn await driver.proxyWebSocket(\n\t\t\tc,\n\t\t\tproxyPath,\n\t\t\tactorId,\n\t\t\t\"json\", // Default encoding for raw WebSocket\n\t\t\tconnParams,\n\t\t\tauthData,\n\t\t);\n\t} catch (error) {\n\t\t// If we receive an error during setup, we send the error and close the socket immediately\n\t\t//\n\t\t// We have to return the error over WS since WebSocket clients cannot read vanilla HTTP responses\n\n\t\tconst { code } = deconstructError(error, logger(), {\n\t\t\twsEvent: \"setup\",\n\t\t});\n\n\t\treturn await upgradeWebSocket(() => ({\n\t\t\tonOpen: (_evt: unknown, ws: WSContext) => {\n\t\t\t\t// Close with message so we can see the error on the client\n\t\t\t\tws.close(1011, code);\n\t\t\t},\n\t\t}))(c, noopNext());\n\t}\n}\n\nfunction universalActorProxy({\n\tregistryConfig,\n\trunConfig,\n\tdriver,\n}: {\n\tregistryConfig: RegistryConfig;\n\trunConfig: RunConfig;\n\tdriver: ManagerDriver;\n}): MiddlewareHandler {\n\treturn async (c, _next) => {\n\t\tif (c.req.header(\"upgrade\") === \"websocket\") {\n\t\t\treturn handleRawWebSocketRequest(c, registryConfig, runConfig, driver);\n\t\t} else {\n\t\t\tconst queryHeader = c.req.header(HEADER_ACTOR_QUERY);\n\t\t\tif (!queryHeader) {\n\t\t\t\tthrow new errors.InvalidRequest(\"Missing actor query header\");\n\t\t\t}\n\t\t\tconst query = ActorQuerySchema.parse(JSON.parse(queryHeader));\n\n\t\t\tconst { actorId } = await queryActor(c, query, driver);\n\n\t\t\tconst url = new URL(c.req.url);\n\t\t\turl.hostname = \"actor\";\n\t\t\turl.pathname = url.pathname\n\t\t\t\t.replace(new RegExp(`^${runConfig.basePath}`, \"\"), \"\")\n\t\t\t\t.replace(/^\\/?registry\\/actors/, \"\")\n\t\t\t\t.replace(/^\\/?actors/, \"\"); // Remove /registry prefix if present\n\n\t\t\tconst proxyRequest = new Request(url, {\n\t\t\t\tmethod: c.req.method,\n\t\t\t\theaders: c.req.raw.headers,\n\t\t\t\tbody: c.req.raw.body,\n\t\t\t});\n\t\t\treturn await driver.proxyRequest(c, proxyRequest, actorId);\n\t\t}\n\t};\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager/auth.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/manager\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/manager/auth.ts\";import type { Context as HonoContext } from \"hono\";\nimport type { AuthIntent } from \"@/actor/config\";\nimport type { AnyActorDefinition } from \"@/actor/definition\";\nimport * as errors from \"@/actor/errors\";\nimport type { RegistryConfig } from \"@/registry/config\";\nimport { stringifyError } from \"@/utils\";\nimport type { ManagerDriver } from \"./driver\";\nimport { logger } from \"./log\";\nimport type { ActorQuery } from \"./protocol/query\";\n\n/**\n * Get authentication intents from a actor query\n */\nexport function getIntentsFromQuery(query: ActorQuery): Set<AuthIntent> {\n\tconst intents = new Set<AuthIntent>();\n\n\tif (\"getForId\" in query) {\n\t\tintents.add(\"get\");\n\t} else if (\"getForKey\" in query) {\n\t\tintents.add(\"get\");\n\t} else if (\"getOrCreateForKey\" in query) {\n\t\tintents.add(\"get\");\n\t\tintents.add(\"create\");\n\t} else if (\"create\" in query) {\n\t\tintents.add(\"create\");\n\t}\n\n\treturn intents;\n}\n\n/**\n * Get actor name from a actor query\n */\nexport async function getActorNameFromQuery(\n\tc: HonoContext,\n\tdriver: ManagerDriver,\n\tquery: ActorQuery,\n): Promise<string> {\n\tif (\"getForId\" in query) {\n\t\t// TODO: This will have a duplicate call to getForId between this and queryActor\n\t\tconst output = await driver.getForId({\n\t\t\tc,\n\t\t\tname: query.getForId.name,\n\t\t\tactorId: query.getForId.actorId,\n\t\t});\n\t\tif (!output) throw new errors.ActorNotFound(query.getForId.actorId);\n\t\treturn output.name;\n\t} else if (\"getForKey\" in query) {\n\t\treturn query.getForKey.name;\n\t} else if (\"getOrCreateForKey\" in query) {\n\t\treturn query.getOrCreateForKey.name;\n\t} else if (\"create\" in query) {\n\t\treturn query.create.name;\n\t} else {\n\t\tthrow new errors.InvalidRequest(\"Invalid query format\");\n\t}\n}\n\n/**\n * Authenticate a request using the actor's onAuth function\n */\nexport async function authenticateRequest(\n\tc: HonoContext,\n\tactorDefinition: AnyActorDefinition,\n\tintents: Set<AuthIntent>,\n\tparams: unknown,\n): Promise<unknown> {\n\tif (!(\"onAuth\" in actorDefinition.config)) {\n\t\tthrow new errors.Forbidden(\n\t\t\t\"Actor requires authentication but no onAuth handler is defined (https://rivet.gg/docs/actors/authentication/). Provide an empty handler to disable auth: `onAuth: () => {}`\",\n\t\t);\n\t}\n\n\ttry {\n\t\tconst dataOrPromise = actorDefinition.config.onAuth(\n\t\t\t{\n\t\t\t\trequest: c.req.raw,\n\t\t\t\tintents,\n\t\t\t},\n\t\t\tparams,\n\t\t);\n\t\tif (dataOrPromise instanceof Promise) {\n\t\t\treturn await dataOrPromise;\n\t\t} else {\n\t\t\treturn dataOrPromise;\n\t\t}\n\t} catch (error) {\n\t\tlogger().info(\"authentication error\", { error: stringifyError(error) });\n\t\tthrow error;\n\t}\n}\n\n/**\n * Simplified authentication for endpoints that combines all auth steps\n */\nexport async function authenticateEndpoint(\n\tc: HonoContext,\n\tdriver: ManagerDriver,\n\tregistryConfig: RegistryConfig,\n\tquery: ActorQuery,\n\tadditionalIntents: AuthIntent[],\n\tparams: unknown,\n): Promise<unknown> {\n\t// Get base intents from query\n\tconst intents = getIntentsFromQuery(query);\n\n\t// Add endpoint-specific intents\n\tfor (const intent of additionalIntents) {\n\t\tintents.add(intent);\n\t}\n\n\t// Get actor definition\n\tconst actorName = await getActorNameFromQuery(c, driver, query);\n\tconst actorDefinition = registryConfig.use[actorName];\n\tif (!actorDefinition) {\n\t\tthrow new errors.ActorNotFound(actorName);\n\t}\n\n\t// Authenticate\n\treturn await authenticateRequest(c, actorDefinition, intents, params);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry/config.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/registry/config.ts\";//! These configs configs hold anything that's not platform-specific about running actors.\n\nimport { z } from \"zod\";\nimport type { ActorDefinition, AnyActorDefinition } from \"@/actor/definition\";\n\nexport const ActorsSchema = z.record(\n\tz.string(),\n\tz.custom<ActorDefinition<any, any, any, any, any, any, any, any>>(),\n);\nexport type RegistryActors = z.infer<typeof ActorsSchema>;\n\nexport const TestConfigSchema = z.object({ enabled: z.boolean() });\nexport type TestConfig = z.infer<typeof TestConfigSchema>;\n\n/** Base config used for the actor config across all platforms. */\nexport const RegistryConfigSchema = z.object({\n\tuse: z.record(z.string(), z.custom<AnyActorDefinition>()),\n\n\t// TODO: Find a better way of passing around the test config\n\t/**\n\t * Test configuration.\n\t *\n\t * DO NOT MANUALLY ENABLE. THIS IS USED INTERNALLY.\n\t * @internal\n\t **/\n\ttest: TestConfigSchema.optional().default({ enabled: false }),\n});\nexport type RegistryConfig = z.infer<typeof RegistryConfigSchema>;\nexport type RegistryConfigInput<A extends RegistryActors> = Omit<\n\tz.input<typeof RegistryConfigSchema>,\n\t\"use\"\n> & { use: A };\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry/log.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/registry/log.ts\";import { getLogger } from \"@/common//log\";\n\nexport const LOGGER_NAME = \"registry\";\n\nexport function logger() {\n\treturn getLogger(LOGGER_NAME);\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry/serve.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/registry/serve.ts\";import { Hono } from \"hono\";\nimport { getEnvUniversal } from \"@/utils\";\nimport { logger } from \"./log\";\n\nexport async function crossPlatformServe(\n\trivetKitRouter: Hono<any>,\n\tuserRouter: Hono | undefined,\n) {\n\tconst app = userRouter ?? new Hono();\n\n\t// Import @hono/node-server\n\tlet serve: any;\n\ttry {\n\t\tconst dep = await import(\"@hono/node-server\");\n\t\tserve = dep.serve;\n\t} catch (err) {\n\t\tlogger().error(\n\t\t\t\"failed to import @hono/node-server. please run 'npm install @hono/node-server @hono/node-ws'\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\t// Mount registry\n\tapp.route(\"/registry\", rivetKitRouter);\n\n\t// Import @hono/node-ws\n\tlet createNodeWebSocket: any;\n\ttry {\n\t\tconst dep = await import(\"@hono/node-ws\");\n\t\tcreateNodeWebSocket = dep.createNodeWebSocket;\n\t} catch (err) {\n\t\tlogger().error(\n\t\t\t\"failed to import @hono/node-ws. please run 'npm install @hono/node-server @hono/node-ws'\",\n\t\t);\n\t\tprocess.exit(1);\n\t}\n\n\t// Inject WS\n\tconst { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({\n\t\tapp,\n\t});\n\n\t// Start server\n\tconst port = Number.parseInt(\n\t\tgetEnvUniversal(\"PORT\") ?? getEnvUniversal(\"PORT_HTTP\") ?? \"8080\",\n\t);\n\tconst server = serve({ fetch: app.fetch, port }, () =>\n\t\tlogger().info(\"server listening\", { port }),\n\t);\n\tinjectWebSocket(server);\n\n\treturn { upgradeWebSocket };\n}\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry/mod.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/src/registry\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/src/registry/mod.ts\";import type { Hono } from \"hono\";\nimport { createActorRouter } from \"@/actor/router\";\nimport { type Client, createClientWithDriver } from \"@/client/client\";\nimport { chooseDefaultDriver } from \"@/drivers/default\";\nimport { createInlineClientDriver } from \"@/inline-client-driver/mod\";\nimport { getInspectorUrl } from \"@/inspector/utils\";\nimport { createManagerRouter } from \"@/manager/router\";\nimport {\n\ttype RegistryActors,\n\ttype RegistryConfig,\n\ttype RegistryConfigInput,\n\tRegistryConfigSchema,\n} from \"./config\";\nimport { logger } from \"./log\";\nimport {\n\ttype DriverConfig,\n\ttype RunConfig,\n\ttype RunConfigInput,\n\tRunConfigSchema,\n} from \"./run-config\";\nimport { crossPlatformServe } from \"./serve\";\n\ninterface ServerOutput<A extends Registry<any>> {\n\tclient: Client<A>;\n\thono: Hono;\n\thandler: (req: Request) => Promise<Response>;\n\tserve: (hono?: Hono) => void;\n}\n\nexport class Registry<A extends RegistryActors> {\n\t#config: RegistryConfig;\n\n\tpublic get config(): RegistryConfig {\n\t\treturn this.#config;\n\t}\n\n\tconstructor(config: RegistryConfig) {\n\t\tthis.#config = config;\n\t}\n\n\t/**\n\t * Runs the registry for a server.\n\t */\n\tpublic createServer(inputConfig?: RunConfigInput): ServerOutput<this> {\n\t\tconst config = RunConfigSchema.parse(inputConfig);\n\n\t\t// Choose the driver based on configuration\n\t\tconst driver = chooseDefaultDriver(config);\n\n\t\t// Configure getUpgradeWebSocket lazily so we can assign it in crossPlatformServe\n\t\tlet upgradeWebSocket: any;\n\t\tif (!config.getUpgradeWebSocket) {\n\t\t\tconfig.getUpgradeWebSocket = () => upgradeWebSocket!;\n\t\t}\n\n\t\t// Create router\n\t\tconst managerDriver = driver.manager(this.#config, config);\n\t\tconst clientDriver = createInlineClientDriver(managerDriver);\n\t\tconst { router: hono } = createManagerRouter(\n\t\t\tthis.#config,\n\t\t\tconfig,\n\t\t\tclientDriver,\n\t\t\tmanagerDriver,\n\t\t\tfalse,\n\t\t);\n\n\t\t// Create client\n\t\tconst client = createClientWithDriver<this>(clientDriver);\n\n\t\tconst driverLog = managerDriver.extraStartupLog?.() ?? {};\n\t\tlogger().info(\"rivetkit ready\", {\n\t\t\tdriver: driver.name,\n\t\t\tdefinitions: Object.keys(this.#config.use).length,\n\t\t\t...driverLog,\n\t\t});\n\t\tif (config.inspector?.enabled) {\n\t\t\tlogger().info(\"inspector ready\", {\n\t\t\t\turl: getInspectorUrl(config),\n\t\t\t});\n\t\t}\n\n\t\t// Create runner\n\t\tif (config.role === \"all\" || config.role === \"runner\") {\n\t\t\tconst inlineClient = createClientWithDriver(\n\t\t\t\tcreateInlineClientDriver(managerDriver),\n\t\t\t);\n\t\t\tconst _actorDriver = driver.actor(\n\t\t\t\tthis.#config,\n\t\t\t\tconfig,\n\t\t\t\tmanagerDriver,\n\t\t\t\tinlineClient,\n\t\t\t);\n\t\t\t// TODO: What do we do with the actor driver here?\n\t\t}\n\n\t\treturn {\n\t\t\tclient,\n\t\t\thono,\n\t\t\thandler: async (req: Request) => await hono.fetch(req),\n\t\t\tserve: async (app) => {\n\t\t\t\tconst out = await crossPlatformServe(hono, app);\n\t\t\t\tupgradeWebSocket = out.upgradeWebSocket;\n\t\t\t},\n\t\t};\n\t}\n\n\t/**\n\t * Runs the registry as a standalone server.\n\t */\n\tpublic async runServer(inputConfig?: RunConfigInput) {\n\t\tconst { serve } = this.createServer(inputConfig);\n\t\tserve();\n\t}\n}\n\nexport function setup<A extends RegistryActors>(\n\tinput: RegistryConfigInput<A>,\n): Registry<A> {\n\tconst config = RegistryConfigSchema.parse(input);\n\treturn new Registry(config);\n}\n\nexport type { RegistryConfig, RegistryActors, RunConfig, DriverConfig };\nexport { RegistryConfigSchema };\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-inputs.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-inputs.ts\";import { actor } from \"rivetkit\";\n\nexport interface State {\n\tinitialInput?: unknown;\n\tonCreateInput?: unknown;\n}\n\n// Test actor that can capture input during creation\nexport const inputActor = actor({\n\tonAuth: () => {},\n\tcreateState: (c, input): State => {\n\t\treturn {\n\t\t\tinitialInput: input,\n\t\t\tonCreateInput: undefined,\n\t\t};\n\t},\n\n\tonCreate: (c, input) => {\n\t\tc.state.onCreateInput = input;\n\t},\n\n\tactions: {\n\t\tgetInputs: (c) => {\n\t\t\treturn {\n\t\t\t\tinitialInput: c.state.initialInput,\n\t\t\t\tonCreateInput: c.state.onCreateInput,\n\t\t\t};\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-timeout.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-timeout.ts\";import { actor } from \"rivetkit\";\n\n// Short timeout actor\nexport const shortTimeoutActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\toptions: {\n\t\tactionTimeout: 50, // 50ms timeout\n\t},\n\tactions: {\n\t\tquickAction: async (c) => {\n\t\t\treturn \"quick response\";\n\t\t},\n\t\tslowAction: async (c) => {\n\t\t\t// This action should timeout\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, 100));\n\t\t\treturn \"slow response\";\n\t\t},\n\t},\n});\n\n// Long timeout actor\nexport const longTimeoutActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\toptions: {\n\t\tactionTimeout: 200, // 200ms timeout\n\t},\n\tactions: {\n\t\tdelayedAction: async (c) => {\n\t\t\t// This action should complete within timeout\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, 100));\n\t\t\treturn \"delayed response\";\n\t\t},\n\t},\n});\n\n// Default timeout actor\nexport const defaultTimeoutActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tactions: {\n\t\tnormalAction: async (c) => {\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, 50));\n\t\t\treturn \"normal response\";\n\t\t},\n\t},\n});\n\n// Sync actor (timeout shouldn't apply)\nexport const syncTimeoutActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\toptions: {\n\t\tactionTimeout: 50, // 50ms timeout\n\t},\n\tactions: {\n\t\tsyncAction: (c) => {\n\t\t\treturn \"sync response\";\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-types.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/action-types.ts\";import { actor, UserError } from \"rivetkit\";\n\n// Actor with synchronous actions\nexport const syncActionActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tactions: {\n\t\t// Simple synchronous action that returns a value directly\n\t\tincrement: (c, amount = 1) => {\n\t\t\tc.state.value += amount;\n\t\t\treturn c.state.value;\n\t\t},\n\t\t// Synchronous action that returns an object\n\t\tgetInfo: (c) => {\n\t\t\treturn {\n\t\t\t\tcurrentValue: c.state.value,\n\t\t\t\ttimestamp: Date.now(),\n\t\t\t};\n\t\t},\n\t\t// Synchronous action with no return value (void)\n\t\treset: (c) => {\n\t\t\tc.state.value = 0;\n\t\t},\n\t},\n});\n\n// Actor with asynchronous actions\nexport const asyncActionActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0, data: null as any },\n\tactions: {\n\t\t// Async action with a delay\n\t\tdelayedIncrement: async (c, amount = 1) => {\n\t\t\tawait Promise.resolve();\n\t\t\tc.state.value += amount;\n\t\t\treturn c.state.value;\n\t\t},\n\t\t// Async action that simulates an API call\n\t\tfetchData: async (c, id: string) => {\n\t\t\tawait Promise.resolve();\n\n\t\t\t// Simulate response data\n\t\t\tconst data = { id, timestamp: Date.now() };\n\t\t\tc.state.data = data;\n\t\t\treturn data;\n\t\t},\n\t\t// Async action with error handling\n\t\tasyncWithError: async (c, shouldError: boolean) => {\n\t\t\tawait Promise.resolve();\n\n\t\t\tif (shouldError) {\n\t\t\t\tthrow new UserError(\"Intentional error\");\n\t\t\t}\n\n\t\t\treturn \"Success\";\n\t\t},\n\t},\n});\n\n// Actor with promise actions\nexport const promiseActor = actor({\n\tonAuth: () => {},\n\tstate: { results: [] as string[] },\n\tactions: {\n\t\t// Action that returns a resolved promise\n\t\tresolvedPromise: (c) => {\n\t\t\treturn Promise.resolve(\"resolved value\");\n\t\t},\n\t\t// Action that returns a promise that resolves after a delay\n\t\tdelayedPromise: (c): Promise<string> => {\n\t\t\treturn new Promise<string>((resolve) => {\n\t\t\t\tc.state.results.push(\"delayed\");\n\t\t\t\tresolve(\"delayed value\");\n\t\t\t});\n\t\t},\n\t\t// Action that returns a rejected promise\n\t\trejectedPromise: (c) => {\n\t\t\treturn Promise.reject(new UserError(\"promised rejection\"));\n\t\t},\n\t\t// Action to check the collected results\n\t\tgetResults: (c) => {\n\t\t\treturn c.state.results;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/actor-onstatechange.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/actor-onstatechange.ts\";import { actor } from \"rivetkit\";\n\nexport const onStateChangeActor = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tvalue: 0,\n\t\tchangeCount: 0,\n\t},\n\tactions: {\n\t\t// Action that modifies state - should trigger onStateChange\n\t\tsetValue: (c, newValue: number) => {\n\t\t\tc.state.value = newValue;\n\t\t\treturn c.state.value;\n\t\t},\n\t\t// Action that modifies state multiple times - should trigger onStateChange for each change\n\t\tincrementMultiple: (c, times: number) => {\n\t\t\tfor (let i = 0; i < times; i++) {\n\t\t\t\tc.state.value++;\n\t\t\t}\n\t\t\treturn c.state.value;\n\t\t},\n\t\t// Action that doesn't modify state - should NOT trigger onStateChange\n\t\tgetValue: (c) => {\n\t\t\treturn c.state.value;\n\t\t},\n\t\t// Action that reads and returns without modifying - should NOT trigger onStateChange\n\t\tgetDoubled: (c) => {\n\t\t\tconst doubled = c.state.value * 2;\n\t\t\treturn doubled;\n\t\t},\n\t\t// Get the count of how many times onStateChange was called\n\t\tgetChangeCount: (c) => {\n\t\t\treturn c.state.changeCount;\n\t\t},\n\t\t// Reset change counter for testing\n\t\tresetChangeCount: (c) => {\n\t\t\tc.state.changeCount = 0;\n\t\t},\n\t},\n\t// Track onStateChange calls\n\tonStateChange: (c) => {\n\t\tc.state.changeCount++;\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/auth.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/auth.ts\";import { actor, UserError } from \"rivetkit\";\n\n// Basic auth actor - requires API key\nexport const authActor = actor({\n\tstate: { requests: 0 },\n\tonAuth: (opts, params: { apiKey?: string } | undefined) => {\n\t\tconst apiKey = params?.apiKey;\n\t\tif (!apiKey) {\n\t\t\tthrow new UserError(\"API key required\", { code: \"missing_auth\" });\n\t\t}\n\n\t\tif (apiKey !== \"valid-api-key\") {\n\t\t\tthrow new UserError(\"Invalid API key\", { code: \"invalid_auth\" });\n\t\t}\n\n\t\treturn { userId: \"user123\", token: apiKey };\n\t},\n\tactions: {\n\t\tgetRequests: (c) => {\n\t\t\tc.state.requests++;\n\t\t\treturn c.state.requests;\n\t\t},\n\t\tgetUserAuth: (c) => c.conn.auth,\n\t},\n});\n\n// Intent-specific auth actor - checks different permissions for different intents\nexport const intentAuthActor = actor({\n\tstate: { value: 0 },\n\tonAuth: ({ request, intents }, params: { role: string }) => {\n\t\tconsole.log(\"intents\", intents, params);\n\t\tconst role = params.role;\n\n\t\tif (intents.has(\"create\") && role !== \"admin\") {\n\t\t\tthrow new UserError(\"Admin role required for create operations\", {\n\t\t\t\tcode: \"insufficient_permissions\",\n\t\t\t});\n\t\t}\n\n\t\tif (intents.has(\"action\") && ![\"admin\", \"user\"].includes(role || \"\")) {\n\t\t\tthrow new UserError(\"User or admin role required for actions\", {\n\t\t\t\tcode: \"insufficient_permissions\",\n\t\t\t});\n\t\t}\n\n\t\treturn { role, timestamp: Date.now() };\n\t},\n\tactions: {\n\t\tgetValue: (c) => c.state.value,\n\t\tsetValue: (c, value: number) => {\n\t\t\tc.state.value = value;\n\t\t\treturn value;\n\t\t},\n\t\tgetAuth: (c) => c.conn.auth,\n\t},\n});\n\n// Public actor - empty onAuth to allow public access\nexport const publicActor = actor({\n\tstate: { visitors: 0 },\n\tonAuth: () => {\n\t\treturn null; // Allow public access\n\t},\n\tactions: {\n\t\tvisit: (c) => {\n\t\t\tc.state.visitors++;\n\t\t\treturn c.state.visitors;\n\t\t},\n\t},\n});\n\n// No auth actor - should fail when accessed publicly (no onAuth defined)\nexport const noAuthActor = actor({\n\tstate: { value: 42 },\n\tactions: {\n\t\tgetValue: (c) => c.state.value,\n\t},\n});\n\n// Async auth actor - tests promise-based authentication\nexport const asyncAuthActor = actor({\n\tstate: { count: 0 },\n\tonAuth: async (opts, params: { token?: string } | undefined) => {\n\t\tconst token = params?.token;\n\t\tif (!token) {\n\t\t\tthrow new UserError(\"Token required\", { code: \"missing_token\" });\n\t\t}\n\n\t\t// Simulate token validation\n\t\tif (token === \"invalid\") {\n\t\t\tthrow new UserError(\"Token is invalid\", { code: \"invalid_token\" });\n\t\t}\n\n\t\treturn { userId: `user-${token}`, validated: true };\n\t},\n\tactions: {\n\t\tincrement: (c) => {\n\t\t\tc.state.count++;\n\t\t\treturn c.state.count;\n\t\t},\n\t\tgetAuthData: (c) => c.conn.auth,\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-liveness.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-liveness.ts\";import { actor, CONNECTION_DRIVER_WEBSOCKET } from \"rivetkit\";\n\nexport const connLivenessActor = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tcounter: 0,\n\t\tacceptingConnections: true,\n\t},\n\toptions: {\n\t\tconnectionLivenessInterval: 5_000,\n\t\tconnectionLivenessTimeout: 2_500,\n\t},\n\tonConnect: (c, conn) => {\n\t\tif (!c.state.acceptingConnections) {\n\t\t\tconn.disconnect();\n\t\t\tthrow new Error(\"Actor is not accepting connections\");\n\t\t}\n\t},\n\tactions: {\n\t\tgetWsConnectionsLiveness: (c) => {\n\t\t\treturn Array.from(c.conns.values())\n\t\t\t\t.filter((conn) => conn.driver === CONNECTION_DRIVER_WEBSOCKET)\n\t\t\t\t.map((conn) => ({\n\t\t\t\t\tid: conn.id,\n\t\t\t\t\tstatus: conn.status,\n\t\t\t\t\tlastSeen: conn.lastSeen,\n\t\t\t\t}));\n\t\t},\n\t\tgetConnectionId: (c) => {\n\t\t\treturn c.conn.id;\n\t\t},\n\t\tkill: (c, connId: string) => {\n\t\t\tc.state.acceptingConnections = false;\n\t\t\t// Disconnect the connection with the given ID\n\t\t\t// This simulates a network failure or a manual disconnection\n\t\t\t// The connection will be cleaned up by the actor manager after the timeout\n\t\t\tconst conn = c.conns.get(connId);\n\t\t\tif (conn) {\n\t\t\t\tconn.disconnect();\n\t\t\t}\n\t\t},\n\t\tgetCounter: (c) => {\n\t\t\treturn c.state.counter;\n\t\t},\n\t\tincrement: (c, amount: number) => {\n\t\t\tc.state.counter += amount;\n\t\t\treturn c.state.counter;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-params.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-params.ts\";import { actor } from \"rivetkit\";\n\nexport const counterWithParams = actor({\n\tonAuth: () => {},\n\tstate: { count: 0, initializers: [] as string[] },\n\tcreateConnState: (c, opts, params: { name?: string }) => {\n\t\treturn {\n\t\t\tname: params.name || \"anonymous\",\n\t\t};\n\t},\n\tonConnect: (c, conn) => {\n\t\t// Record connection name\n\t\tc.state.initializers.push(conn.state.name);\n\t},\n\tactions: {\n\t\tincrement: (c, x: number) => {\n\t\t\tc.state.count += x;\n\t\t\tc.broadcast(\"newCount\", {\n\t\t\t\tcount: c.state.count,\n\t\t\t\tby: c.conn.state.name,\n\t\t\t});\n\t\t\treturn c.state.count;\n\t\t},\n\t\tgetInitializers: (c) => {\n\t\t\treturn c.state.initializers;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-state.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/conn-state.ts\";import { actor } from \"rivetkit\";\n\nexport type ConnState = {\n\tusername: string;\n\trole: string;\n\tcounter: number;\n\tcreatedAt: number;\n};\n\nexport const connStateActor = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tsharedCounter: 0,\n\t\tdisconnectionCount: 0,\n\t},\n\t// Define connection state\n\tcreateConnState: (\n\t\tc,\n\t\topts,\n\t\tparams: { username?: string; role?: string },\n\t): ConnState => {\n\t\treturn {\n\t\t\tusername: params?.username || \"anonymous\",\n\t\t\trole: params?.role || \"user\",\n\t\t\tcounter: 0,\n\t\t\tcreatedAt: Date.now(),\n\t\t};\n\t},\n\t// Lifecycle hook when a connection is established\n\tonConnect: (c, conn) => {\n\t\t// Broadcast event about the new connection\n\t\tc.broadcast(\"userConnected\", {\n\t\t\tid: conn.id,\n\t\t\tusername: \"anonymous\",\n\t\t\trole: \"user\",\n\t\t});\n\t},\n\t// Lifecycle hook when a connection is closed\n\tonDisconnect: (c, conn) => {\n\t\tc.state.disconnectionCount += 1;\n\t\tc.broadcast(\"userDisconnected\", {\n\t\t\tid: conn.id,\n\t\t});\n\t},\n\tactions: {\n\t\t// Action to increment the connection's counter\n\t\tincrementConnCounter: (c, amount = 1) => {\n\t\t\tc.conn.state.counter += amount;\n\t\t},\n\n\t\t// Action to increment the shared counter\n\t\tincrementSharedCounter: (c, amount = 1) => {\n\t\t\tc.state.sharedCounter += amount;\n\t\t\treturn c.state.sharedCounter;\n\t\t},\n\n\t\t// Get the connection state\n\t\tgetConnectionState: (c) => {\n\t\t\treturn { id: c.conn.id, ...c.conn.state };\n\t\t},\n\n\t\t// Check all active connections\n\t\tgetConnectionIds: (c) => {\n\t\t\treturn c.conns.keys().toArray();\n\t\t},\n\n\t\t// Get disconnection count\n\t\tgetDisconnectionCount: (c) => {\n\t\t\treturn c.state.disconnectionCount;\n\t\t},\n\n\t\t// Get all active connection states\n\t\tgetAllConnectionStates: (c) => {\n\t\t\treturn c.conns\n\t\t\t\t.entries()\n\t\t\t\t.map(([id, conn]) => ({ id, ...conn.state }))\n\t\t\t\t.toArray();\n\t\t},\n\n\t\t// Send message to a specific connection with matching ID\n\t\tsendToConnection: (c, targetId: string, message: string) => {\n\t\t\tif (c.conns.has(targetId)) {\n\t\t\t\tc.conns\n\t\t\t\t\t.get(targetId)!\n\t\t\t\t\t.send(\"directMessage\", { from: c.conn.id, message });\n\t\t\t\treturn true;\n\t\t\t} else {\n\t\t\t\treturn false;\n\t\t\t}\n\t\t},\n\n\t\t// Update connection state (simulated for tests)\n\t\tupdateConnection: (\n\t\t\tc,\n\t\t\tupdates: Partial<{ username: string; role: string }>,\n\t\t) => {\n\t\t\tif (updates.username) c.conn.state.username = updates.username;\n\t\t\tif (updates.role) c.conn.state.role = updates.role;\n\t\t\treturn c.conn.state;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/counter.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/counter.ts\";import { actor } from \"rivetkit\";\n\nexport const counter = actor({\n\tonAuth: () => {},\n\tstate: { count: 0 },\n\tactions: {\n\t\tincrement: (c, x: number) => {\n\t\t\tc.state.count += x;\n\t\t\tc.broadcast(\"newCount\", c.state.count);\n\t\t\treturn c.state.count;\n\t\t},\n\t\tgetCount: (c) => {\n\t\t\treturn c.state.count;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/error-handling.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/error-handling.ts\";import { actor, UserError } from \"rivetkit\";\n\nexport const errorHandlingActor = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\terrorLog: [] as string[],\n\t},\n\tactions: {\n\t\t// Action that throws a UserError with just a message\n\t\tthrowSimpleError: () => {\n\t\t\tthrow new UserError(\"Simple error message\");\n\t\t},\n\n\t\t// Action that throws a UserError with code and metadata\n\t\tthrowDetailedError: () => {\n\t\t\tthrow new UserError(\"Detailed error message\", {\n\t\t\t\tcode: \"detailed_error\",\n\t\t\t\tmetadata: {\n\t\t\t\t\treason: \"test\",\n\t\t\t\t\ttimestamp: Date.now(),\n\t\t\t\t},\n\t\t\t});\n\t\t},\n\n\t\t// Action that throws an internal error\n\t\tthrowInternalError: () => {\n\t\t\tthrow new Error(\"This is an internal error\");\n\t\t},\n\n\t\t// Action that returns successfully\n\t\tsuccessfulAction: () => {\n\t\t\treturn \"success\";\n\t\t},\n\n\t\t// Action that times out (simulated with a long delay)\n\t\ttimeoutAction: async (c) => {\n\t\t\t// This action should time out if the timeout is configured\n\t\t\treturn new Promise((resolve) => {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tresolve(\"This should not be reached if timeout works\");\n\t\t\t\t}, 10000); // 10 seconds\n\t\t\t});\n\t\t},\n\n\t\t// Action with configurable delay to test timeout edge cases\n\t\tdelayedAction: async (c, delayMs: number) => {\n\t\t\treturn new Promise((resolve) => {\n\t\t\t\tsetTimeout(() => {\n\t\t\t\t\tresolve(`Completed after ${delayMs}ms`);\n\t\t\t\t}, delayMs);\n\t\t\t});\n\t\t},\n\n\t\t// Log an error for inspection\n\t\tlogError: (c, error: string) => {\n\t\t\tc.state.errorLog.push(error);\n\t\t\treturn c.state.errorLog;\n\t\t},\n\n\t\t// Get the error log\n\t\tgetErrorLog: (c) => {\n\t\t\treturn c.state.errorLog;\n\t\t},\n\n\t\t// Clear the error log\n\t\tclearErrorLog: (c) => {\n\t\t\tc.state.errorLog = [];\n\t\t\treturn true;\n\t\t},\n\t},\n\toptions: {\n\t\tactionTimeout: 500, // 500ms timeout for actions\n\t},\n});\n\n// Actor with custom timeout\nexport const customTimeoutActor = actor({\n\tstate: {},\n\tactions: {\n\t\tquickAction: async () => {\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, 50));\n\t\t\treturn \"Quick action completed\";\n\t\t},\n\t\tslowAction: async () => {\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, 300));\n\t\t\treturn \"Slow action completed\";\n\t\t},\n\t},\n\toptions: {\n\t\tactionTimeout: 200, // 200ms timeout\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/inline-client.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/inline-client.ts\";import { actor } from \"rivetkit\";\nimport type { registry } from \"./registry\";\n\nexport const inlineClientActor = actor({\n\tonAuth: () => {},\n\tstate: { messages: [] as string[] },\n\tactions: {\n\t\t// Action that uses client to call another actor (stateless)\n\t\tcallCounterIncrement: async (c, amount: number) => {\n\t\t\tconst client = c.client<typeof registry>();\n\t\t\tconst result = await client.counter\n\t\t\t\t.getOrCreate([\"inline-test\"])\n\t\t\t\t.increment(amount);\n\t\t\tc.state.messages.push(\n\t\t\t\t`Called counter.increment(${amount}), result: ${result}`,\n\t\t\t);\n\t\t\treturn result;\n\t\t},\n\n\t\t// Action that uses client to get counter state (stateless)\n\t\tgetCounterState: async (c) => {\n\t\t\tconst client = c.client<typeof registry>();\n\t\t\tconst count = await client.counter\n\t\t\t\t.getOrCreate([\"inline-test\"])\n\t\t\t\t.getCount();\n\t\t\tc.state.messages.push(`Got counter state: ${count}`);\n\t\t\treturn count;\n\t\t},\n\n\t\t// Action that uses client with .connect() for stateful communication\n\t\tconnectToCounterAndIncrement: async (c, amount: number) => {\n\t\t\tconst client = c.client<typeof registry>();\n\t\t\tconst handle = client.counter.getOrCreate([\"inline-test-stateful\"]);\n\t\t\tconst connection = handle.connect();\n\n\t\t\t// Set up event listener\n\t\t\tconst events: number[] = [];\n\t\t\tconnection.on(\"newCount\", (count: number) => {\n\t\t\t\tevents.push(count);\n\t\t\t});\n\n\t\t\t// Perform increments\n\t\t\tconst result1 = await connection.increment(amount);\n\t\t\tconst result2 = await connection.increment(amount * 2);\n\n\t\t\tawait connection.dispose();\n\n\t\t\tc.state.messages.push(\n\t\t\t\t`Connected to counter, incremented by ${amount} and ${amount * 2}, results: ${result1}, ${result2}, events: ${JSON.stringify(events)}`,\n\t\t\t);\n\n\t\t\treturn { result1, result2, events };\n\t\t},\n\n\t\t// Get all messages from this actor's state\n\t\tgetMessages: (c) => {\n\t\t\treturn c.state.messages;\n\t\t},\n\n\t\t// Clear messages\n\t\tclearMessages: (c) => {\n\t\t\tc.state.messages = [];\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/lifecycle.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/lifecycle.ts\";import { actor } from \"rivetkit\";\n\ntype ConnParams = { trackLifecycle?: boolean } | undefined;\n\nexport const counterWithLifecycle = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tcount: 0,\n\t\tevents: [] as string[],\n\t},\n\tcreateConnState: (c, opts, params: ConnParams) => ({\n\t\tjoinTime: Date.now(),\n\t}),\n\tonStart: (c) => {\n\t\tc.state.events.push(\"onStart\");\n\t},\n\tonBeforeConnect: (c, opts, params: ConnParams) => {\n\t\tif (params?.trackLifecycle) c.state.events.push(\"onBeforeConnect\");\n\t},\n\tonConnect: (c, conn) => {\n\t\tif (conn.params?.trackLifecycle) c.state.events.push(\"onConnect\");\n\t},\n\tonDisconnect: (c, conn) => {\n\t\tif (conn.params?.trackLifecycle) c.state.events.push(\"onDisconnect\");\n\t},\n\tactions: {\n\t\tgetEvents: (c) => {\n\t\t\treturn c.state.events;\n\t\t},\n\t\tincrement: (c, x: number) => {\n\t\t\tc.state.count += x;\n\t\t\treturn c.state.count;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/metadata.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/metadata.ts\";import { actor } from \"rivetkit\";\n\n// Note: For testing only - metadata API will need to be mocked\n// in tests since this is implementation-specific\nexport const metadataActor = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tlastMetadata: null as any,\n\t\tactorName: \"\",\n\t\t// Store tags and region in state for testing since they may not be\n\t\t// available in the context in all environments\n\t\tstoredTags: {} as Record<string, string>,\n\t\tstoredRegion: null as string | null,\n\t},\n\tonStart: (c) => {\n\t\t// Store the actor name during initialization\n\t\tc.state.actorName = c.name;\n\t},\n\tactions: {\n\t\t// Set up test tags - this will be called by tests to simulate tags\n\t\tsetupTestTags: (c, tags: Record<string, string>) => {\n\t\t\tc.state.storedTags = tags;\n\t\t\treturn tags;\n\t\t},\n\n\t\t// Set up test region - this will be called by tests to simulate region\n\t\tsetupTestRegion: (c, region: string) => {\n\t\t\tc.state.storedRegion = region;\n\t\t\treturn region;\n\t\t},\n\n\t\t// Get all available metadata\n\t\tgetMetadata: (c) => {\n\t\t\t// Create metadata object from stored values\n\t\t\tconst metadata = {\n\t\t\t\tname: c.name,\n\t\t\t\ttags: c.state.storedTags,\n\t\t\t\tregion: c.state.storedRegion,\n\t\t\t};\n\n\t\t\t// Store for later inspection\n\t\t\tc.state.lastMetadata = metadata;\n\t\t\treturn metadata;\n\t\t},\n\n\t\t// Get the actor name\n\t\tgetActorName: (c) => {\n\t\t\treturn c.name;\n\t\t},\n\n\t\t// Get a specific tag by key\n\t\tgetTag: (c, key: string) => {\n\t\t\treturn c.state.storedTags[key] || null;\n\t\t},\n\n\t\t// Get all tags\n\t\tgetTags: (c) => {\n\t\t\treturn c.state.storedTags;\n\t\t},\n\n\t\t// Get the region\n\t\tgetRegion: (c) => {\n\t\t\treturn c.state.storedRegion;\n\t\t},\n\n\t\t// Get the stored actor name (from onStart)\n\t\tgetStoredActorName: (c) => {\n\t\t\treturn c.state.actorName;\n\t\t},\n\n\t\t// Get last retrieved metadata\n\t\tgetLastMetadata: (c) => {\n\t\t\treturn c.state.lastMetadata;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http.ts\";import { Hono } from \"hono\";\nimport { type ActorContext, actor } from \"rivetkit\";\n\nexport const rawHttpActor = actor({\n\tstate: {\n\t\trequestCount: 0,\n\t},\n\tonAuth() {\n\t\t// Allow public access - empty onAuth\n\t\treturn {};\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\tconst url = new URL(request.url);\n\t\tconst method = request.method;\n\n\t\t// Track request count\n\t\tctx.state.requestCount++;\n\n\t\t// Handle different endpoints\n\t\tif (url.pathname === \"/api/hello\") {\n\t\t\treturn new Response(JSON.stringify({ message: \"Hello from actor!\" }), {\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\tif (url.pathname === \"/api/echo\" && method === \"POST\") {\n\t\t\treturn new Response(request.body, {\n\t\t\t\theaders: request.headers,\n\t\t\t});\n\t\t}\n\n\t\tif (url.pathname === \"/api/state\") {\n\t\t\treturn new Response(\n\t\t\t\tJSON.stringify({\n\t\t\t\t\trequestCount: ctx.state.requestCount,\n\t\t\t\t}),\n\t\t\t\t{\n\t\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\n\t\tif (url.pathname === \"/api/headers\") {\n\t\t\tconst headers = Object.fromEntries(request.headers.entries());\n\t\t\treturn new Response(JSON.stringify(headers), {\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\t// Return 404 for unhandled paths\n\t\treturn new Response(\"Not Found\", { status: 404 });\n\t},\n\tactions: {},\n});\n\nexport const rawHttpNoHandlerActor = actor({\n\t// No onFetch handler - all requests should return 404\n\tonAuth() {\n\t\t// Allow public access - empty onAuth\n\t\treturn {};\n\t},\n\tactions: {},\n});\n\nexport const rawHttpVoidReturnActor = actor({\n\tonAuth() {\n\t\t// Allow public access - empty onAuth\n\t\treturn {};\n\t},\n\tonFetch(ctx, request) {\n\t\t// Intentionally return void to test error handling\n\t\treturn undefined as any;\n\t},\n\tactions: {},\n});\n\nexport const rawHttpHonoActor = actor({\n\tonAuth() {\n\t\t// Allow public access\n\t\treturn {};\n\t},\n\tcreateVars() {\n\t\tconst router = new Hono();\n\n\t\t// Set up routes\n\t\trouter.get(\"/\", (c: any) => c.json({ message: \"Welcome to Hono actor!\" }));\n\n\t\trouter.get(\"/users\", (c: any) =>\n\t\t\tc.json([\n\t\t\t\t{ id: 1, name: \"Alice\" },\n\t\t\t\t{ id: 2, name: \"Bob\" },\n\t\t\t]),\n\t\t);\n\n\t\trouter.get(\"/users/:id\", (c: any) => {\n\t\t\tconst id = c.req.param(\"id\");\n\t\t\treturn c.json({ id: parseInt(id), name: id === \"1\" ? \"Alice\" : \"Bob\" });\n\t\t});\n\n\t\trouter.post(\"/users\", async (c: any) => {\n\t\t\tconst body = await c.req.json();\n\t\t\treturn c.json({ id: 3, ...body }, 201);\n\t\t});\n\n\t\trouter.put(\"/users/:id\", async (c: any) => {\n\t\t\tconst id = c.req.param(\"id\");\n\t\t\tconst body = await c.req.json();\n\t\t\treturn c.json({ id: parseInt(id), ...body });\n\t\t});\n\n\t\trouter.delete(\"/users/:id\", (c: any) => {\n\t\t\tconst id = c.req.param(\"id\");\n\t\t\treturn c.json({ message: `User ${id} deleted` });\n\t\t});\n\n\t\t// Return the router as a var\n\t\treturn { router };\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\t// Use the Hono router from vars\n\t\treturn ctx.vars.router.fetch(request);\n\t},\n\tactions: {},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http-auth.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http-auth.ts\";import { type ActorContext, actor, UserError } from \"rivetkit\";\n\n// Raw HTTP actor with authentication - requires API key\nexport const rawHttpAuthActor = actor({\n\tstate: {\n\t\trequestCount: 0,\n\t},\n\tonAuth: (opts, params: { apiKey?: string }) => {\n\t\tconst apiKey = params.apiKey;\n\t\tif (!apiKey) {\n\t\t\tthrow new UserError(\"API key required\", { code: \"missing_auth\" });\n\t\t}\n\n\t\tif (apiKey !== \"valid-api-key\") {\n\t\t\tthrow new UserError(\"Invalid API key\", { code: \"invalid_auth\" });\n\t\t}\n\n\t\treturn { userId: \"user123\", token: apiKey };\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\tconst url = new URL(request.url);\n\t\tctx.state.requestCount++;\n\n\t\t// Auth info endpoint - onAuth was already called\n\t\tif (url.pathname === \"/api/auth-info\") {\n\t\t\treturn new Response(\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tmessage: \"Authenticated request\",\n\t\t\t\t\trequestCount: ctx.state.requestCount,\n\t\t\t\t}),\n\t\t\t\t{\n\t\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\n\t\tif (url.pathname === \"/api/protected\") {\n\t\t\treturn new Response(\n\t\t\t\tJSON.stringify({\n\t\t\t\t\tmessage: \"This is protected content\",\n\t\t\t\t}),\n\t\t\t\t{\n\t\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t\t},\n\t\t\t);\n\t\t}\n\n\t\treturn new Response(\"Not Found\", { status: 404 });\n\t},\n\tactions: {\n\t\tgetRequestCount(ctx: any) {\n\t\t\treturn ctx.state.requestCount;\n\t\t},\n\t\tgetAuthFromConnections(ctx: any) {\n\t\t\t// Get auth data from first connection if available\n\t\t\tconst firstConn = ctx.conns.values().next().value;\n\t\t\treturn firstConn?.auth;\n\t\t},\n\t},\n});\n\n// Raw HTTP actor without onAuth - should deny access\nexport const rawHttpNoAuthActor = actor({\n\tstate: {\n\t\tvalue: 42,\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\treturn new Response(\n\t\t\tJSON.stringify({\n\t\t\t\tvalue: ctx.state.value,\n\t\t\t}),\n\t\t\t{\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t},\n\t\t);\n\t},\n\tactions: {\n\t\tgetValue(ctx: any) {\n\t\t\treturn ctx.state.value;\n\t\t},\n\t},\n});\n\n// Raw HTTP actor with public access (empty onAuth)\nexport const rawHttpPublicActor = actor({\n\tstate: {\n\t\tvisitors: 0,\n\t},\n\tonAuth: () => {\n\t\treturn null; // Allow public access\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\tctx.state.visitors++;\n\t\treturn new Response(\n\t\t\tJSON.stringify({\n\t\t\t\tmessage: \"Welcome visitor!\",\n\t\t\t\tcount: ctx.state.visitors,\n\t\t\t}),\n\t\t\t{\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t},\n\t\t);\n\t},\n\tactions: {\n\t\tgetVisitorCount(ctx: any) {\n\t\t\treturn ctx.state.visitors;\n\t\t},\n\t},\n});\n\n// Raw HTTP actor with custom auth in onFetch (no onAuth)\nexport const rawHttpCustomAuthActor = actor({\n\tstate: {\n\t\tauthorized: 0,\n\t\tunauthorized: 0,\n\t},\n\tonAuth: () => {\n\t\t// Allow all connections - auth will be handled in onFetch\n\t\treturn {};\n\t},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\t// Custom auth check in onFetch\n\t\tconst authHeader = request.headers.get(\"Authorization\");\n\n\t\tif (!authHeader || !authHeader.startsWith(\"Bearer \")) {\n\t\t\tctx.state.unauthorized++;\n\t\t\treturn new Response(JSON.stringify({ error: \"Unauthorized\" }), {\n\t\t\t\tstatus: 401,\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\tconst token = authHeader.substring(7);\n\t\tif (token !== \"custom-token\") {\n\t\t\tctx.state.unauthorized++;\n\t\t\treturn new Response(JSON.stringify({ error: \"Invalid token\" }), {\n\t\t\t\tstatus: 403,\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\tctx.state.authorized++;\n\t\treturn new Response(\n\t\t\tJSON.stringify({\n\t\t\t\tmessage: \"Authorized!\",\n\t\t\t\tauthorized: ctx.state.authorized,\n\t\t\t}),\n\t\t\t{\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t},\n\t\t);\n\t},\n\tactions: {\n\t\tgetStats(ctx: any) {\n\t\t\treturn {\n\t\t\t\tauthorized: ctx.state.authorized,\n\t\t\t\tunauthorized: ctx.state.unauthorized,\n\t\t\t};\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http-request-properties.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-http-request-properties.ts\";import { type ActorContext, actor } from \"rivetkit\";\n\nexport const rawHttpRequestPropertiesActor = actor({\n\tonAuth() {\n\t\t// Allow public access - empty onAuth\n\t\treturn {};\n\t},\n\tactions: {},\n\tonFetch(\n\t\tctx: ActorContext<any, any, any, any, any, any, any>,\n\t\trequest: Request,\n\t) {\n\t\t// Extract all relevant Request properties\n\t\tconst url = new URL(request.url);\n\t\tconst method = request.method;\n\n\t\t// Get all headers\n\t\tconst headers = Object.fromEntries(request.headers.entries());\n\n\t\t// Handle body based on content type\n\t\tconst handleBody = async () => {\n\t\t\tif (!request.body) {\n\t\t\t\treturn null;\n\t\t\t}\n\n\t\t\tconst contentType = request.headers.get(\"content-type\") || \"\";\n\n\t\t\ttry {\n\t\t\t\tif (contentType.includes(\"application/json\")) {\n\t\t\t\t\tconst text = await request.text();\n\t\t\t\t\treturn text ? JSON.parse(text) : null;\n\t\t\t\t} else {\n\t\t\t\t\t// For non-JSON, return as text\n\t\t\t\t\tconst text = await request.text();\n\t\t\t\t\treturn text || null; // Return null for empty bodies\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\t// If body parsing fails, return null\n\t\t\t\treturn null;\n\t\t\t}\n\t\t};\n\n\t\t// Special handling for HEAD requests - return empty body\n\t\tif (method === \"HEAD\") {\n\t\t\treturn new Response(null, {\n\t\t\t\tstatus: 200,\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\t// Return all request properties as JSON\n\t\treturn handleBody().then((body) => {\n\t\t\tconst responseData = {\n\t\t\t\t// URL properties\n\t\t\t\turl: request.url,\n\t\t\t\tpathname: url.pathname,\n\t\t\t\tsearch: url.search,\n\t\t\t\tsearchParams: Object.fromEntries(url.searchParams.entries()),\n\t\t\t\thash: url.hash,\n\n\t\t\t\t// Method\n\t\t\t\tmethod: request.method,\n\n\t\t\t\t// Headers\n\t\t\t\theaders: headers,\n\n\t\t\t\t// Body\n\t\t\t\tbody,\n\t\t\t\tbodyText:\n\t\t\t\t\ttypeof body === \"string\"\n\t\t\t\t\t\t? body\n\t\t\t\t\t\t: body === null && request.body !== null\n\t\t\t\t\t\t\t? \"\"\n\t\t\t\t\t\t\t: null,\n\n\t\t\t\t// Additional properties that might be available\n\t\t\t\t// Note: Some properties like cache, credentials, mode, etc.\n\t\t\t\t// might not be available in all environments\n\t\t\t\tcache: request.cache || null,\n\t\t\t\tcredentials: request.credentials || null,\n\t\t\t\tmode: request.mode || null,\n\t\t\t\tredirect: request.redirect || null,\n\t\t\t\treferrer: request.referrer || null,\n\t\t\t};\n\n\t\t\treturn new Response(JSON.stringify(responseData), {\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t});\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-websocket.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-websocket.ts\";import { type ActorContext, actor, type UniversalWebSocket } from \"rivetkit\";\n\nexport const rawWebSocketActor = actor({\n\tstate: {\n\t\tconnectionCount: 0,\n\t\tmessageCount: 0,\n\t},\n\tonAuth(params) {\n\t\t// Allow all connections and pass through connection params\n\t\treturn { connParams: params };\n\t},\n\tonWebSocket(ctx, websocket, opts) {\n\t\tctx.state.connectionCount = ctx.state.connectionCount + 1;\n\t\tconsole.log(`[ACTOR] New connection, count: ${ctx.state.connectionCount}`);\n\n\t\t// Send welcome message\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"welcome\",\n\t\t\t\tconnectionCount: ctx.state.connectionCount,\n\t\t\t}),\n\t\t);\n\t\tconsole.log(\"[ACTOR] Sent welcome message\");\n\n\t\t// Echo messages back\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\tctx.state.messageCount = ctx.state.messageCount + 1;\n\t\t\tconsole.log(\n\t\t\t\t`[ACTOR] Message received, total count: ${ctx.state.messageCount}, data:`,\n\t\t\t\tevent.data,\n\t\t\t);\n\n\t\t\tconst data = event.data;\n\t\t\tif (typeof data === \"string\") {\n\t\t\t\ttry {\n\t\t\t\t\tconst parsed = JSON.parse(data);\n\t\t\t\t\tif (parsed.type === \"ping\") {\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"pong\",\n\t\t\t\t\t\t\t\ttimestamp: Date.now(),\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else if (parsed.type === \"getStats\") {\n\t\t\t\t\t\tconsole.log(\n\t\t\t\t\t\t\t`[ACTOR] Sending stats - connections: ${ctx.state.connectionCount}, messages: ${ctx.state.messageCount}`,\n\t\t\t\t\t\t);\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"stats\",\n\t\t\t\t\t\t\t\tconnectionCount: ctx.state.connectionCount,\n\t\t\t\t\t\t\t\tmessageCount: ctx.state.messageCount,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else if (parsed.type === \"getAuthData\") {\n\t\t\t\t\t\t// Auth data is not directly available in raw WebSocket handler\n\t\t\t\t\t\t// Send a message indicating this limitation\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"authData\",\n\t\t\t\t\t\t\t\tauthData: null,\n\t\t\t\t\t\t\t\tmessage: \"Auth data not available in raw WebSocket handler\",\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else if (parsed.type === \"getRequestInfo\") {\n\t\t\t\t\t\t// Send back the request URL info\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"requestInfo\",\n\t\t\t\t\t\t\t\turl: opts.request.url,\n\t\t\t\t\t\t\t\tpathname: new URL(opts.request.url).pathname,\n\t\t\t\t\t\t\t\tsearch: new URL(opts.request.url).search,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// Echo back\n\t\t\t\t\t\twebsocket.send(data);\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\t// If not JSON, just echo it back\n\t\t\t\t\twebsocket.send(data);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// Echo binary data\n\t\t\t\twebsocket.send(data);\n\t\t\t}\n\t\t});\n\n\t\t// Handle close\n\t\twebsocket.addEventListener(\"close\", () => {\n\t\t\tctx.state.connectionCount = ctx.state.connectionCount - 1;\n\t\t\tconsole.log(\n\t\t\t\t`[ACTOR] Connection closed, count: ${ctx.state.connectionCount}`,\n\t\t\t);\n\t\t});\n\t},\n\tactions: {\n\t\tgetStats(ctx: any) {\n\t\t\treturn {\n\t\t\t\tconnectionCount: ctx.state.connectionCount,\n\t\t\t\tmessageCount: ctx.state.messageCount,\n\t\t\t};\n\t\t},\n\t},\n});\n\nexport const rawWebSocketBinaryActor = actor({\n\tonAuth() {\n\t\t// Allow all connections\n\t\treturn {};\n\t},\n\tonWebSocket(ctx, websocket, opts) {\n\t\t// Handle binary data\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\tconst data = event.data;\n\t\t\tif (data instanceof ArrayBuffer || data instanceof Uint8Array) {\n\t\t\t\t// Reverse the bytes and send back\n\t\t\t\tconst bytes = new Uint8Array(data);\n\t\t\t\tconst reversed = new Uint8Array(bytes.length);\n\t\t\t\tfor (let i = 0; i < bytes.length; i++) {\n\t\t\t\t\treversed[i] = bytes[bytes.length - 1 - i];\n\t\t\t\t}\n\t\t\t\twebsocket.send(reversed);\n\t\t\t}\n\t\t});\n\t},\n\tactions: {},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-websocket-auth.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/raw-websocket-auth.ts\";import {\n\ttype ActorContext,\n\tactor,\n\ttype UniversalWebSocket,\n\tUserError,\n} from \"rivetkit\";\n\n// Raw WebSocket actor with authentication\nexport const rawWebSocketAuthActor = actor({\n\tstate: {\n\t\tconnectionCount: 0,\n\t\tmessageCount: 0,\n\t},\n\tonAuth: (opts, params: { apiKey?: string }) => {\n\t\tconst apiKey = params.apiKey;\n\t\tif (!apiKey) {\n\t\t\tthrow new UserError(\"API key required\", { code: \"missing_auth\" });\n\t\t}\n\n\t\tif (apiKey !== \"valid-api-key\") {\n\t\t\tthrow new UserError(\"Invalid API key\", { code: \"invalid_auth\" });\n\t\t}\n\n\t\treturn { userId: \"user123\", token: apiKey };\n\t},\n\tonWebSocket(ctx, websocket) {\n\t\tctx.state.connectionCount++;\n\n\t\t// Send welcome message on connect\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"welcome\",\n\t\t\t\tmessage: \"Authenticated WebSocket connection\",\n\t\t\t\tconnectionCount: ctx.state.connectionCount,\n\t\t\t}),\n\t\t);\n\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\tctx.state.messageCount++;\n\t\t\tconst data = event.data;\n\n\t\t\tif (typeof data === \"string\") {\n\t\t\t\ttry {\n\t\t\t\t\tconst parsed = JSON.parse(data);\n\t\t\t\t\tif (parsed.type === \"getAuth\") {\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"authInfo\",\n\t\t\t\t\t\t\t\tauthenticated: true,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// Echo message back\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"echo\",\n\t\t\t\t\t\t\t\toriginal: parsed,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\twebsocket.send(data);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\twebsocket.addEventListener(\"close\", () => {\n\t\t\tctx.state.connectionCount--;\n\t\t});\n\t},\n\tactions: {\n\t\tgetStats(ctx: any) {\n\t\t\treturn {\n\t\t\t\tconnectionCount: ctx.state.connectionCount,\n\t\t\t\tmessageCount: ctx.state.messageCount,\n\t\t\t};\n\t\t},\n\t},\n});\n\n// Raw WebSocket actor without onAuth - should deny access\nexport const rawWebSocketNoAuthActor = actor({\n\tstate: {\n\t\tconnections: 0,\n\t},\n\tonWebSocket(ctx, websocket) {\n\t\tctx.state.connections++;\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"connected\",\n\t\t\t\tconnections: ctx.state.connections,\n\t\t\t}),\n\t\t);\n\t},\n\tactions: {\n\t\tgetConnectionCount(ctx: any) {\n\t\t\treturn ctx.state.connections;\n\t\t},\n\t},\n});\n\n// Raw WebSocket actor with public access\nexport const rawWebSocketPublicActor = actor({\n\tstate: {\n\t\tvisitors: 0,\n\t},\n\tonAuth: () => {\n\t\treturn null; // Allow public access\n\t},\n\tonWebSocket(ctx, websocket) {\n\t\tctx.state.visitors++;\n\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"welcome\",\n\t\t\t\tmessage: \"Public WebSocket connection\",\n\t\t\t\tvisitorNumber: ctx.state.visitors,\n\t\t\t}),\n\t\t);\n\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\t// Echo messages\n\t\t\twebsocket.send(event.data);\n\t\t});\n\t},\n\tactions: {\n\t\tgetVisitorCount(ctx: any) {\n\t\t\treturn ctx.state.visitors;\n\t\t},\n\t},\n});\n\n// Raw WebSocket with custom auth in onWebSocket\nexport const rawWebSocketCustomAuthActor = actor({\n\tstate: {\n\t\tauthorized: 0,\n\t\tunauthorized: 0,\n\t},\n\tonAuth: () => {\n\t\t// Allow all connections - auth will be handled in onWebSocket\n\t\treturn {};\n\t},\n\tonWebSocket(ctx, websocket, opts) {\n\t\t// Check for auth token in URL or headers\n\t\tconst url = new URL(opts.request.url);\n\t\tconst token = url.searchParams.get(\"token\");\n\n\t\tif (!token || token !== \"custom-ws-token\") {\n\t\t\tctx.state.unauthorized++;\n\t\t\twebsocket.send(\n\t\t\t\tJSON.stringify({\n\t\t\t\t\ttype: \"error\",\n\t\t\t\t\tmessage: \"Unauthorized\",\n\t\t\t\t}),\n\t\t\t);\n\t\t\twebsocket.close(1008, \"Unauthorized\");\n\t\t\treturn;\n\t\t}\n\n\t\tctx.state.authorized++;\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"authorized\",\n\t\t\t\tmessage: \"Welcome authenticated user!\",\n\t\t\t}),\n\t\t);\n\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\twebsocket.send(\n\t\t\t\tJSON.stringify({\n\t\t\t\t\ttype: \"echo\",\n\t\t\t\t\tdata: event.data,\n\t\t\t\t\tauthenticated: true,\n\t\t\t\t}),\n\t\t\t);\n\t\t});\n\t},\n\tactions: {\n\t\tgetStats(ctx: any) {\n\t\t\treturn {\n\t\t\t\tauthorized: ctx.state.authorized,\n\t\t\t\tunauthorized: ctx.state.unauthorized,\n\t\t\t};\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/request-access.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/request-access.ts\";import { actor } from \"rivetkit\";\n\n/**\n * Test fixture to verify request object access in all lifecycle hooks\n */\nexport const requestAccessActor = actor({\n\tonAuth: () => {}, // Allow unauthenticated connections\n\tstate: {\n\t\t// Track request info from different hooks\n\t\tonBeforeConnectRequest: {\n\t\t\thasRequest: false,\n\t\t\trequestUrl: null as string | null,\n\t\t\trequestMethod: null as string | null,\n\t\t\trequestHeaders: {} as Record<string, string>,\n\t\t},\n\t\tcreateConnStateRequest: {\n\t\t\thasRequest: false,\n\t\t\trequestUrl: null as string | null,\n\t\t\trequestMethod: null as string | null,\n\t\t\trequestHeaders: {} as Record<string, string>,\n\t\t},\n\t\tonFetchRequest: {\n\t\t\thasRequest: false,\n\t\t\trequestUrl: null as string | null,\n\t\t\trequestMethod: null as string | null,\n\t\t\trequestHeaders: {} as Record<string, string>,\n\t\t},\n\t\tonWebSocketRequest: {\n\t\t\thasRequest: false,\n\t\t\trequestUrl: null as string | null,\n\t\t\trequestMethod: null as string | null,\n\t\t\trequestHeaders: {} as Record<string, string>,\n\t\t},\n\t},\n\tcreateConnState: (c, { request }, params: { trackRequest?: boolean }) => {\n\t\t// In createConnState, the state isn't available yet.\n\n\t\treturn {\n\t\t\ttrackRequest: params?.trackRequest || false,\n\t\t\trequestInfo:\n\t\t\t\tparams?.trackRequest && request\n\t\t\t\t\t? {\n\t\t\t\t\t\t\thasRequest: true,\n\t\t\t\t\t\t\trequestUrl: request.url,\n\t\t\t\t\t\t\trequestMethod: request.method,\n\t\t\t\t\t\t\trequestHeaders: Object.fromEntries(request.headers.entries()),\n\t\t\t\t\t\t}\n\t\t\t\t\t: null,\n\t\t};\n\t},\n\tonConnect: (c, conn) => {\n\t\t// Copy request info from connection state if it was tracked\n\t\tif (conn.state.requestInfo) {\n\t\t\tc.state.createConnStateRequest = conn.state.requestInfo;\n\t\t}\n\t},\n\tonBeforeConnect: (c, { request }, params) => {\n\t\tif (params?.trackRequest) {\n\t\t\tif (request) {\n\t\t\t\tc.state.onBeforeConnectRequest.hasRequest = true;\n\t\t\t\tc.state.onBeforeConnectRequest.requestUrl = request.url;\n\t\t\t\tc.state.onBeforeConnectRequest.requestMethod = request.method;\n\n\t\t\t\t// Store select headers\n\t\t\t\tconst headers: Record<string, string> = {};\n\t\t\t\trequest.headers.forEach((value, key) => {\n\t\t\t\t\theaders[key] = value;\n\t\t\t\t});\n\t\t\t\tc.state.onBeforeConnectRequest.requestHeaders = headers;\n\t\t\t} else {\n\t\t\t\t// Track that we tried but request was not available\n\t\t\t\tc.state.onBeforeConnectRequest.hasRequest = false;\n\t\t\t}\n\t\t}\n\t},\n\tonFetch: (c, request) => {\n\t\t// Store request info\n\t\tc.state.onFetchRequest.hasRequest = true;\n\t\tc.state.onFetchRequest.requestUrl = request.url;\n\t\tc.state.onFetchRequest.requestMethod = request.method;\n\n\t\t// Store select headers\n\t\tconst headers: Record<string, string> = {};\n\t\trequest.headers.forEach((value, key) => {\n\t\t\theaders[key] = value;\n\t\t});\n\t\tc.state.onFetchRequest.requestHeaders = headers;\n\n\t\t// Return response with request info\n\t\treturn new Response(\n\t\t\tJSON.stringify({\n\t\t\t\thasRequest: true,\n\t\t\t\trequestUrl: request.url,\n\t\t\t\trequestMethod: request.method,\n\t\t\t\trequestHeaders: headers,\n\t\t\t}),\n\t\t\t{\n\t\t\t\tstatus: 200,\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t},\n\t\t);\n\t},\n\tonWebSocket: (c, websocket, { request }) => {\n\t\t// Store request info\n\t\tc.state.onWebSocketRequest.hasRequest = true;\n\t\tc.state.onWebSocketRequest.requestUrl = request.url;\n\t\tc.state.onWebSocketRequest.requestMethod = request.method;\n\n\t\t// Store select headers\n\t\tconst headers: Record<string, string> = {};\n\t\trequest.headers.forEach((value, key) => {\n\t\t\theaders[key] = value;\n\t\t});\n\t\tc.state.onWebSocketRequest.requestHeaders = headers;\n\n\t\t// Send request info on connection\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\thasRequest: true,\n\t\t\t\trequestUrl: request.url,\n\t\t\t\trequestMethod: request.method,\n\t\t\t\trequestHeaders: headers,\n\t\t\t}),\n\t\t);\n\n\t\t// Echo messages back\n\t\twebsocket.addEventListener(\"message\", (event) => {\n\t\t\twebsocket.send(event.data);\n\t\t});\n\t},\n\tactions: {\n\t\tgetRequestInfo: (c) => {\n\t\t\treturn {\n\t\t\t\tonBeforeConnect: c.state.onBeforeConnectRequest,\n\t\t\t\tcreateConnState: c.state.createConnStateRequest,\n\t\t\t\tonFetch: c.state.onFetchRequest,\n\t\t\t\tonWebSocket: c.state.onWebSocketRequest,\n\t\t\t};\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/request-access-auth.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/request-access-auth.ts\";import { actor } from \"rivetkit\";\n\n/**\n * Test fixture to verify request object access in onAuth hook\n * onAuth runs on the HTTP server, not in the actor, so we test it separately\n */\nexport const requestAccessAuthActor = actor({\n\tonAuth: ({ request, intents }, params: { trackRequest?: boolean }) => {\n\t\tif (params?.trackRequest) {\n\t\t\t// Extract request info and return it as auth data\n\t\t\tconst headers: Record<string, string> = {};\n\t\t\trequest.headers.forEach((value, key) => {\n\t\t\t\theaders[key] = value;\n\t\t\t});\n\n\t\t\treturn {\n\t\t\t\thasRequest: true,\n\t\t\t\trequestUrl: request.url,\n\t\t\t\trequestMethod: request.method,\n\t\t\t\trequestHeaders: headers,\n\t\t\t\tintents: Array.from(intents),\n\t\t\t};\n\t\t}\n\n\t\t// Return empty auth data when not tracking\n\t\treturn {};\n\t},\n\tstate: {\n\t\tauthData: null as any,\n\t},\n\tonConnect: (c, conn) => {\n\t\t// Store auth data in state so we can retrieve it\n\t\tc.state.authData = conn.auth;\n\t},\n\tactions: {\n\t\tgetAuthRequestInfo: (c) => {\n\t\t\t// Return the stored auth data or a default object\n\t\t\tconst authData = c.state.authData || {\n\t\t\t\thasRequest: false,\n\t\t\t\trequestUrl: null,\n\t\t\t\trequestMethod: null,\n\t\t\t\trequestHeaders: {},\n\t\t\t\tintents: [],\n\t\t\t};\n\t\t\treturn authData;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/scheduled.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/scheduled.ts\";import { actor } from \"rivetkit\";\n\nexport const scheduled = actor({\n\tonAuth: () => {},\n\tstate: {\n\t\tlastRun: 0,\n\t\tscheduledCount: 0,\n\t\ttaskHistory: [] as string[],\n\t},\n\tactions: {\n\t\t// Schedule using 'at' with specific timestamp\n\t\tscheduleTaskAt: (c, timestamp: number) => {\n\t\t\tc.schedule.at(timestamp, \"onScheduledTask\");\n\t\t\treturn timestamp;\n\t\t},\n\n\t\t// Schedule using 'after' with delay\n\t\tscheduleTaskAfter: (c, delayMs: number) => {\n\t\t\tc.schedule.after(delayMs, \"onScheduledTask\");\n\t\t\treturn Date.now() + delayMs;\n\t\t},\n\n\t\t// Schedule with a task ID for ordering tests\n\t\tscheduleTaskAfterWithId: (c, taskId: string, delayMs: number) => {\n\t\t\tc.schedule.after(delayMs, \"onScheduledTaskWithId\", taskId);\n\t\t\treturn { taskId, scheduledFor: Date.now() + delayMs };\n\t\t},\n\n\t\t// Original method for backward compatibility\n\t\tscheduleTask: (c, delayMs: number) => {\n\t\t\tconst timestamp = Date.now() + delayMs;\n\t\t\tc.schedule.at(timestamp, \"onScheduledTask\");\n\t\t\treturn timestamp;\n\t\t},\n\n\t\t// Getters for state\n\t\tgetLastRun: (c) => {\n\t\t\treturn c.state.lastRun;\n\t\t},\n\n\t\tgetScheduledCount: (c) => {\n\t\t\treturn c.state.scheduledCount;\n\t\t},\n\n\t\tgetTaskHistory: (c) => {\n\t\t\treturn c.state.taskHistory;\n\t\t},\n\n\t\tclearHistory: (c) => {\n\t\t\tc.state.taskHistory = [];\n\t\t\tc.state.scheduledCount = 0;\n\t\t\tc.state.lastRun = 0;\n\t\t\treturn true;\n\t\t},\n\n\t\t// Scheduled task handlers\n\t\tonScheduledTask: (c) => {\n\t\t\tc.state.lastRun = Date.now();\n\t\t\tc.state.scheduledCount++;\n\t\t\tc.broadcast(\"scheduled\", {\n\t\t\t\ttime: c.state.lastRun,\n\t\t\t\tcount: c.state.scheduledCount,\n\t\t\t});\n\t\t},\n\n\t\tonScheduledTaskWithId: (c, taskId: string) => {\n\t\t\tc.state.lastRun = Date.now();\n\t\t\tc.state.scheduledCount++;\n\t\t\tc.state.taskHistory.push(taskId);\n\t\t\tc.broadcast(\"scheduledWithId\", {\n\t\t\t\ttaskId,\n\t\t\t\ttime: c.state.lastRun,\n\t\t\t\tcount: c.state.scheduledCount,\n\t\t\t});\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/sleep.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/sleep.ts\";import { actor, type UniversalWebSocket } from \"rivetkit\";\n\nexport const SLEEP_TIMEOUT = 500;\n\nexport const sleep = actor({\n\tonAuth: () => {},\n\tstate: { startCount: 0, sleepCount: 0 },\n\tonStart: (c) => {\n\t\tc.state.startCount += 1;\n\t},\n\tonStop: (c) => {\n\t\tc.state.sleepCount += 1;\n\t},\n\tactions: {\n\t\ttriggerSleep: (c) => {\n\t\t\tc.sleep();\n\t\t},\n\t\tgetCounts: (c) => {\n\t\t\treturn { startCount: c.state.startCount, sleepCount: c.state.sleepCount };\n\t\t},\n\t\tsetAlarm: async (c, duration: number) => {\n\t\t\tawait c.schedule.after(duration, \"onAlarm\");\n\t\t},\n\t\tonAlarm: (c) => {\n\t\t\tc.log.info(\"alarm called\");\n\t\t},\n\t},\n\toptions: {\n\t\tsleepTimeout: SLEEP_TIMEOUT,\n\t},\n});\n\nexport const sleepWithLongRpc = actor({\n\tonAuth: () => {},\n\tstate: { startCount: 0, sleepCount: 0 },\n\tcreateVars: () => ({}) as { longRunningResolve: PromiseWithResolvers<void> },\n\tonStart: (c) => {\n\t\tc.state.startCount += 1;\n\t},\n\tonStop: (c) => {\n\t\tc.state.sleepCount += 1;\n\t},\n\tactions: {\n\t\tgetCounts: (c) => {\n\t\t\treturn { startCount: c.state.startCount, sleepCount: c.state.sleepCount };\n\t\t},\n\t\tlongRunningRpc: async (c) => {\n\t\t\tc.log.info(\"starting long running rpc\");\n\t\t\tc.vars.longRunningResolve = Promise.withResolvers();\n\t\t\tc.broadcast(\"waiting\");\n\t\t\tawait c.vars.longRunningResolve.promise;\n\t\t\tc.log.info(\"finished long running rpc\");\n\t\t},\n\t\tfinishLongRunningRpc: (c) => c.vars.longRunningResolve?.resolve(),\n\t},\n\toptions: {\n\t\tsleepTimeout: SLEEP_TIMEOUT,\n\t},\n});\n\nexport const sleepWithRawHttp = actor({\n\tonAuth: () => {},\n\tstate: { startCount: 0, sleepCount: 0, requestCount: 0 },\n\tonStart: (c) => {\n\t\tc.state.startCount += 1;\n\t},\n\tonStop: (c) => {\n\t\tc.state.sleepCount += 1;\n\t},\n\tonFetch: async (c, request) => {\n\t\tc.state.requestCount += 1;\n\t\tconst url = new URL(request.url);\n\n\t\tif (url.pathname === \"/long-request\") {\n\t\t\tconst duration = parseInt(url.searchParams.get(\"duration\") || \"1000\");\n\t\t\tc.log.info(\"starting long fetch request\", { duration });\n\t\t\tawait new Promise((resolve) => setTimeout(resolve, duration));\n\t\t\tc.log.info(\"finished long fetch request\");\n\t\t\treturn new Response(JSON.stringify({ completed: true }), {\n\t\t\t\theaders: { \"Content-Type\": \"application/json\" },\n\t\t\t});\n\t\t}\n\n\t\treturn new Response(\"Not Found\", { status: 404 });\n\t},\n\tactions: {\n\t\tgetCounts: (c) => {\n\t\t\treturn {\n\t\t\t\tstartCount: c.state.startCount,\n\t\t\t\tsleepCount: c.state.sleepCount,\n\t\t\t\trequestCount: c.state.requestCount,\n\t\t\t};\n\t\t},\n\t},\n\toptions: {\n\t\tsleepTimeout: SLEEP_TIMEOUT,\n\t},\n});\n\nexport const sleepWithRawWebSocket = actor({\n\tonAuth: () => {},\n\tstate: { startCount: 0, sleepCount: 0, connectionCount: 0 },\n\tonStart: (c) => {\n\t\tc.state.startCount += 1;\n\t},\n\tonStop: (c) => {\n\t\tc.state.sleepCount += 1;\n\t},\n\tonWebSocket: (c, websocket: UniversalWebSocket, opts) => {\n\t\tc.state.connectionCount += 1;\n\t\tc.log.info(\"websocket connected\", {\n\t\t\tconnectionCount: c.state.connectionCount,\n\t\t});\n\n\t\twebsocket.send(\n\t\t\tJSON.stringify({\n\t\t\t\ttype: \"connected\",\n\t\t\t\tconnectionCount: c.state.connectionCount,\n\t\t\t}),\n\t\t);\n\n\t\twebsocket.addEventListener(\"message\", (event: any) => {\n\t\t\tconst data = event.data;\n\t\t\tif (typeof data === \"string\") {\n\t\t\t\ttry {\n\t\t\t\t\tconst parsed = JSON.parse(data);\n\t\t\t\t\tif (parsed.type === \"getCounts\") {\n\t\t\t\t\t\twebsocket.send(\n\t\t\t\t\t\t\tJSON.stringify({\n\t\t\t\t\t\t\t\ttype: \"counts\",\n\t\t\t\t\t\t\t\tstartCount: c.state.startCount,\n\t\t\t\t\t\t\t\tsleepCount: c.state.sleepCount,\n\t\t\t\t\t\t\t\tconnectionCount: c.state.connectionCount,\n\t\t\t\t\t\t\t}),\n\t\t\t\t\t\t);\n\t\t\t\t\t} else if (parsed.type === \"keepAlive\") {\n\t\t\t\t\t\t// Just acknowledge to keep connection alive\n\t\t\t\t\t\twebsocket.send(JSON.stringify({ type: \"ack\" }));\n\t\t\t\t\t}\n\t\t\t\t} catch {\n\t\t\t\t\t// Echo non-JSON messages\n\t\t\t\t\twebsocket.send(data);\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\twebsocket.addEventListener(\"close\", () => {\n\t\t\tc.state.connectionCount -= 1;\n\t\t\tc.log.info(\"websocket disconnected\", {\n\t\t\t\tconnectionCount: c.state.connectionCount,\n\t\t\t});\n\t\t});\n\t},\n\tactions: {\n\t\tgetCounts: (c) => {\n\t\t\treturn {\n\t\t\t\tstartCount: c.state.startCount,\n\t\t\t\tsleepCount: c.state.sleepCount,\n\t\t\t\tconnectionCount: c.state.connectionCount,\n\t\t\t};\n\t\t},\n\t},\n\toptions: {\n\t\tsleepTimeout: SLEEP_TIMEOUT,\n\t},\n});\n\nexport const sleepWithNoSleepOption = actor({\n\tonAuth: () => {},\n\tstate: { startCount: 0, sleepCount: 0 },\n\tonStart: (c) => {\n\t\tc.state.startCount += 1;\n\t},\n\tonStop: (c) => {\n\t\tc.state.sleepCount += 1;\n\t},\n\tactions: {\n\t\tgetCounts: (c) => {\n\t\t\treturn { startCount: c.state.startCount, sleepCount: c.state.sleepCount };\n\t\t},\n\t},\n\toptions: {\n\t\tsleepTimeout: SLEEP_TIMEOUT,\n\t\tnoSleep: true,\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/vars.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/vars.ts\";import { actor } from \"rivetkit\";\n\n// Actor with static vars\nexport const staticVarActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tconnState: { hello: \"world\" },\n\tvars: { counter: 42, name: \"test-actor\" },\n\tactions: {\n\t\tgetVars: (c) => {\n\t\t\treturn c.vars;\n\t\t},\n\t\tgetName: (c) => {\n\t\t\treturn c.vars.name;\n\t\t},\n\t},\n});\n\n// Actor with nested vars\nexport const nestedVarActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tconnState: { hello: \"world\" },\n\tvars: {\n\t\tcounter: 42,\n\t\tnested: {\n\t\t\tvalue: \"original\",\n\t\t\tarray: [1, 2, 3],\n\t\t\tobj: { key: \"value\" },\n\t\t},\n\t},\n\tactions: {\n\t\tgetVars: (c) => {\n\t\t\treturn c.vars;\n\t\t},\n\t\tmodifyNested: (c) => {\n\t\t\t// Attempt to modify the nested object\n\t\t\tc.vars.nested.value = \"modified\";\n\t\t\tc.vars.nested.array.push(4);\n\t\t\tc.vars.nested.obj.key = \"new-value\";\n\t\t\treturn c.vars;\n\t\t},\n\t},\n});\n\n// Actor with dynamic vars\nexport const dynamicVarActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tconnState: { hello: \"world\" },\n\tcreateVars: () => {\n\t\treturn {\n\t\t\trandom: Math.random(),\n\t\t\tcomputed: `Actor-${Math.floor(Math.random() * 1000)}`,\n\t\t};\n\t},\n\tactions: {\n\t\tgetVars: (c) => {\n\t\t\treturn c.vars;\n\t\t},\n\t},\n});\n\n// Actor with unique vars per instance\nexport const uniqueVarActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tconnState: { hello: \"world\" },\n\tcreateVars: () => {\n\t\treturn {\n\t\t\tid: Math.floor(Math.random() * 1000000),\n\t\t};\n\t},\n\tactions: {\n\t\tgetVars: (c) => {\n\t\t\treturn c.vars;\n\t\t},\n\t},\n});\n\n// Actor that uses driver context\nexport const driverCtxActor = actor({\n\tonAuth: () => {},\n\tstate: { value: 0 },\n\tconnState: { hello: \"world\" },\n\tcreateVars: (c, driverCtx: any) => {\n\t\treturn {\n\t\t\thasDriverCtx: Boolean(driverCtx?.isTest),\n\t\t};\n\t},\n\tactions: {\n\t\tgetVars: (c) => {\n\t\t\treturn c.vars;\n\t\t},\n\t},\n});\n", "const __injected_filename__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/registry.ts\";const __injected_dirname__ = \"/Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite\";const __injected_import_meta_url__ = \"file:///Users/nathan/rivetkit/packages/rivetkit/fixtures/driver-test-suite/registry.ts\";import { setup } from \"rivetkit\";\n\nimport { inputActor } from \"./action-inputs\";\nimport {\n\tdefaultTimeoutActor,\n\tlongTimeoutActor,\n\tshortTimeoutActor,\n\tsyncTimeoutActor,\n} from \"./action-timeout\";\nimport {\n\tasyncActionActor,\n\tpromiseActor,\n\tsyncActionActor,\n} from \"./action-types\";\nimport { onStateChangeActor } from \"./actor-onstatechange\";\nimport {\n\tasyncAuthActor,\n\tauthActor,\n\tintentAuthActor,\n\tnoAuthActor,\n\tpublicActor,\n} from \"./auth\";\nimport { connLivenessActor } from \"./conn-liveness\";\nimport { counterWithParams } from \"./conn-params\";\nimport { connStateActor } from \"./conn-state\";\n// Import actors from individual files\nimport { counter } from \"./counter\";\nimport { customTimeoutActor, errorHandlingActor } from \"./error-handling\";\nimport { inlineClientActor } from \"./inline-client\";\nimport { counterWithLifecycle } from \"./lifecycle\";\nimport { metadataActor } from \"./metadata\";\nimport {\n\trawHttpActor,\n\trawHttpHonoActor,\n\trawHttpNoHandlerActor,\n\trawHttpVoidReturnActor,\n} from \"./raw-http\";\nimport {\n\trawHttpAuthActor,\n\trawHttpCustomAuthActor,\n\trawHttpNoAuthActor,\n\trawHttpPublicActor,\n} from \"./raw-http-auth\";\nimport { rawHttpRequestPropertiesActor } from \"./raw-http-request-properties\";\nimport { rawWebSocketActor, rawWebSocketBinaryActor } from \"./raw-websocket\";\nimport {\n\trawWebSocketAuthActor,\n\trawWebSocketCustomAuthActor,\n\trawWebSocketNoAuthActor,\n\trawWebSocketPublicActor,\n} from \"./raw-websocket-auth\";\nimport { requestAccessActor } from \"./request-access\";\nimport { requestAccessAuthActor } from \"./request-access-auth\";\nimport { scheduled } from \"./scheduled\";\nimport {\n\tsleep,\n\tsleepWithLongRpc,\n\tsleepWithNoSleepOption,\n\tsleepWithRawHttp,\n\tsleepWithRawWebSocket,\n} from \"./sleep\";\nimport {\n\tdriverCtxActor,\n\tdynamicVarActor,\n\tnestedVarActor,\n\tstaticVarActor,\n\tuniqueVarActor,\n} from \"./vars\";\n\n// Consolidated setup with all actors\nexport const registry = setup({\n\tuse: {\n\t\t// From counter.ts\n\t\tcounter,\n\t\t// From lifecycle.ts\n\t\tcounterWithLifecycle,\n\t\t// From scheduled.ts\n\t\tscheduled,\n\t\t// From sleep.ts\n\t\tsleep,\n\t\tsleepWithLongRpc,\n\t\tsleepWithRawHttp,\n\t\tsleepWithRawWebSocket,\n\t\tsleepWithNoSleepOption,\n\t\t// From error-handling.ts\n\t\terrorHandlingActor,\n\t\tcustomTimeoutActor,\n\t\t// From inline-client.ts\n\t\tinlineClientActor,\n\t\t// From action-inputs.ts\n\t\tinputActor,\n\t\t// From action-timeout.ts\n\t\tshortTimeoutActor,\n\t\tlongTimeoutActor,\n\t\tdefaultTimeoutActor,\n\t\tsyncTimeoutActor,\n\t\t// From action-types.ts\n\t\tsyncActionActor,\n\t\tasyncActionActor,\n\t\tpromiseActor,\n\t\t// From conn-params.ts\n\t\tcounterWithParams,\n\t\t// From conn-state.ts\n\t\tconnStateActor,\n\t\t// From actor-conn.ts\n\t\tconnLivenessActor,\n\t\t// From metadata.ts\n\t\tmetadataActor,\n\t\t// From vars.ts\n\t\tstaticVarActor,\n\t\tnestedVarActor,\n\t\tdynamicVarActor,\n\t\tuniqueVarActor,\n\t\tdriverCtxActor,\n\t\t// From auth.ts\n\t\tauthActor,\n\t\tintentAuthActor,\n\t\tpublicActor,\n\t\tnoAuthActor,\n\t\tasyncAuthActor,\n\t\t// From raw-http.ts\n\t\trawHttpActor,\n\t\trawHttpNoHandlerActor,\n\t\trawHttpVoidReturnActor,\n\t\trawHttpHonoActor,\n\t\t// From raw-http-auth.ts\n\t\trawHttpAuthActor,\n\t\trawHttpNoAuthActor,\n\t\trawHttpPublicActor,\n\t\trawHttpCustomAuthActor,\n\t\t// From raw-http-request-properties.ts\n\t\trawHttpRequestPropertiesActor,\n\t\t// From raw-websocket.ts\n\t\trawWebSocketActor,\n\t\trawWebSocketBinaryActor,\n\t\t// From raw-websocket-auth.ts\n\t\trawWebSocketAuthActor,\n\t\trawWebSocketNoAuthActor,\n\t\trawWebSocketPublicActor,\n\t\trawWebSocketCustomAuthActor,\n\t\t// From request-access.ts\n\t\trequestAccessActor,\n\t\trequestAccessAuthActor,\n\t\t// From actor-onstatechange.ts\n\t\tonStateChangeActor,\n\t},\n});\n"],
  "mappings": "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",
  "names": ["cbor", "config", "logger", "assertUnreachable", "assertUnreachable", "actor", "z", "z", "cbor", "invariant", "streamSSE", "z", "z", "z", "cbor", "logger", "logger", "cbor", "z", "z", "actor", "message", "actor", "path", "z", "z", "ActorFeature", "z", "streamSSE", "bare", "config", "read0", "write0", "read1", "write1", "CURRENT_VERSION", "migrations", "actor", "actor", "config", "path", "invariant", "bareData", "conn", "sleep", "res", "config", "actor", "Hono", "invariant", "cbor", "logger", "path", "crypto", "crypto", "Hono", "c", "actor", "invariant", "config", "cbor", "invariant", "InternalError", "ActorError", "LOGGER_NAME", "logger", "cbor", "invariant", "logger", "invariant", "ActorError", "logger", "ActorError", "InternalError", "invariant", "invariant", "path", "logger", "path", "assertUnreachable", "invariant", "logger", "opts", "LOGGER_NAME", "logger", "cbor", "WSContext", "invariant", "z", "z", "z", "z", "cbor", "LOGGER_NAME", "logger", "config", "logger", "actor", "invariant", "WSContext", "z", "z", "cbor", "invariant", "logger", "path", "logger", "config", "WebSocket", "logger", "event", "config", "logger", "path", "WebSocket", "invariant", "config", "actor", "crypto", "fsSync", "fs", "path", "invariant", "bare", "config", "read0", "write0", "CURRENT_VERSION", "migrations", "LOGGER_NAME", "logger", "crypto", "path", "logger", "invariant", "actor", "invariant", "cbor", "invariant", "onChange", "logger", "LOGGER_NAME", "logger", "logger", "invariant", "ActorError", "path", "sValidator", "Hono", "Hono", "sValidator", "actor", "transformActor", "actor", "path", "invariant", "logger", "cbor", "Hono", "streamSSE", "invariant", "z", "logger", "z", "logger", "path", "c", "Hono", "invariant", "queryActor", "streamSSE", "z", "z", "LOGGER_NAME", "logger", "Hono", "Hono", "logger", "config", "logger", "Hono", "Hono"]
}

diff --git a/packages/rivetkit/fixtures/driver-test-suite/registry.ts b/packages/rivetkit/fixtures/driver-test-suite/registry.ts
index 22d051d63..bffd29b2f 100644
--- a/packages/rivetkit/fixtures/driver-test-suite/registry.ts
+++ b/packages/rivetkit/fixtures/driver-test-suite/registry.ts
@@ -12,6 +12,7 @@ import {
 	promiseActor,
 	syncActionActor,
 } from "./action-types";
+import { onStateChangeActor } from "./actor-onstatechange";
 import {
 	asyncAuthActor,
 	authActor,
@@ -140,5 +141,7 @@ export const registry = setup({
 		// From request-access.ts
 		requestAccessActor,
 		requestAccessAuthActor,
+		// From actor-onstatechange.ts
+		onStateChangeActor,
 	},
 });
diff --git a/packages/rivetkit/src/actor/config.ts b/packages/rivetkit/src/actor/config.ts
index 69ffbd957..8c91d09e8 100644
--- a/packages/rivetkit/src/actor/config.ts
+++ b/packages/rivetkit/src/actor/config.ts
@@ -347,6 +347,9 @@ interface BaseActorConfig<
 	 * Use this hook to react to state changes, such as updating
 	 * external systems or triggering events.
 	 *
+	 * State changes made within this hook will NOT trigger
+	 * another onStateChange call, preventing infinite recursion.
+	 *
 	 * @param newState The updated state
 	 */
 	onStateChange?: (
diff --git a/packages/rivetkit/src/actor/instance.ts b/packages/rivetkit/src/actor/instance.ts
index 6231640e9..5327c020d 100644
--- a/packages/rivetkit/src/actor/instance.ts
+++ b/packages/rivetkit/src/actor/instance.ts
@@ -142,6 +142,7 @@ export class ActorInstance<
 	}
 
 	#persistChanged = false;
+	#isInOnStateChange = false;
 
 	/**
 	 * The proxied state that notifies of changes automatically.
@@ -648,8 +649,14 @@ export class ActorInstance<
 				this.inspector.emitter.emit("stateUpdated", this.#persist.state);
 
 				// Call onStateChange if it exists
-				if (this.#config.onStateChange && this.#ready) {
+				// Skip if we're already inside onStateChange to prevent infinite recursion
+				if (
+					this.#config.onStateChange &&
+					this.#ready &&
+					!this.#isInOnStateChange
+				) {
 					try {
+						this.#isInOnStateChange = true;
 						this.#config.onStateChange(
 							this.actorContext,
 							this.#persistRaw.state,
@@ -658,6 +665,8 @@ export class ActorInstance<
 						logger().error("error in `_onStateChange`", {
 							error: stringifyError(error),
 						});
+					} finally {
+						this.#isInOnStateChange = false;
 					}
 				}
 
diff --git a/packages/rivetkit/src/driver-test-suite/mod.ts b/packages/rivetkit/src/driver-test-suite/mod.ts
index c3885700b..73d074787 100644
--- a/packages/rivetkit/src/driver-test-suite/mod.ts
+++ b/packages/rivetkit/src/driver-test-suite/mod.ts
@@ -22,6 +22,7 @@ import { runActorHandleTests } from "./tests/actor-handle";
 import { runActorInlineClientTests } from "./tests/actor-inline-client";
 import { runActorInspectorTests } from "./tests/actor-inspector";
 import { runActorMetadataTests } from "./tests/actor-metadata";
+import { runActorOnStateChangeTests } from "./tests/actor-onstatechange";
 import { runActorVarsTests } from "./tests/actor-vars";
 import { runManagerDriverTests } from "./tests/manager-driver";
 import { runRawHttpTests } from "./tests/raw-http";
@@ -109,6 +110,8 @@ export function runDriverTests(
 
 			runActorMetadataTests(driverTestConfig);
 
+			runActorOnStateChangeTests(driverTestConfig);
+
 			runActorErrorHandlingTests(driverTestConfig);
 
 			runActorAuthTests(driverTestConfig);
diff --git a/packages/rivetkit/src/driver-test-suite/tests/actor-onstatechange.ts b/packages/rivetkit/src/driver-test-suite/tests/actor-onstatechange.ts
new file mode 100644
index 000000000..fe8bc2840
--- /dev/null
+++ b/packages/rivetkit/src/driver-test-suite/tests/actor-onstatechange.ts
@@ -0,0 +1,75 @@
+import { describe, expect, test } from "vitest";
+import type { DriverTestConfig } from "@/driver-test-suite/mod";
+import { setupDriverTest } from "@/driver-test-suite/utils";
+
+export function runActorOnStateChangeTests(driverTestConfig: DriverTestConfig) {
+	describe("Actor onStateChange Tests", () => {
+		test("triggers onStateChange when state is modified", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Modify state - should trigger onChange
+			await actor.setValue(10);
+
+			// Check that onChange was called
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(1);
+		});
+
+		test("triggers onChange multiple times for multiple state changes", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Modify state multiple times
+			await actor.incrementMultiple(3);
+
+			// Check that onChange was called for each modification
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(3);
+		});
+
+		test("does NOT trigger onChange for read-only actions", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Set initial value
+			await actor.setValue(5);
+
+			// Read value without modifying - should NOT trigger onChange
+			const value = await actor.getValue();
+			expect(value).toBe(5);
+
+			// Check that onChange was NOT called
+			const changeCount = await actor.getChangeCount();
+			expect(changeCount).toBe(1);
+		});
+
+		test("does NOT trigger onChange for computed values", async (c) => {
+			const { client } = await setupDriverTest(c, driverTestConfig);
+
+			const actor = client.onStateChangeActor.getOrCreate();
+
+			// Set initial value
+			await actor.setValue(3);
+
+			// Check that onChange was called
+			{
+				const changeCount = await actor.getChangeCount();
+				expect(changeCount).toBe(1);
+			}
+
+			// Compute value without modifying state - should NOT trigger onChange
+			const doubled = await actor.getDoubled();
+			expect(doubled).toBe(6);
+
+			// Check that onChange was NOT called
+			{
+				const changeCount = await actor.getChangeCount();
+				expect(changeCount).toBe(1);
+			}
+		});
+	});
+}