@rivetkit/engine-runner 2.0.21

package/dist/mod.js

@@ -0,0 +1,2027 @@
+// src/mod.ts
+import * as protocol from "@rivetkit/engine-runner-protocol";
+
+// src/log.ts
+var LOGGER;
+function setLogger(logger2) {
+  LOGGER = logger2;
+}
+function logger() {
+  return LOGGER;
+}
+
+// src/tunnel.ts
+import { v4 as uuidv4 } from "uuid";
+
+// src/utils.ts
+function unreachable(x) {
+  throw `Unreachable: ${x}`;
+}
+function calculateBackoff(attempt, options = {}) {
+  const {
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    multiplier = 2,
+    jitter = true
+  } = options;
+  let delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
+  if (jitter) {
+    delay = delay * (1 + Math.random() * 0.25);
+  }
+  return Math.floor(delay);
+}
+
+// src/websocket-tunnel-adapter.ts
+var WebSocketTunnelAdapter = class {
+  #webSocketId;
+  #readyState = 0;
+  // CONNECTING
+  #eventListeners = /* @__PURE__ */ new Map();
+  #onopen = null;
+  #onclose = null;
+  #onerror = null;
+  #onmessage = null;
+  #bufferedAmount = 0;
+  #binaryType = "nodebuffer";
+  #extensions = "";
+  #protocol = "";
+  #url = "";
+  #sendCallback;
+  #closeCallback;
+  // Event buffering for events fired before listeners are attached
+  #bufferedEvents = [];
+  constructor(webSocketId, sendCallback, closeCallback) {
+    this.#webSocketId = webSocketId;
+    this.#sendCallback = sendCallback;
+    this.#closeCallback = closeCallback;
+  }
+  get readyState() {
+    return this.#readyState;
+  }
+  get bufferedAmount() {
+    return this.#bufferedAmount;
+  }
+  get binaryType() {
+    return this.#binaryType;
+  }
+  set binaryType(value) {
+    if (value === "nodebuffer" || value === "arraybuffer" || value === "blob") {
+      this.#binaryType = value;
+    }
+  }
+  get extensions() {
+    return this.#extensions;
+  }
+  get protocol() {
+    return this.#protocol;
+  }
+  get url() {
+    return this.#url;
+  }
+  get onopen() {
+    return this.#onopen;
+  }
+  set onopen(value) {
+    this.#onopen = value;
+    if (value) {
+      this.#flushBufferedEvents("open");
+    }
+  }
+  get onclose() {
+    return this.#onclose;
+  }
+  set onclose(value) {
+    this.#onclose = value;
+    if (value) {
+      this.#flushBufferedEvents("close");
+    }
+  }
+  get onerror() {
+    return this.#onerror;
+  }
+  set onerror(value) {
+    this.#onerror = value;
+    if (value) {
+      this.#flushBufferedEvents("error");
+    }
+  }
+  get onmessage() {
+    return this.#onmessage;
+  }
+  set onmessage(value) {
+    this.#onmessage = value;
+    if (value) {
+      this.#flushBufferedEvents("message");
+    }
+  }
+  send(data) {
+    if (this.#readyState !== 1) {
+      throw new Error("WebSocket is not open");
+    }
+    let isBinary = false;
+    let messageData;
+    if (typeof data === "string") {
+      messageData = data;
+    } else if (data instanceof ArrayBuffer) {
+      isBinary = true;
+      messageData = data;
+    } else if (ArrayBuffer.isView(data)) {
+      isBinary = true;
+      const view = data;
+      if (view.buffer instanceof SharedArrayBuffer) {
+        const bytes = new Uint8Array(
+          view.buffer,
+          view.byteOffset,
+          view.byteLength
+        );
+        messageData = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+      } else {
+        messageData = view.buffer.slice(
+          view.byteOffset,
+          view.byteOffset + view.byteLength
+        );
+      }
+    } else if (data instanceof Blob) {
+      throw new Error("Blob sending not implemented in tunnel adapter");
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      isBinary = true;
+      const buf = data;
+      if (buf.buffer instanceof SharedArrayBuffer) {
+        const bytes = new Uint8Array(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength
+        );
+        messageData = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+      } else {
+        messageData = buf.buffer.slice(
+          buf.byteOffset,
+          buf.byteOffset + buf.byteLength
+        );
+      }
+    } else {
+      throw new Error("Invalid data type");
+    }
+    this.#sendCallback(messageData, isBinary);
+  }
+  close(code, reason) {
+    if (this.#readyState === 2 || // CLOSING
+    this.#readyState === 3) {
+      return;
+    }
+    this.#readyState = 2;
+    this.#closeCallback(code, reason);
+    this.#readyState = 3;
+    const closeEvent = {
+      wasClean: true,
+      code: code || 1e3,
+      reason: reason || "",
+      type: "close",
+      target: this
+    };
+    this.#fireEvent("close", closeEvent);
+  }
+  addEventListener(type, listener, options) {
+    if (typeof listener === "function") {
+      let listeners = this.#eventListeners.get(type);
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        this.#eventListeners.set(type, listeners);
+      }
+      listeners.add(listener);
+      this.#flushBufferedEvents(type);
+    }
+  }
+  removeEventListener(type, listener, options) {
+    if (typeof listener === "function") {
+      const listeners = this.#eventListeners.get(type);
+      if (listeners) {
+        listeners.delete(listener);
+      }
+    }
+  }
+  dispatchEvent(event) {
+    return true;
+  }
+  #fireEvent(type, event) {
+    var _a, _b, _c, _d, _e;
+    const listeners = this.#eventListeners.get(type);
+    let hasListeners = false;
+    if (listeners && listeners.size > 0) {
+      hasListeners = true;
+      for (const listener of listeners) {
+        try {
+          listener.call(this, event);
+        } catch (error) {
+          (_a = logger()) == null ? void 0 : _a.error({
+            msg: "error in websocket event listener",
+            error,
+            type
+          });
+        }
+      }
+    }
+    switch (type) {
+      case "open":
+        if (this.#onopen) {
+          hasListeners = true;
+          try {
+            this.#onopen.call(this, event);
+          } catch (error) {
+            (_b = logger()) == null ? void 0 : _b.error({
+              msg: "error in onopen handler",
+              error
+            });
+          }
+        }
+        break;
+      case "close":
+        if (this.#onclose) {
+          hasListeners = true;
+          try {
+            this.#onclose.call(this, event);
+          } catch (error) {
+            (_c = logger()) == null ? void 0 : _c.error({
+              msg: "error in onclose handler",
+              error
+            });
+          }
+        }
+        break;
+      case "error":
+        if (this.#onerror) {
+          hasListeners = true;
+          try {
+            this.#onerror.call(this, event);
+          } catch (error) {
+            (_d = logger()) == null ? void 0 : _d.error({
+              msg: "error in onerror handler",
+              error
+            });
+          }
+        }
+        break;
+      case "message":
+        if (this.#onmessage) {
+          hasListeners = true;
+          try {
+            this.#onmessage.call(this, event);
+          } catch (error) {
+            (_e = logger()) == null ? void 0 : _e.error({
+              msg: "error in onmessage handler",
+              error
+            });
+          }
+        }
+        break;
+    }
+    if (!hasListeners) {
+      this.#bufferedEvents.push({ type, event });
+    }
+  }
+  #flushBufferedEvents(type) {
+    var _a, _b, _c, _d, _e;
+    const eventsToFlush = this.#bufferedEvents.filter(
+      (buffered) => buffered.type === type
+    );
+    this.#bufferedEvents = this.#bufferedEvents.filter(
+      (buffered) => buffered.type !== type
+    );
+    for (const { event } of eventsToFlush) {
+      const listeners = this.#eventListeners.get(type);
+      if (listeners) {
+        for (const listener of listeners) {
+          try {
+            listener.call(this, event);
+          } catch (error) {
+            (_a = logger()) == null ? void 0 : _a.error({
+              msg: "error in websocket event listener",
+              error,
+              type
+            });
+          }
+        }
+      }
+      switch (type) {
+        case "open":
+          if (this.#onopen) {
+            try {
+              this.#onopen.call(this, event);
+            } catch (error) {
+              (_b = logger()) == null ? void 0 : _b.error({
+                msg: "error in onopen handler",
+                error
+              });
+            }
+          }
+          break;
+        case "close":
+          if (this.#onclose) {
+            try {
+              this.#onclose.call(this, event);
+            } catch (error) {
+              (_c = logger()) == null ? void 0 : _c.error({
+                msg: "error in onclose handler",
+                error
+              });
+            }
+          }
+          break;
+        case "error":
+          if (this.#onerror) {
+            try {
+              this.#onerror.call(this, event);
+            } catch (error) {
+              (_d = logger()) == null ? void 0 : _d.error({
+                msg: "error in onerror handler",
+                error
+              });
+            }
+          }
+          break;
+        case "message":
+          if (this.#onmessage) {
+            try {
+              this.#onmessage.call(this, event);
+            } catch (error) {
+              (_e = logger()) == null ? void 0 : _e.error({
+                msg: "error in onmessage handler",
+                error
+              });
+            }
+          }
+          break;
+      }
+    }
+  }
+  // Internal methods called by the Tunnel class
+  _handleOpen() {
+    if (this.#readyState !== 0) {
+      return;
+    }
+    this.#readyState = 1;
+    const event = {
+      type: "open",
+      target: this
+    };
+    this.#fireEvent("open", event);
+  }
+  _handleMessage(data, isBinary) {
+    if (this.#readyState !== 1) {
+      return;
+    }
+    let messageData;
+    if (isBinary) {
+      if (this.#binaryType === "nodebuffer") {
+        messageData = Buffer.from(data);
+      } else if (this.#binaryType === "arraybuffer") {
+        if (data instanceof Uint8Array) {
+          messageData = data.buffer.slice(
+            data.byteOffset,
+            data.byteOffset + data.byteLength
+          );
+        } else {
+          messageData = data;
+        }
+      } else {
+        throw new Error(
+          "Blob binaryType not supported in tunnel adapter"
+        );
+      }
+    } else {
+      messageData = data;
+    }
+    const event = {
+      data: messageData,
+      type: "message",
+      target: this
+    };
+    this.#fireEvent("message", event);
+  }
+  _handleClose(code, reason) {
+    if (this.#readyState === 3) {
+      return;
+    }
+    this.#readyState = 3;
+    const event = {
+      wasClean: true,
+      code: code || 1e3,
+      reason: reason || "",
+      type: "close",
+      target: this
+    };
+    this.#fireEvent("close", event);
+  }
+  _handleError(error) {
+    const event = {
+      type: "error",
+      target: this,
+      error
+    };
+    this.#fireEvent("error", event);
+  }
+  // WebSocket constants for compatibility
+  static CONNECTING = 0;
+  static OPEN = 1;
+  static CLOSING = 2;
+  static CLOSED = 3;
+  // Instance constants
+  CONNECTING = 0;
+  OPEN = 1;
+  CLOSING = 2;
+  CLOSED = 3;
+  // Additional methods for compatibility
+  ping(data, mask, cb) {
+    if (cb) cb(new Error("Ping not supported in tunnel adapter"));
+  }
+  pong(data, mask, cb) {
+    if (cb) cb(new Error("Pong not supported in tunnel adapter"));
+  }
+  terminate() {
+    this.#readyState = 3;
+    this.#closeCallback(1006, "Abnormal Closure");
+    const event = {
+      wasClean: false,
+      code: 1006,
+      reason: "Abnormal Closure",
+      type: "close",
+      target: this
+    };
+    this.#fireEvent("close", event);
+  }
+};
+
+// src/tunnel.ts
+var GC_INTERVAL = 6e4;
+var MESSAGE_ACK_TIMEOUT = 5e3;
+var Tunnel = class {
+  #runner;
+  /** Requests over the tunnel to the actor that are in flight. */
+  #actorPendingRequests = /* @__PURE__ */ new Map();
+  /** WebSockets over the tunnel to the actor that are in flight. */
+  #actorWebSockets = /* @__PURE__ */ new Map();
+  /** Messages sent from the actor over the tunnel that have not been acked by the gateway. */
+  #pendingTunnelMessages = /* @__PURE__ */ new Map();
+  #gcInterval;
+  constructor(runner) {
+    this.#runner = runner;
+  }
+  start() {
+    this.#startGarbageCollector();
+  }
+  shutdown() {
+    if (this.#gcInterval) {
+      clearInterval(this.#gcInterval);
+      this.#gcInterval = void 0;
+    }
+    for (const [_, request] of this.#actorPendingRequests) {
+      request.reject(new Error("Tunnel shutting down"));
+    }
+    this.#actorPendingRequests.clear();
+    for (const [_, ws] of this.#actorWebSockets) {
+      ws.close();
+    }
+    this.#actorWebSockets.clear();
+  }
+  #sendMessage(requestId, messageKind) {
+    var _a;
+    if (!this.#runner.__webSocketReady()) {
+      (_a = logger()) == null ? void 0 : _a.warn(
+        "cannot send tunnel message, socket not connected to engine"
+      );
+      return;
+    }
+    const messageId = generateUuidBuffer();
+    const requestIdStr = bufferToString(requestId);
+    this.#pendingTunnelMessages.set(bufferToString(messageId), {
+      sentAt: Date.now(),
+      requestIdStr
+    });
+    const message = {
+      tag: "ToServerTunnelMessage",
+      val: {
+        requestId,
+        messageId,
+        messageKind
+      }
+    };
+    this.#runner.__sendToServer(message);
+  }
+  #sendAck(requestId, messageId) {
+    if (!this.#runner.__webSocketReady()) {
+      return;
+    }
+    const message = {
+      tag: "ToServerTunnelMessage",
+      val: {
+        requestId,
+        messageId,
+        messageKind: { tag: "TunnelAck", val: null }
+      }
+    };
+    this.#runner.__sendToServer(message);
+  }
+  #startGarbageCollector() {
+    if (this.#gcInterval) {
+      clearInterval(this.#gcInterval);
+    }
+    this.#gcInterval = setInterval(() => {
+      this.#gc();
+    }, GC_INTERVAL);
+  }
+  #gc() {
+    var _a;
+    const now = Date.now();
+    const messagesToDelete = [];
+    for (const [messageId, pendingMessage] of this.#pendingTunnelMessages) {
+      if (now - pendingMessage.sentAt > MESSAGE_ACK_TIMEOUT) {
+        messagesToDelete.push(messageId);
+        const requestIdStr = pendingMessage.requestIdStr;
+        const pendingRequest = this.#actorPendingRequests.get(requestIdStr);
+        if (pendingRequest) {
+          pendingRequest.reject(
+            new Error("Message acknowledgment timeout")
+          );
+          if (pendingRequest.streamController) {
+            pendingRequest.streamController.error(
+              new Error("Message acknowledgment timeout")
+            );
+          }
+          this.#actorPendingRequests.delete(requestIdStr);
+        }
+        const webSocket = this.#actorWebSockets.get(requestIdStr);
+        if (webSocket) {
+          webSocket.close(1e3, "Message acknowledgment timeout");
+          this.#actorWebSockets.delete(requestIdStr);
+        }
+      }
+    }
+    if (messagesToDelete.length > 0) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "purging unacked tunnel messages, this indicates that the Rivet Engine is disconnected or not responding",
+        count: messagesToDelete.length
+      });
+      for (const messageId of messagesToDelete) {
+        this.#pendingTunnelMessages.delete(messageId);
+      }
+    }
+  }
+  unregisterActor(actor) {
+    const actorId = actor.actorId;
+    for (const requestId of actor.requests) {
+      const pending = this.#actorPendingRequests.get(requestId);
+      if (pending) {
+        pending.reject(new Error(`Actor ${actorId} stopped`));
+        this.#actorPendingRequests.delete(requestId);
+      }
+    }
+    actor.requests.clear();
+    for (const webSocketId of actor.webSockets) {
+      const ws = this.#actorWebSockets.get(webSocketId);
+      if (ws) {
+        ws.close(1e3, "Actor stopped");
+        this.#actorWebSockets.delete(webSocketId);
+      }
+    }
+    actor.webSockets.clear();
+  }
+  async #fetch(actorId, request) {
+    var _a;
+    if (!this.#runner.hasActor(actorId)) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "ignoring request for unknown actor",
+        actorId
+      });
+      return new Response("Actor not found", { status: 404 });
+    }
+    const fetchHandler = this.#runner.config.fetch(
+      this.#runner,
+      actorId,
+      request
+    );
+    if (!fetchHandler) {
+      return new Response("Not Implemented", { status: 501 });
+    }
+    return fetchHandler;
+  }
+  async handleTunnelMessage(message) {
+    if (message.messageKind.tag === "TunnelAck") {
+      const msgIdStr = bufferToString(message.messageId);
+      const pending = this.#pendingTunnelMessages.get(msgIdStr);
+      if (pending) {
+        this.#pendingTunnelMessages.delete(msgIdStr);
+      }
+    } else {
+      this.#sendAck(message.requestId, message.messageId);
+      switch (message.messageKind.tag) {
+        case "ToClientRequestStart":
+          await this.#handleRequestStart(
+            message.requestId,
+            message.messageKind.val
+          );
+          break;
+        case "ToClientRequestChunk":
+          await this.#handleRequestChunk(
+            message.requestId,
+            message.messageKind.val
+          );
+          break;
+        case "ToClientRequestAbort":
+          await this.#handleRequestAbort(message.requestId);
+          break;
+        case "ToClientWebSocketOpen":
+          await this.#handleWebSocketOpen(
+            message.requestId,
+            message.messageKind.val
+          );
+          break;
+        case "ToClientWebSocketMessage":
+          await this.#handleWebSocketMessage(
+            message.requestId,
+            message.messageKind.val
+          );
+          break;
+        case "ToClientWebSocketClose":
+          await this.#handleWebSocketClose(
+            message.requestId,
+            message.messageKind.val
+          );
+          break;
+        default:
+          unreachable(message.messageKind);
+      }
+    }
+  }
+  async #handleRequestStart(requestId, req) {
+    var _a;
+    const requestIdStr = bufferToString(requestId);
+    const actor = this.#runner.getActor(req.actorId);
+    if (actor) {
+      actor.requests.add(requestIdStr);
+    }
+    try {
+      const headers = new Headers();
+      for (const [key, value] of req.headers) {
+        headers.append(key, value);
+      }
+      const request = new Request(`http://localhost${req.path}`, {
+        method: req.method,
+        headers,
+        body: req.body ? new Uint8Array(req.body) : void 0
+      });
+      if (req.stream) {
+        const stream = new ReadableStream({
+          start: (controller) => {
+            const existing = this.#actorPendingRequests.get(requestIdStr);
+            if (existing) {
+              existing.streamController = controller;
+              existing.actorId = req.actorId;
+            } else {
+              this.#actorPendingRequests.set(requestIdStr, {
+                resolve: () => {
+                },
+                reject: () => {
+                },
+                streamController: controller,
+                actorId: req.actorId
+              });
+            }
+          }
+        });
+        const streamingRequest = new Request(request, {
+          body: stream,
+          duplex: "half"
+        });
+        const response = await this.#fetch(
+          req.actorId,
+          streamingRequest
+        );
+        await this.#sendResponse(requestId, response);
+      } else {
+        const response = await this.#fetch(req.actorId, request);
+        await this.#sendResponse(requestId, response);
+      }
+    } catch (error) {
+      (_a = logger()) == null ? void 0 : _a.error({ msg: "error handling request", error });
+      this.#sendResponseError(requestId, 500, "Internal Server Error");
+    } finally {
+      const actor2 = this.#runner.getActor(req.actorId);
+      if (actor2) {
+        actor2.requests.delete(requestIdStr);
+      }
+    }
+  }
+  async #handleRequestChunk(requestId, chunk) {
+    const requestIdStr = bufferToString(requestId);
+    const pending = this.#actorPendingRequests.get(requestIdStr);
+    if (pending == null ? void 0 : pending.streamController) {
+      pending.streamController.enqueue(new Uint8Array(chunk.body));
+      if (chunk.finish) {
+        pending.streamController.close();
+        this.#actorPendingRequests.delete(requestIdStr);
+      }
+    }
+  }
+  async #handleRequestAbort(requestId) {
+    const requestIdStr = bufferToString(requestId);
+    const pending = this.#actorPendingRequests.get(requestIdStr);
+    if (pending == null ? void 0 : pending.streamController) {
+      pending.streamController.error(new Error("Request aborted"));
+    }
+    this.#actorPendingRequests.delete(requestIdStr);
+  }
+  async #sendResponse(requestId, response) {
+    const body = response.body ? await response.arrayBuffer() : null;
+    const headers = /* @__PURE__ */ new Map();
+    response.headers.forEach((value, key) => {
+      headers.set(key, value);
+    });
+    if (body && !headers.has("content-length")) {
+      headers.set("content-length", String(body.byteLength));
+    }
+    this.#sendMessage(requestId, {
+      tag: "ToServerResponseStart",
+      val: {
+        status: response.status,
+        headers,
+        body: body || null,
+        stream: false
+      }
+    });
+  }
+  #sendResponseError(requestId, status, message) {
+    const headers = /* @__PURE__ */ new Map();
+    headers.set("content-type", "text/plain");
+    this.#sendMessage(requestId, {
+      tag: "ToServerResponseStart",
+      val: {
+        status,
+        headers,
+        body: new TextEncoder().encode(message).buffer,
+        stream: false
+      }
+    });
+  }
+  async #handleWebSocketOpen(requestId, open) {
+    var _a, _b, _c;
+    const webSocketId = bufferToString(requestId);
+    const actor = this.#runner.getActor(open.actorId);
+    if (!actor) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "ignoring websocket for unknown actor",
+        actorId: open.actorId
+      });
+      this.#sendMessage(requestId, {
+        tag: "ToServerWebSocketClose",
+        val: {
+          code: 1011,
+          reason: "Actor not found"
+        }
+      });
+      return;
+    }
+    const websocketHandler = this.#runner.config.websocket;
+    if (!websocketHandler) {
+      (_b = logger()) == null ? void 0 : _b.error({
+        msg: "no websocket handler configured for tunnel"
+      });
+      this.#sendMessage(requestId, {
+        tag: "ToServerWebSocketClose",
+        val: {
+          code: 1011,
+          reason: "Not Implemented"
+        }
+      });
+      return;
+    }
+    if (actor) {
+      actor.webSockets.add(webSocketId);
+    }
+    try {
+      const adapter = new WebSocketTunnelAdapter(
+        webSocketId,
+        (data, isBinary) => {
+          const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data).buffer : data;
+          this.#sendMessage(requestId, {
+            tag: "ToServerWebSocketMessage",
+            val: {
+              data: dataBuffer,
+              binary: isBinary
+            }
+          });
+        },
+        (code, reason) => {
+          this.#sendMessage(requestId, {
+            tag: "ToServerWebSocketClose",
+            val: {
+              code: code || null,
+              reason: reason || null
+            }
+          });
+          this.#actorWebSockets.delete(webSocketId);
+          if (actor) {
+            actor.webSockets.delete(webSocketId);
+          }
+        }
+      );
+      this.#actorWebSockets.set(webSocketId, adapter);
+      this.#sendMessage(requestId, {
+        tag: "ToServerWebSocketOpen",
+        val: null
+      });
+      adapter._handleOpen();
+      const headerInit = {};
+      if (open.headers) {
+        for (const [k, v] of open.headers) {
+          headerInit[k] = v;
+        }
+      }
+      headerInit["Upgrade"] = "websocket";
+      headerInit["Connection"] = "Upgrade";
+      const request = new Request(`http://localhost${open.path}`, {
+        method: "GET",
+        headers: headerInit
+      });
+      await websocketHandler(
+        this.#runner,
+        open.actorId,
+        adapter,
+        request
+      );
+    } catch (error) {
+      (_c = logger()) == null ? void 0 : _c.error({ msg: "error handling websocket open", error });
+      this.#sendMessage(requestId, {
+        tag: "ToServerWebSocketClose",
+        val: {
+          code: 1011,
+          reason: "Server Error"
+        }
+      });
+      this.#actorWebSockets.delete(webSocketId);
+      if (actor) {
+        actor.webSockets.delete(webSocketId);
+      }
+    }
+  }
+  async #handleWebSocketMessage(requestId, msg) {
+    const webSocketId = bufferToString(requestId);
+    const adapter = this.#actorWebSockets.get(webSocketId);
+    if (adapter) {
+      const data = msg.binary ? new Uint8Array(msg.data) : new TextDecoder().decode(new Uint8Array(msg.data));
+      adapter._handleMessage(data, msg.binary);
+    }
+  }
+  async #handleWebSocketClose(requestId, close) {
+    const webSocketId = bufferToString(requestId);
+    const adapter = this.#actorWebSockets.get(webSocketId);
+    if (adapter) {
+      adapter._handleClose(
+        close.code || void 0,
+        close.reason || void 0
+      );
+      this.#actorWebSockets.delete(webSocketId);
+    }
+  }
+};
+function bufferToString(buffer) {
+  return Buffer.from(buffer).toString("base64");
+}
+function generateUuidBuffer() {
+  const buffer = new Uint8Array(16);
+  uuidv4(void 0, buffer);
+  return buffer.buffer;
+}
+
+// src/websocket.ts
+var webSocketPromise = null;
+async function importWebSocket() {
+  if (webSocketPromise !== null) {
+    return webSocketPromise;
+  }
+  webSocketPromise = (async () => {
+    var _a, _b, _c;
+    let _WebSocket;
+    if (typeof WebSocket !== "undefined") {
+      _WebSocket = WebSocket;
+      (_a = logger()) == null ? void 0 : _a.debug({ msg: "using native websocket" });
+    } else {
+      try {
+        const ws = await import("ws");
+        _WebSocket = ws.default;
+        (_b = logger()) == null ? void 0 : _b.debug({ msg: "using websocket from npm" });
+      } catch {
+        _WebSocket = class MockWebSocket {
+          constructor() {
+            throw new Error(
+              'WebSocket support requires installing the "ws" peer dependency.'
+            );
+          }
+        };
+        (_c = logger()) == null ? void 0 : _c.debug({ msg: "using mock websocket" });
+      }
+    }
+    return _WebSocket;
+  })();
+  return webSocketPromise;
+}
+
+// src/mod.ts
+var KV_EXPIRE = 3e4;
+var PROTOCOL_VERSION = 1;
+var EVENT_BACKLOG_WARN_THRESHOLD = 1e4;
+var SIGNAL_HANDLERS = [];
+var Runner = class {
+  #config;
+  get config() {
+    return this.#config;
+  }
+  #actors = /* @__PURE__ */ new Map();
+  #actorWebSockets = /* @__PURE__ */ new Map();
+  // WebSocket
+  #pegboardWebSocket;
+  runnerId;
+  #lastCommandIdx = -1;
+  #pingLoop;
+  #nextEventIdx = 0n;
+  #started = false;
+  #shutdown = false;
+  #reconnectAttempt = 0;
+  #reconnectTimeout;
+  // Runner lost threshold management
+  #runnerLostThreshold;
+  #runnerLostTimeout;
+  // Event storage for resending
+  #eventHistory = [];
+  #eventBacklogWarned = false;
+  // Command acknowledgment
+  #ackInterval;
+  // KV operations
+  #nextRequestId = 0;
+  #kvRequests = /* @__PURE__ */ new Map();
+  #kvCleanupInterval;
+  // Tunnel for HTTP/WebSocket forwarding
+  #tunnel;
+  constructor(config) {
+    this.#config = config;
+    if (this.#config.logger) setLogger(this.#config.logger);
+    this.#kvCleanupInterval = setInterval(() => {
+      this.#cleanupOldKvRequests();
+    }, 15e3);
+  }
+  // MARK: Manage actors
+  sleepActor(actorId, generation) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    this.#sendActorIntent(actorId, actor.generation, "sleep");
+  }
+  async stopActor(actorId, generation) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    this.#sendActorIntent(actorId, actor.generation, "stop");
+  }
+  async forceStopActor(actorId, generation) {
+    var _a;
+    const actor = this.#removeActor(actorId, generation);
+    if (!actor) return;
+    (_a = this.#tunnel) == null ? void 0 : _a.unregisterActor(actor);
+    try {
+      await this.#config.onActorStop(actorId, actor.generation);
+    } catch (err) {
+      console.error(`Error in onActorStop for actor ${actorId}:`, err);
+    }
+    this.#sendActorStateUpdate(actorId, actor.generation, "stopped");
+    this.#config.onActorStop(actorId, actor.generation).catch((err) => {
+      var _a2;
+      (_a2 = logger()) == null ? void 0 : _a2.error({
+        msg: "error in onactorstop for actor",
+        runnerId: this.runnerId,
+        actorId,
+        err
+      });
+    });
+  }
+  #stopAllActors() {
+    var _a;
+    (_a = logger()) == null ? void 0 : _a.info({
+      msg: "stopping all actors due to runner lost threshold exceeded",
+      runnerId: this.runnerId
+    });
+    const actorIds = Array.from(this.#actors.keys());
+    for (const actorId of actorIds) {
+      this.forceStopActor(actorId);
+    }
+  }
+  getActor(actorId, generation) {
+    var _a, _b;
+    const actor = this.#actors.get(actorId);
+    if (!actor) {
+      (_a = logger()) == null ? void 0 : _a.error({
+        msg: "actor not found",
+        runnerId: this.runnerId,
+        actorId
+      });
+      return void 0;
+    }
+    if (generation !== void 0 && actor.generation !== generation) {
+      (_b = logger()) == null ? void 0 : _b.error({
+        msg: "actor generation mismatch",
+        runnerId: this.runnerId,
+        actorId,
+        generation
+      });
+      return void 0;
+    }
+    return actor;
+  }
+  hasActor(actorId, generation) {
+    const actor = this.#actors.get(actorId);
+    return !!actor && (generation === void 0 || actor.generation === generation);
+  }
+  #removeActor(actorId, generation) {
+    var _a, _b, _c;
+    const actor = this.#actors.get(actorId);
+    if (!actor) {
+      (_a = logger()) == null ? void 0 : _a.error({
+        msg: "actor not found for removal",
+        runnerId: this.runnerId,
+        actorId
+      });
+      return void 0;
+    }
+    if (generation !== void 0 && actor.generation !== generation) {
+      (_b = logger()) == null ? void 0 : _b.error({
+        msg: "actor generation mismatch",
+        runnerId: this.runnerId,
+        actorId,
+        generation
+      });
+      return void 0;
+    }
+    this.#actors.delete(actorId);
+    const actorWebSockets = this.#actorWebSockets.get(actorId);
+    if (actorWebSockets) {
+      for (const ws of actorWebSockets) {
+        try {
+          ws.close(1e3, "Actor stopped");
+        } catch (err) {
+          (_c = logger()) == null ? void 0 : _c.error({
+            msg: "error closing websocket for actor",
+            runnerId: this.runnerId,
+            actorId,
+            err
+          });
+        }
+      }
+      this.#actorWebSockets.delete(actorId);
+    }
+    return actor;
+  }
+  // MARK: Start
+  async start() {
+    var _a, _b;
+    if (this.#started) throw new Error("Cannot call runner.start twice");
+    this.#started = true;
+    (_a = logger()) == null ? void 0 : _a.info({ msg: "starting runner" });
+    this.#tunnel = new Tunnel(this);
+    this.#tunnel.start();
+    try {
+      await this.#openPegboardWebSocket();
+    } catch (error) {
+      this.#started = false;
+      throw error;
+    }
+    if (!this.#config.noAutoShutdown) {
+      if (!SIGNAL_HANDLERS.length) {
+        process.on("SIGTERM", () => {
+          var _a2;
+          (_a2 = logger()) == null ? void 0 : _a2.debug("received SIGTERM");
+          for (const handler of SIGNAL_HANDLERS) {
+            handler();
+          }
+          process.exit(0);
+        });
+        process.on("SIGINT", () => {
+          var _a2;
+          (_a2 = logger()) == null ? void 0 : _a2.debug("received SIGINT");
+          for (const handler of SIGNAL_HANDLERS) {
+            handler();
+          }
+          process.exit(0);
+        });
+        (_b = logger()) == null ? void 0 : _b.debug({
+          msg: "added SIGTERM listeners"
+        });
+      }
+      SIGNAL_HANDLERS.push(() => {
+        var _a2;
+        const weak = new WeakRef(this);
+        (_a2 = weak.deref()) == null ? void 0 : _a2.shutdown(false, false);
+      });
+    }
+  }
+  // MARK: Shutdown
+  async shutdown(immediate, exit = false) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    (_a = logger()) == null ? void 0 : _a.info({
+      msg: "starting shutdown",
+      runnerId: this.runnerId,
+      immediate,
+      exit
+    });
+    this.#shutdown = true;
+    if (this.#reconnectTimeout) {
+      clearTimeout(this.#reconnectTimeout);
+      this.#reconnectTimeout = void 0;
+    }
+    if (this.#runnerLostTimeout) {
+      clearTimeout(this.#runnerLostTimeout);
+      this.#runnerLostTimeout = void 0;
+    }
+    if (this.#pingLoop) {
+      clearInterval(this.#pingLoop);
+      this.#pingLoop = void 0;
+    }
+    if (this.#ackInterval) {
+      clearInterval(this.#ackInterval);
+      this.#ackInterval = void 0;
+    }
+    if (this.#kvCleanupInterval) {
+      clearInterval(this.#kvCleanupInterval);
+      this.#kvCleanupInterval = void 0;
+    }
+    for (const request of this.#kvRequests.values()) {
+      request.reject(
+        new Error("WebSocket connection closed during shutdown")
+      );
+    }
+    this.#kvRequests.clear();
+    if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
+      const pegboardWebSocket = this.#pegboardWebSocket;
+      if (immediate) {
+        pegboardWebSocket.close(1e3, "Stopping");
+      } else {
+        try {
+          (_b = logger()) == null ? void 0 : _b.info({
+            msg: "sending stopping message",
+            runnerId: this.runnerId,
+            readyState: pegboardWebSocket.readyState
+          });
+          const encoded = protocol.encodeToServer({
+            tag: "ToServerStopping",
+            val: null
+          });
+          if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
+            this.#pegboardWebSocket.send(encoded);
+          } else {
+            (_c = logger()) == null ? void 0 : _c.error(
+              "WebSocket not available or not open for sending data"
+            );
+          }
+          const closePromise = new Promise((resolve) => {
+            if (!pegboardWebSocket)
+              throw new Error("missing pegboardWebSocket");
+            pegboardWebSocket.addEventListener("close", (ev) => {
+              var _a2;
+              (_a2 = logger()) == null ? void 0 : _a2.info({
+                msg: "connection closed",
+                runnerId: this.runnerId,
+                code: ev.code,
+                reason: ev.reason.toString()
+              });
+              resolve();
+            });
+          });
+          (_d = logger()) == null ? void 0 : _d.info({
+            msg: "closing WebSocket",
+            runnerId: this.runnerId
+          });
+          pegboardWebSocket.close(1e3, "Stopping");
+          await closePromise;
+          (_e = logger()) == null ? void 0 : _e.info({
+            msg: "websocket shutdown completed",
+            runnerId: this.runnerId
+          });
+        } catch (error) {
+          (_f = logger()) == null ? void 0 : _f.error({
+            msg: "error during websocket shutdown:",
+            runnerId: this.runnerId,
+            error
+          });
+          pegboardWebSocket.close();
+        }
+      }
+    } else {
+      (_h = logger()) == null ? void 0 : _h.warn({
+        msg: "no runner WebSocket to shutdown or already closed",
+        runnerId: this.runnerId,
+        readyState: (_g = this.#pegboardWebSocket) == null ? void 0 : _g.readyState
+      });
+    }
+    if (this.#tunnel) {
+      this.#tunnel.shutdown();
+      this.#tunnel = void 0;
+    }
+    if (exit) process.exit(0);
+    this.#config.onShutdown();
+  }
+  // MARK: Networking
+  get pegboardUrl() {
+    const endpoint = this.#config.pegboardEndpoint || this.#config.endpoint;
+    const wsEndpoint = endpoint.replace("http://", "ws://").replace("https://", "wss://");
+    return `${wsEndpoint}?protocol_version=${PROTOCOL_VERSION}&namespace=${encodeURIComponent(this.#config.namespace)}&runner_key=${encodeURIComponent(this.#config.runnerKey)}`;
+  }
+  // MARK: Runner protocol
+  async #openPegboardWebSocket() {
+    const protocols = ["rivet", `rivet_target.runner`];
+    if (this.config.token)
+      protocols.push(`rivet_token.${this.config.token}`);
+    const WS = await importWebSocket();
+    const ws = new WS(this.pegboardUrl, protocols);
+    this.#pegboardWebSocket = ws;
+    ws.addEventListener("open", () => {
+      var _a;
+      (_a = logger()) == null ? void 0 : _a.info({ msg: "Connected" });
+      this.#reconnectAttempt = 0;
+      if (this.#reconnectTimeout) {
+        clearTimeout(this.#reconnectTimeout);
+        this.#reconnectTimeout = void 0;
+      }
+      if (this.#runnerLostTimeout) {
+        clearTimeout(this.#runnerLostTimeout);
+        this.#runnerLostTimeout = void 0;
+      }
+      const init = {
+        name: this.#config.runnerName,
+        version: this.#config.version,
+        totalSlots: this.#config.totalSlots,
+        lastCommandIdx: this.#lastCommandIdx >= 0 ? BigInt(this.#lastCommandIdx) : null,
+        prepopulateActorNames: new Map(
+          Object.entries(this.#config.prepopulateActorNames).map(
+            ([name, data]) => [
+              name,
+              { metadata: JSON.stringify(data.metadata) }
+            ]
+          )
+        ),
+        metadata: JSON.stringify(this.#config.metadata)
+      };
+      this.__sendToServer({
+        tag: "ToServerInit",
+        val: init
+      });
+      this.#processUnsentKvRequests();
+      const pingInterval = 1e3;
+      const pingLoop = setInterval(() => {
+        var _a2;
+        if (ws.readyState === 1) {
+          this.__sendToServer({
+            tag: "ToServerPing",
+            val: {
+              ts: BigInt(Date.now())
+            }
+          });
+        } else {
+          clearInterval(pingLoop);
+          (_a2 = logger()) == null ? void 0 : _a2.info({
+            msg: "WebSocket not open, stopping ping loop",
+            runnerId: this.runnerId
+          });
+        }
+      }, pingInterval);
+      this.#pingLoop = pingLoop;
+      const ackInterval = 5 * 60 * 1e3;
+      const ackLoop = setInterval(() => {
+        var _a2;
+        if (ws.readyState === 1) {
+          this.#sendCommandAcknowledgment();
+        } else {
+          clearInterval(ackLoop);
+          (_a2 = logger()) == null ? void 0 : _a2.info({
+            msg: "WebSocket not open, stopping ack loop",
+            runnerId: this.runnerId
+          });
+        }
+      }, ackInterval);
+      this.#ackInterval = ackLoop;
+    });
+    ws.addEventListener("message", async (ev) => {
+      var _a, _b, _c, _d;
+      let buf;
+      if (ev.data instanceof Blob) {
+        buf = new Uint8Array(await ev.data.arrayBuffer());
+      } else if (Buffer.isBuffer(ev.data)) {
+        buf = new Uint8Array(ev.data);
+      } else {
+        throw new Error(`expected binary data, got ${typeof ev.data}`);
+      }
+      const message = protocol.decodeToClient(buf);
+      if (message.tag === "ToClientInit") {
+        const init = message.val;
+        if (this.runnerId !== init.runnerId) {
+          this.runnerId = init.runnerId;
+          this.#eventHistory.length = 0;
+        }
+        this.#runnerLostThreshold = ((_a = init.metadata) == null ? void 0 : _a.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
+        (_b = logger()) == null ? void 0 : _b.info({
+          msg: "received init",
+          runnerId: init.runnerId,
+          lastEventIdx: init.lastEventIdx,
+          runnerLostThreshold: this.#runnerLostThreshold
+        });
+        this.#resendUnacknowledgedEvents(init.lastEventIdx);
+        this.#config.onConnected();
+      } else if (message.tag === "ToClientCommands") {
+        const commands = message.val;
+        this.#handleCommands(commands);
+      } else if (message.tag === "ToClientAckEvents") {
+        this.#handleAckEvents(message.val);
+      } else if (message.tag === "ToClientKvResponse") {
+        const kvResponse = message.val;
+        this.#handleKvResponse(kvResponse);
+      } else if (message.tag === "ToClientTunnelMessage") {
+        (_c = this.#tunnel) == null ? void 0 : _c.handleTunnelMessage(message.val);
+      } else if (message.tag === "ToClientClose") {
+        (_d = this.#tunnel) == null ? void 0 : _d.shutdown();
+        ws.close(1e3, "manual closure");
+      } else {
+        unreachable(message);
+      }
+    });
+    ws.addEventListener("error", (ev) => {
+      var _a, _b;
+      (_a = logger()) == null ? void 0 : _a.error({
+        msg: `WebSocket error: ${ev.error}`,
+        runnerId: this.runnerId
+      });
+      if (!this.#shutdown) {
+        if (!this.#runnerLostTimeout && this.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
+          (_b = logger()) == null ? void 0 : _b.info({
+            msg: "starting runner lost timeout",
+            runnerId: this.runnerId,
+            seconds: this.#runnerLostThreshold / 1e3
+          });
+          this.#runnerLostTimeout = setTimeout(() => {
+            this.#stopAllActors();
+          }, this.#runnerLostThreshold);
+        }
+        this.#scheduleReconnect();
+      }
+    });
+    ws.addEventListener("close", async (ev) => {
+      var _a, _b, _c;
+      (_a = logger()) == null ? void 0 : _a.info({
+        msg: "connection closed",
+        runnerId: this.runnerId,
+        code: ev.code,
+        reason: ev.reason.toString()
+      });
+      this.#config.onDisconnected();
+      if (ev.reason.toString().startsWith("ws.eviction")) {
+        (_b = logger()) == null ? void 0 : _b.info({
+          msg: "runner evicted",
+          runnerId: this.runnerId
+        });
+        await this.shutdown(true);
+      }
+      if (this.#pingLoop) {
+        clearInterval(this.#pingLoop);
+        this.#pingLoop = void 0;
+      }
+      if (this.#ackInterval) {
+        clearInterval(this.#ackInterval);
+        this.#ackInterval = void 0;
+      }
+      if (!this.#shutdown) {
+        if (!this.#runnerLostTimeout && this.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
+          (_c = logger()) == null ? void 0 : _c.info({
+            msg: "starting runner lost timeout",
+            runnerId: this.runnerId,
+            seconds: this.#runnerLostThreshold / 1e3
+          });
+          this.#runnerLostTimeout = setTimeout(() => {
+            this.#stopAllActors();
+          }, this.#runnerLostThreshold);
+        }
+        this.#scheduleReconnect();
+      }
+    });
+  }
+  #handleCommands(commands) {
+    var _a, _b;
+    (_a = logger()) == null ? void 0 : _a.info({
+      msg: "received commands",
+      runnerId: this.runnerId,
+      commandCount: commands.length
+    });
+    for (const commandWrapper of commands) {
+      (_b = logger()) == null ? void 0 : _b.info({
+        msg: "received command",
+        runnerId: this.runnerId,
+        commandWrapper
+      });
+      if (commandWrapper.inner.tag === "CommandStartActor") {
+        this.#handleCommandStartActor(commandWrapper);
+      } else if (commandWrapper.inner.tag === "CommandStopActor") {
+        this.#handleCommandStopActor(commandWrapper);
+      } else {
+        unreachable(commandWrapper.inner);
+      }
+      this.#lastCommandIdx = Number(commandWrapper.index);
+    }
+  }
+  #handleAckEvents(ack) {
+    var _a;
+    const lastAckedIdx = ack.lastEventIdx;
+    const originalLength = this.#eventHistory.length;
+    this.#eventHistory = this.#eventHistory.filter(
+      (event) => event.index > lastAckedIdx
+    );
+    const prunedCount = originalLength - this.#eventHistory.length;
+    if (prunedCount > 0) {
+      (_a = logger()) == null ? void 0 : _a.info({
+        msg: "pruned acknowledged events",
+        runnerId: this.runnerId,
+        lastAckedIdx: lastAckedIdx.toString(),
+        prunedCount
+      });
+    }
+    if (this.#eventHistory.length <= EVENT_BACKLOG_WARN_THRESHOLD) {
+      this.#eventBacklogWarned = false;
+    }
+  }
+  /** Track events to send to the server in case we need to resend it on disconnect. */
+  #recordEvent(eventWrapper) {
+    var _a;
+    this.#eventHistory.push(eventWrapper);
+    if (this.#eventHistory.length > EVENT_BACKLOG_WARN_THRESHOLD && !this.#eventBacklogWarned) {
+      this.#eventBacklogWarned = true;
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "unacknowledged event backlog exceeds threshold",
+        runnerId: this.runnerId,
+        backlogSize: this.#eventHistory.length,
+        threshold: EVENT_BACKLOG_WARN_THRESHOLD
+      });
+    }
+  }
+  #handleCommandStartActor(commandWrapper) {
+    const startCommand = commandWrapper.inner.val;
+    const actorId = startCommand.actorId;
+    const generation = startCommand.generation;
+    const config = startCommand.config;
+    const actorConfig = {
+      name: config.name,
+      key: config.key,
+      createTs: config.createTs,
+      input: config.input ? new Uint8Array(config.input) : null
+    };
+    const instance = {
+      actorId,
+      generation,
+      config: actorConfig,
+      requests: /* @__PURE__ */ new Set(),
+      webSockets: /* @__PURE__ */ new Set()
+    };
+    this.#actors.set(actorId, instance);
+    this.#sendActorStateUpdate(actorId, generation, "running");
+    this.#config.onActorStart(actorId, generation, actorConfig).catch((err) => {
+      var _a;
+      (_a = logger()) == null ? void 0 : _a.error({
+        msg: "error in onactorstart for actor",
+        runnerId: this.runnerId,
+        actorId,
+        err
+      });
+      this.forceStopActor(actorId, generation);
+    });
+  }
+  #handleCommandStopActor(commandWrapper) {
+    const stopCommand = commandWrapper.inner.val;
+    const actorId = stopCommand.actorId;
+    const generation = stopCommand.generation;
+    this.forceStopActor(actorId, generation);
+  }
+  #sendActorIntent(actorId, generation, intentType) {
+    var _a, _b;
+    if (this.#shutdown) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "Runner is shut down, cannot send actor intent",
+        runnerId: this.runnerId
+      });
+      return;
+    }
+    let actorIntent;
+    if (intentType === "sleep") {
+      actorIntent = { tag: "ActorIntentSleep", val: null };
+    } else if (intentType === "stop") {
+      actorIntent = {
+        tag: "ActorIntentStop",
+        val: null
+      };
+    } else {
+      unreachable(intentType);
+    }
+    const intentEvent = {
+      actorId,
+      generation,
+      intent: actorIntent
+    };
+    const eventIndex = this.#nextEventIdx++;
+    const eventWrapper = {
+      index: eventIndex,
+      inner: {
+        tag: "EventActorIntent",
+        val: intentEvent
+      }
+    };
+    this.#recordEvent(eventWrapper);
+    (_b = logger()) == null ? void 0 : _b.info({
+      msg: "sending event to server",
+      runnerId: this.runnerId,
+      index: eventWrapper.index,
+      tag: eventWrapper.inner.tag,
+      val: eventWrapper.inner.val
+    });
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: [eventWrapper]
+    });
+  }
+  #sendActorStateUpdate(actorId, generation, stateType) {
+    var _a, _b;
+    if (this.#shutdown) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "Runner is shut down, cannot send actor state update",
+        runnerId: this.runnerId
+      });
+      return;
+    }
+    let actorState;
+    if (stateType === "running") {
+      actorState = { tag: "ActorStateRunning", val: null };
+    } else if (stateType === "stopped") {
+      actorState = {
+        tag: "ActorStateStopped",
+        val: {
+          code: protocol.StopCode.Ok,
+          message: null
+        }
+      };
+    } else {
+      unreachable(stateType);
+    }
+    const stateUpdateEvent = {
+      actorId,
+      generation,
+      state: actorState
+    };
+    const eventIndex = this.#nextEventIdx++;
+    const eventWrapper = {
+      index: eventIndex,
+      inner: {
+        tag: "EventActorStateUpdate",
+        val: stateUpdateEvent
+      }
+    };
+    this.#recordEvent(eventWrapper);
+    (_b = logger()) == null ? void 0 : _b.info({
+      msg: "sending event to server",
+      runnerId: this.runnerId,
+      index: eventWrapper.index,
+      tag: eventWrapper.inner.tag,
+      val: eventWrapper.inner.val
+    });
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: [eventWrapper]
+    });
+  }
+  #sendCommandAcknowledgment() {
+    var _a;
+    if (this.#shutdown) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "Runner is shut down, cannot send command acknowledgment",
+        runnerId: this.runnerId
+      });
+      return;
+    }
+    if (this.#lastCommandIdx < 0) {
+      return;
+    }
+    this.__sendToServer({
+      tag: "ToServerAckCommands",
+      val: {
+        lastCommandIdx: BigInt(this.#lastCommandIdx)
+      }
+    });
+  }
+  #handleKvResponse(response) {
+    var _a;
+    const requestId = response.requestId;
+    const request = this.#kvRequests.get(requestId);
+    if (!request) {
+      const msg = "received kv response for unknown request id";
+      (_a = logger()) == null ? void 0 : _a.error({ msg, runnerId: this.runnerId, requestId });
+      return;
+    }
+    this.#kvRequests.delete(requestId);
+    if (response.data.tag === "KvErrorResponse") {
+      request.reject(
+        new Error(response.data.val.message || "Unknown KV error")
+      );
+    } else {
+      request.resolve(response.data.val);
+    }
+  }
+  #parseGetResponseSimple(response, requestedKeys) {
+    const responseKeys = [];
+    const responseValues = [];
+    for (const key of response.keys) {
+      responseKeys.push(new Uint8Array(key));
+    }
+    for (const value of response.values) {
+      responseValues.push(new Uint8Array(value));
+    }
+    const result = [];
+    for (const requestedKey of requestedKeys) {
+      let found = false;
+      for (let i = 0; i < responseKeys.length; i++) {
+        if (this.#keysEqual(requestedKey, responseKeys[i])) {
+          result.push(responseValues[i]);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        result.push(null);
+      }
+    }
+    return result;
+  }
+  #keysEqual(key1, key2) {
+    if (key1.length !== key2.length) return false;
+    for (let i = 0; i < key1.length; i++) {
+      if (key1[i] !== key2[i]) return false;
+    }
+    return true;
+  }
+  //#parseGetResponse(response: protocol.KvGetResponse) {
+  //	const keys: string[] = [];
+  //	const values: Uint8Array[] = [];
+  //	const metadata: { version: Uint8Array; createTs: bigint }[] = [];
+  //
+  //	for (const key of response.keys) {
+  //		keys.push(new TextDecoder().decode(key));
+  //	}
+  //
+  //	for (const value of response.values) {
+  //		values.push(new Uint8Array(value));
+  //	}
+  //
+  //	for (const meta of response.metadata) {
+  //		metadata.push({
+  //			version: new Uint8Array(meta.version),
+  //			createTs: meta.createTs,
+  //		});
+  //	}
+  //
+  //	return { keys, values, metadata };
+  //}
+  #parseListResponseSimple(response) {
+    const result = [];
+    for (let i = 0; i < response.keys.length; i++) {
+      const key = response.keys[i];
+      const value = response.values[i];
+      if (key && value) {
+        const keyBytes = new Uint8Array(key);
+        const valueBytes = new Uint8Array(value);
+        result.push([keyBytes, valueBytes]);
+      }
+    }
+    return result;
+  }
+  //#parseListResponse(response: protocol.KvListResponse) {
+  //	const keys: string[] = [];
+  //	const values: Uint8Array[] = [];
+  //	const metadata: { version: Uint8Array; createTs: bigint }[] = [];
+  //
+  //	for (const key of response.keys) {
+  //		keys.push(new TextDecoder().decode(key));
+  //	}
+  //
+  //	for (const value of response.values) {
+  //		values.push(new Uint8Array(value));
+  //	}
+  //
+  //	for (const meta of response.metadata) {
+  //		metadata.push({
+  //			version: new Uint8Array(meta.version),
+  //			createTs: meta.createTs,
+  //		});
+  //	}
+  //
+  //	return { keys, values, metadata };
+  //}
+  // MARK: KV Operations
+  async kvGet(actorId, keys) {
+    const kvKeys = keys.map(
+      (key) => key.buffer.slice(
+        key.byteOffset,
+        key.byteOffset + key.byteLength
+      )
+    );
+    const requestData = {
+      tag: "KvGetRequest",
+      val: { keys: kvKeys }
+    };
+    const response = await this.#sendKvRequest(actorId, requestData);
+    return this.#parseGetResponseSimple(response, keys);
+  }
+  async kvListAll(actorId, options) {
+    const requestData = {
+      tag: "KvListRequest",
+      val: {
+        query: { tag: "KvListAllQuery", val: null },
+        reverse: (options == null ? void 0 : options.reverse) || null,
+        limit: (options == null ? void 0 : options.limit) !== void 0 ? BigInt(options.limit) : null
+      }
+    };
+    const response = await this.#sendKvRequest(actorId, requestData);
+    return this.#parseListResponseSimple(response);
+  }
+  async kvListRange(actorId, start, end, exclusive, options) {
+    const startKey = start.buffer.slice(
+      start.byteOffset,
+      start.byteOffset + start.byteLength
+    );
+    const endKey = end.buffer.slice(
+      end.byteOffset,
+      end.byteOffset + end.byteLength
+    );
+    const requestData = {
+      tag: "KvListRequest",
+      val: {
+        query: {
+          tag: "KvListRangeQuery",
+          val: {
+            start: startKey,
+            end: endKey,
+            exclusive: exclusive || false
+          }
+        },
+        reverse: (options == null ? void 0 : options.reverse) || null,
+        limit: (options == null ? void 0 : options.limit) !== void 0 ? BigInt(options.limit) : null
+      }
+    };
+    const response = await this.#sendKvRequest(actorId, requestData);
+    return this.#parseListResponseSimple(response);
+  }
+  async kvListPrefix(actorId, prefix, options) {
+    const prefixKey = prefix.buffer.slice(
+      prefix.byteOffset,
+      prefix.byteOffset + prefix.byteLength
+    );
+    const requestData = {
+      tag: "KvListRequest",
+      val: {
+        query: {
+          tag: "KvListPrefixQuery",
+          val: { key: prefixKey }
+        },
+        reverse: (options == null ? void 0 : options.reverse) || null,
+        limit: (options == null ? void 0 : options.limit) !== void 0 ? BigInt(options.limit) : null
+      }
+    };
+    const response = await this.#sendKvRequest(actorId, requestData);
+    return this.#parseListResponseSimple(response);
+  }
+  async kvPut(actorId, entries) {
+    const keys = entries.map(
+      ([key, _value]) => key.buffer.slice(
+        key.byteOffset,
+        key.byteOffset + key.byteLength
+      )
+    );
+    const values = entries.map(
+      ([_key, value]) => value.buffer.slice(
+        value.byteOffset,
+        value.byteOffset + value.byteLength
+      )
+    );
+    const requestData = {
+      tag: "KvPutRequest",
+      val: { keys, values }
+    };
+    await this.#sendKvRequest(actorId, requestData);
+  }
+  async kvDelete(actorId, keys) {
+    const kvKeys = keys.map(
+      (key) => key.buffer.slice(
+        key.byteOffset,
+        key.byteOffset + key.byteLength
+      )
+    );
+    const requestData = {
+      tag: "KvDeleteRequest",
+      val: { keys: kvKeys }
+    };
+    await this.#sendKvRequest(actorId, requestData);
+  }
+  async kvDrop(actorId) {
+    const requestData = {
+      tag: "KvDropRequest",
+      val: null
+    };
+    await this.#sendKvRequest(actorId, requestData);
+  }
+  // MARK: Alarm Operations
+  setAlarm(actorId, alarmTs, generation) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    if (this.#shutdown) {
+      console.warn("Runner is shut down, cannot set alarm");
+      return;
+    }
+    const alarmEvent = {
+      actorId,
+      generation: actor.generation,
+      alarmTs: alarmTs !== null ? BigInt(alarmTs) : null
+    };
+    const eventIndex = this.#nextEventIdx++;
+    const eventWrapper = {
+      index: eventIndex,
+      inner: {
+        tag: "EventActorSetAlarm",
+        val: alarmEvent
+      }
+    };
+    this.#recordEvent(eventWrapper);
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: [eventWrapper]
+    });
+  }
+  clearAlarm(actorId, generation) {
+    this.setAlarm(actorId, null, generation);
+  }
+  #sendKvRequest(actorId, requestData) {
+    return new Promise((resolve, reject) => {
+      if (this.#shutdown) {
+        reject(new Error("Runner is shut down"));
+        return;
+      }
+      const requestId = this.#nextRequestId++;
+      const isConnected = this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1;
+      const requestEntry = {
+        actorId,
+        data: requestData,
+        resolve,
+        reject,
+        sent: false,
+        timestamp: Date.now()
+      };
+      this.#kvRequests.set(requestId, requestEntry);
+      if (isConnected) {
+        this.#sendSingleKvRequest(requestId);
+      }
+    });
+  }
+  #sendSingleKvRequest(requestId) {
+    const request = this.#kvRequests.get(requestId);
+    if (!request || request.sent) return;
+    try {
+      const kvRequest = {
+        actorId: request.actorId,
+        requestId,
+        data: request.data
+      };
+      this.__sendToServer({
+        tag: "ToServerKvRequest",
+        val: kvRequest
+      });
+      request.sent = true;
+      request.timestamp = Date.now();
+    } catch (error) {
+      this.#kvRequests.delete(requestId);
+      request.reject(error);
+    }
+  }
+  #processUnsentKvRequests() {
+    if (!this.#pegboardWebSocket || this.#pegboardWebSocket.readyState !== 1) {
+      return;
+    }
+    let processedCount = 0;
+    for (const [requestId, request] of this.#kvRequests.entries()) {
+      if (!request.sent) {
+        this.#sendSingleKvRequest(requestId);
+        processedCount++;
+      }
+    }
+    if (processedCount > 0) {
+    }
+  }
+  __webSocketReady() {
+    return this.#pegboardWebSocket ? this.#pegboardWebSocket.readyState === 1 : false;
+  }
+  __sendToServer(message) {
+    var _a, _b;
+    if (this.#shutdown) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "Runner is shut down, cannot send message to server",
+        runnerId: this.runnerId
+      });
+      return;
+    }
+    const encoded = protocol.encodeToServer(message);
+    if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
+      this.#pegboardWebSocket.send(encoded);
+    } else {
+      (_b = logger()) == null ? void 0 : _b.error({
+        msg: "WebSocket not available or not open for sending data",
+        runnerId: this.runnerId
+      });
+    }
+  }
+  getServerlessInitPacket() {
+    if (!this.runnerId) return void 0;
+    const data = protocol.encodeToServerlessServer({
+      tag: "ToServerlessServerInit",
+      val: {
+        runnerId: this.runnerId
+      }
+    });
+    const buffer = Buffer.alloc(data.length + 2);
+    buffer.writeUInt16LE(PROTOCOL_VERSION, 0);
+    Buffer.from(data).copy(buffer, 2);
+    return buffer.toString("base64");
+  }
+  #scheduleReconnect() {
+    var _a, _b;
+    if (this.#shutdown) {
+      (_a = logger()) == null ? void 0 : _a.debug({
+        msg: "Runner is shut down, not attempting reconnect",
+        runnerId: this.runnerId
+      });
+      return;
+    }
+    const delay = calculateBackoff(this.#reconnectAttempt, {
+      initialDelay: 1e3,
+      maxDelay: 3e4,
+      multiplier: 2,
+      jitter: true
+    });
+    (_b = logger()) == null ? void 0 : _b.debug({
+      msg: `Scheduling reconnect attempt ${this.#reconnectAttempt + 1} in ${delay}ms`,
+      runnerId: this.runnerId
+    });
+    this.#reconnectTimeout = setTimeout(async () => {
+      var _a2;
+      if (!this.#shutdown) {
+        this.#reconnectAttempt++;
+        (_a2 = logger()) == null ? void 0 : _a2.debug({
+          msg: `Attempting to reconnect (attempt ${this.#reconnectAttempt})...`,
+          runnerId: this.runnerId
+        });
+        await this.#openPegboardWebSocket();
+      }
+    }, delay);
+  }
+  #resendUnacknowledgedEvents(lastEventIdx) {
+    const eventsToResend = this.#eventHistory.filter(
+      (event) => event.index > lastEventIdx
+    );
+    if (eventsToResend.length === 0) return;
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: eventsToResend
+    });
+  }
+  #cleanupOldKvRequests() {
+    const thirtySecondsAgo = Date.now() - KV_EXPIRE;
+    const toDelete = [];
+    for (const [requestId, request] of this.#kvRequests.entries()) {
+      if (request.timestamp < thirtySecondsAgo) {
+        request.reject(
+          new Error(
+            "KV request timed out waiting for WebSocket connection"
+          )
+        );
+        toDelete.push(requestId);
+      }
+    }
+    for (const requestId of toDelete) {
+      this.#kvRequests.delete(requestId);
+    }
+    if (toDelete.length > 0) {
+    }
+  }
+};
+export {
+  Runner
+};
+//# sourceMappingURL=mod.js.map