@rivetkit/engine-runner 25.7.2-rc.1 → 25.7.3

package/dist/mod.cjs

@@ -1,1823 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } var _class;// src/log.ts
-var LOGGER = void 0;
-function setLogger(logger2) {
-  LOGGER = logger2;
-}
-function logger() {
-  return LOGGER;
-}
-
-// 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 Promise.resolve().then(() => _interopRequireWildcard(require("ws")));
-        _WebSocket = ws.default;
-        (_b = logger()) == null ? void 0 : _b.debug({ msg: "using websocket from npm" });
-      } catch (e) {
-        _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 _enginerunnerprotocol = require('@rivetkit/engine-runner-protocol'); var protocol = _interopRequireWildcard(_enginerunnerprotocol);
-
-// 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 * Math.pow(multiplier, attempt), maxDelay);
-  if (jitter) {
-    delay = delay * (1 + Math.random() * 0.25);
-  }
-  return Math.floor(delay);
-}
-
-// src/websocket-tunnel-adapter.ts
-var WebSocketTunnelAdapter = (_class = 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) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
-    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 __initStatic() {this.CONNECTING = 0}
-  static __initStatic2() {this.OPEN = 1}
-  static __initStatic3() {this.CLOSING = 2}
-  static __initStatic4() {this.CLOSED = 3}
-  // Instance constants
-  __init() {this.CONNECTING = 0}
-  __init2() {this.OPEN = 1}
-  __init3() {this.CLOSING = 2}
-  __init4() {this.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);
-  }
-}, _class.__initStatic(), _class.__initStatic2(), _class.__initStatic3(), _class.__initStatic4(), _class);
-
-// src/tunnel.ts
-var _uuid = require('uuid');
-var GC_INTERVAL = 6e4;
-var MESSAGE_ACK_TIMEOUT = 5e3;
-var Tunnel = class {
-  #runner;
-  #actorPendingRequests = /* @__PURE__ */ new Map();
-  #actorWebSockets = /* @__PURE__ */ new Map();
-  #pendingMessages = /* @__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) {
-    if (!this.#runner.__webSocketReady()) {
-      console.warn("Cannot send tunnel message, WebSocket not connected");
-      return;
-    }
-    const messageId = generateUuidBuffer();
-    const requestIdStr = bufferToString(requestId);
-    this.#pendingMessages.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() {
-    const now = Date.now();
-    const messagesToDelete = [];
-    for (const [messageId, pendingMessage] of this.#pendingMessages) {
-      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);
-        }
-      }
-    }
-    for (const messageId of messagesToDelete) {
-      this.#pendingMessages.delete(messageId);
-      console.warn(`Purged unacked message: ${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(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.#pendingMessages.get(msgIdStr);
-      if (pending) {
-        this.#pendingMessages.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) {
-      console.error("No websocket handler configured for tunnel");
-      (_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(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);
-  _uuid.v4.call(void 0, void 0, buffer);
-  return buffer.buffer;
-}
-
-// src/mod.ts
-var KV_EXPIRE = 3e4;
-var Runner = class {
-  #config;
-  get config() {
-    return this.#config;
-  }
-  #actors = /* @__PURE__ */ new Map();
-  #actorWebSockets = /* @__PURE__ */ new Map();
-  // WebSocket
-  #pegboardWebSocket;
-  
-  #lastCommandIdx = -1;
-  #pingLoop;
-  #nextEventIdx = 0n;
-  #started = false;
-  #shutdown = false;
-  #reconnectAttempt = 0;
-  #reconnectTimeout;
-  // Runner lost threshold management
-  #runnerLostThreshold;
-  #runnerLostTimeout;
-  // Event storage for resending
-  #eventHistory = [];
-  #eventPruneInterval;
-  // 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.#tunnel = new Tunnel(this);
-    this.#eventPruneInterval = setInterval(() => {
-      this.#pruneOldEvents();
-    }, 6e4);
-    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.#removeActor(actorId, generation);
-    if (!actor) return;
-    this.#tunnel.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 _a;
-      (_a = logger()) == null ? void 0 : _a.error({
-        msg: "error in onactorstop for actor",
-        actorId,
-        err
-      });
-    });
-  }
-  #stopAllActors() {
-    var _a;
-    (_a = logger()) == null ? void 0 : _a.info(
-      "stopping all actors due to runner lost threshold exceeded"
-    );
-    const actorIds = Array.from(this.#actors.keys());
-    for (const actorId of actorIds) {
-      this.stopActor(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", actorId });
-      return void 0;
-    }
-    if (generation !== void 0 && actor.generation !== generation) {
-      (_b = logger()) == null ? void 0 : _b.error({
-        msg: "actor generation mismatch",
-        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", actorId });
-      return void 0;
-    }
-    if (generation !== void 0 && actor.generation !== generation) {
-      (_b = logger()) == null ? void 0 : _b.error({
-        msg: "actor generation mismatch",
-        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",
-            actorId,
-            err
-          });
-        }
-      }
-      this.#actorWebSockets.delete(actorId);
-    }
-    return actor;
-  }
-  // MARK: Start
-  async start() {
-    var _a;
-    if (this.#started) throw new Error("Cannot call runner.start twice");
-    this.#started = true;
-    (_a = logger()) == null ? void 0 : _a.info("starting runner");
-    this.#tunnel.start();
-    try {
-      await this.#openPegboardWebSocket();
-    } catch (error) {
-      this.#started = false;
-      throw error;
-    }
-    if (!this.#config.noAutoShutdown) {
-      process.on("SIGTERM", this.shutdown.bind(this, false, true));
-      process.on("SIGINT", this.shutdown.bind(this, false, true));
-    }
-  }
-  // 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...", immediate });
-    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.#eventPruneInterval) {
-      clearInterval(this.#eventPruneInterval);
-      this.#eventPruneInterval = 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",
-            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",
-                code: ev.code,
-                reason: ev.reason.toString()
-              });
-              resolve();
-            });
-          });
-          (_d = logger()) == null ? void 0 : _d.info("closing WebSocket");
-          pegboardWebSocket.close(1e3, "Stopping");
-          await closePromise;
-          (_e = logger()) == null ? void 0 : _e.info("websocket shutdown completed");
-        } catch (error) {
-          (_f = logger()) == null ? void 0 : _f.error({
-            msg: "error during websocket shutdown:",
-            error
-          });
-          pegboardWebSocket.close();
-        }
-      }
-    } else {
-      (_g = logger()) == null ? void 0 : _g.warn("no runner WebSocket to shutdown or already closed");
-    }
-    if (this.#tunnel) {
-      this.#tunnel.shutdown();
-      (_h = logger()) == null ? void 0 : _h.info("tunnel shutdown completed");
-    }
-    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=1&namespace=${encodeURIComponent(this.#config.namespace)}&runner_key=${encodeURIComponent(this.#config.runnerKey)}`;
-  }
-  get pegboardTunnelUrl() {
-    const endpoint = this.#config.pegboardRelayEndpoint || this.#config.pegboardEndpoint || this.#config.endpoint;
-    const wsEndpoint = endpoint.replace("http://", "ws://").replace("https://", "wss://");
-    return `${wsEndpoint}?protocol_version=1&namespace=${encodeURIComponent(this.#config.namespace)}&runner_name=${encodeURIComponent(this.#config.runnerName)}&runner_key=${encodeURIComponent(this.#config.runnerKey)}`;
-  }
-  // MARK: Runner protocol
-  async #openPegboardWebSocket() {
-    const WS = await importWebSocket();
-    const ws = new WS(this.pegboardUrl, {
-      headers: {
-        "x-rivet-target": "runner"
-      }
-    });
-    this.#pegboardWebSocket = ws;
-    ws.addEventListener("open", () => {
-      var _a;
-      (_a = logger()) == null ? void 0 : _a.info("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("WebSocket not open, stopping ping loop");
-        }
-      }, 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("WebSocket not open, stopping ack loop");
-        }
-      }, ackInterval);
-      this.#ackInterval = ackLoop;
-    });
-    ws.addEventListener("message", async (ev) => {
-      var _a, _b, _c;
-      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;
-        this.runnerId = init.runnerId;
-        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") {
-        throw new Error("TODO");
-      } 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") {
-      } else {
-        unreachable(message);
-      }
-    });
-    ws.addEventListener("error", (ev) => {
-      var _a;
-      (_a = logger()) == null ? void 0 : _a.error("WebSocket error:", ev.error);
-    });
-    ws.addEventListener("close", (ev) => {
-      var _a, _b;
-      (_a = logger()) == null ? void 0 : _a.info({
-        msg: "connection closed",
-        code: ev.code,
-        reason: ev.reason.toString()
-      });
-      this.#config.onDisconnected();
-      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.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
-          (_b = logger()) == null ? void 0 : _b.info({
-            msg: "starting runner lost timeout",
-            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",
-      commandCount: commands.length
-    });
-    for (const commandWrapper of commands) {
-      (_b = logger()) == null ? void 0 : _b.info({ msg: "received command", 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);
-    }
-  }
-  #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",
-        actorId,
-        err
-      });
-      this.stopActor(actorId, generation);
-    });
-  }
-  #handleCommandStopActor(commandWrapper) {
-    const stopCommand = commandWrapper.inner.val;
-    const actorId = stopCommand.actorId;
-    const generation = stopCommand.generation;
-    this.stopActor(actorId, generation);
-  }
-  #sendActorIntent(actorId, generation, intentType) {
-    var _a, _b;
-    if (this.#shutdown) {
-      (_a = logger()) == null ? void 0 : _a.warn("Runner is shut down, cannot send actor intent");
-      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.#eventHistory.push({
-      event: eventWrapper,
-      timestamp: Date.now()
-    });
-    (_b = logger()) == null ? void 0 : _b.info({
-      msg: "sending event to server",
-      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(
-        "Runner is shut down, cannot send actor state update"
-      );
-      return;
-    }
-    let actorState;
-    if (stateType === "running") {
-      actorState = { tag: "ActorStateRunning", val: null };
-    } else if (stateType === "stopped") {
-      actorState = {
-        tag: "ActorStateStopped",
-        val: {
-          code: protocol.StopCode.Ok,
-          message: "hello"
-        }
-      };
-    } else {
-      unreachable(stateType);
-    }
-    const stateUpdateEvent = {
-      actorId,
-      generation,
-      state: actorState
-    };
-    const eventIndex = this.#nextEventIdx++;
-    const eventWrapper = {
-      index: eventIndex,
-      inner: {
-        tag: "EventActorStateUpdate",
-        val: stateUpdateEvent
-      }
-    };
-    this.#eventHistory.push({
-      event: eventWrapper,
-      timestamp: Date.now()
-    });
-    (_b = logger()) == null ? void 0 : _b.info({
-      msg: "sending event to server",
-      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(
-        "Runner is shut down, cannot send command acknowledgment"
-      );
-      return;
-    }
-    if (this.#lastCommandIdx < 0) {
-      return;
-    }
-    this.__sendToServer({
-      tag: "ToServerAckCommands",
-      val: {
-        lastCommandIdx: BigInt(this.#lastCommandIdx)
-      }
-    });
-  }
-  #handleKvResponse(response) {
-    var _a, _b;
-    const requestId = response.requestId;
-    const request = this.#kvRequests.get(requestId);
-    if (!request) {
-      const msg = "received kv response for unknown request id";
-      if (logger()) {
-        (_a = logger()) == null ? void 0 : _a.error({ msg, requestId });
-      } else {
-        (_b = logger()) == null ? void 0 : _b.error({ msg, 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.#eventHistory.push({
-      event: eventWrapper,
-      timestamp: Date.now()
-    });
-    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(
-        "Runner is shut down, cannot send message to server"
-      );
-      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(
-        "WebSocket not available or not open for sending data"
-      );
-    }
-  }
-  #scheduleReconnect() {
-    if (this.#shutdown) {
-      return;
-    }
-    const delay = calculateBackoff(this.#reconnectAttempt, {
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      multiplier: 2,
-      jitter: true
-    });
-    this.#reconnectTimeout = setTimeout(async () => {
-      if (!this.#shutdown) {
-        this.#reconnectAttempt++;
-        await this.#openPegboardWebSocket();
-      }
-    }, delay);
-  }
-  #resendUnacknowledgedEvents(lastEventIdx) {
-    const eventsToResend = this.#eventHistory.filter(
-      (item) => item.event.index > lastEventIdx
-    );
-    if (eventsToResend.length === 0) return;
-    const events = eventsToResend.map((item) => item.event);
-    this.__sendToServer({
-      tag: "ToServerEvents",
-      val: events
-    });
-  }
-  // TODO(RVT-4986): Prune when server acks events instead of based on old events
-  #pruneOldEvents() {
-    const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
-    const originalLength = this.#eventHistory.length;
-    this.#eventHistory = this.#eventHistory.filter(
-      (item) => item.timestamp > fiveMinutesAgo
-    );
-    const prunedCount = originalLength - this.#eventHistory.length;
-    if (prunedCount > 0) {
-    }
-  }
-  #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) {
-    }
-  }
-};
-
-
-exports.Runner = Runner;
-//# sourceMappingURL=mod.cjs.map