@rivetkit/engine 1.0.0 → 2.2.1-pr.4600.b74ff3b

package/sdks/typescript/runner/dist/mod.js

@@ -1,2951 +0,0 @@
-// 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/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);
-}
-function parseWebSocketCloseReason(reason) {
-  var _a;
-  const [mainPart, rayId] = reason.split("#");
-  const [group, error] = mainPart.split(".");
-  if (!group || !error) {
-    (_a = logger()) == null ? void 0 : _a.warn({ msg: "failed to parse close reason", reason });
-    return void 0;
-  }
-  return {
-    group,
-    error,
-    rayId
-  };
-}
-var U16_MAX = 65535;
-function wrappingLtU16(a, b) {
-  return a !== b && wrappingSub(b, a, U16_MAX) < U16_MAX / 2;
-}
-function wrappingLteU16(a, b) {
-  return a === b || wrappingLtU16(a, b);
-}
-function wrappingAddU16(a, b) {
-  return (a + b) % (U16_MAX + 1);
-}
-function wrappingSubU16(a, b) {
-  return wrappingSub(a, b, U16_MAX);
-}
-function wrappingSub(a, b, max) {
-  const result = a - b;
-  if (result < 0) {
-    return result + max + 1;
-  }
-  return result;
-}
-function arraysEqual(a, b) {
-  const ua = new Uint8Array(a);
-  const ub = new Uint8Array(b);
-  if (ua.length !== ub.length) return false;
-  for (let i = 0; i < ua.length; i++) {
-    if (ua[i] !== ub[i]) return false;
-  }
-  return true;
-}
-function promiseWithResolvers() {
-  let resolve;
-  let reject;
-  const promise = new Promise((res, rej) => {
-    resolve = res;
-    reject = rej;
-  });
-  return { promise, resolve, reject };
-}
-function idToStr(id) {
-  const bytes = new Uint8Array(id);
-  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
-}
-
-// src/actor.ts
-var RunnerActor = class {
-  constructor(actorId, generation, config, hibernatingRequests) {
-    this.hibernatingRequests = hibernatingRequests;
-    this.actorId = actorId;
-    this.generation = generation;
-    this.config = config;
-    this.actorStartPromise = promiseWithResolvers();
-  }
-  actorId;
-  generation;
-  config;
-  pendingRequests = [];
-  webSockets = [];
-  actorStartPromise;
-  /**
-   * If restoreHibernatingRequests has been called. This is used to assert
-   * that the caller is implemented correctly.
-   **/
-  hibernationRestored = false;
-  // Pending request methods
-  getPendingRequest(gatewayId, requestId) {
-    var _a;
-    return (_a = this.pendingRequests.find(
-      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-    )) == null ? void 0 : _a.request;
-  }
-  createPendingRequest(gatewayId, requestId, clientMessageIndex) {
-    var _a, _b;
-    const exists = this.getPendingRequest(gatewayId, requestId) !== void 0;
-    if (exists) {
-      (_a = logger()) == null ? void 0 : _a.warn({
-        msg: "attempting to set pending request twice, replacing existing",
-        gatewayId: idToStr(gatewayId),
-        requestId: idToStr(requestId)
-      });
-      this.deletePendingRequest(gatewayId, requestId);
-    }
-    this.pendingRequests.push({
-      gatewayId,
-      requestId,
-      request: {
-        resolve: () => {
-        },
-        reject: () => {
-        },
-        actorId: this.actorId,
-        gatewayId,
-        requestId,
-        clientMessageIndex
-      }
-    });
-    (_b = logger()) == null ? void 0 : _b.debug({
-      msg: "added pending request",
-      gatewayId: idToStr(gatewayId),
-      requestId: idToStr(requestId),
-      length: this.pendingRequests.length
-    });
-  }
-  createPendingRequestWithStreamController(gatewayId, requestId, clientMessageIndex, streamController) {
-    var _a, _b;
-    const exists = this.getPendingRequest(gatewayId, requestId) !== void 0;
-    if (exists) {
-      (_a = logger()) == null ? void 0 : _a.warn({
-        msg: "attempting to set pending request twice, replacing existing",
-        gatewayId: idToStr(gatewayId),
-        requestId: idToStr(requestId)
-      });
-      this.deletePendingRequest(gatewayId, requestId);
-    }
-    this.pendingRequests.push({
-      gatewayId,
-      requestId,
-      request: {
-        resolve: () => {
-        },
-        reject: () => {
-        },
-        actorId: this.actorId,
-        gatewayId,
-        requestId,
-        clientMessageIndex,
-        streamController
-      }
-    });
-    (_b = logger()) == null ? void 0 : _b.debug({
-      msg: "added pending request with stream controller",
-      gatewayId: idToStr(gatewayId),
-      requestId: idToStr(requestId),
-      length: this.pendingRequests.length
-    });
-  }
-  deletePendingRequest(gatewayId, requestId) {
-    var _a;
-    const index = this.pendingRequests.findIndex(
-      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-    );
-    if (index !== -1) {
-      this.pendingRequests.splice(index, 1);
-      (_a = logger()) == null ? void 0 : _a.debug({
-        msg: "removed pending request",
-        gatewayId: idToStr(gatewayId),
-        requestId: idToStr(requestId),
-        length: this.pendingRequests.length
-      });
-    }
-  }
-  // WebSocket methods
-  getWebSocket(gatewayId, requestId) {
-    var _a;
-    return (_a = this.webSockets.find(
-      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-    )) == null ? void 0 : _a.ws;
-  }
-  setWebSocket(gatewayId, requestId, ws) {
-    var _a;
-    const exists = this.getWebSocket(gatewayId, requestId) !== void 0;
-    if (exists) {
-      (_a = logger()) == null ? void 0 : _a.warn({ msg: "attempting to set websocket twice" });
-      return;
-    }
-    this.webSockets.push({ gatewayId, requestId, ws });
-  }
-  deleteWebSocket(gatewayId, requestId) {
-    const index = this.webSockets.findIndex(
-      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-    );
-    if (index !== -1) {
-      this.webSockets.splice(index, 1);
-    }
-  }
-};
-
-// src/stringify.ts
-function stringifyArrayBuffer(buffer) {
-  return `ArrayBuffer(${buffer.byteLength})`;
-}
-function stringifyBigInt(value) {
-  return `${value}n`;
-}
-function stringifyMap(map) {
-  const entries = Array.from(map.entries()).map(([k, v]) => `"${k}": "${v}"`).join(", ");
-  return `Map(${map.size}){${entries}}`;
-}
-function stringifyMessageId(messageId) {
-  return `MessageId{gatewayId: ${idToStr(messageId.gatewayId)}, requestId: ${idToStr(messageId.requestId)}, messageIndex: ${messageId.messageIndex}}`;
-}
-function stringifyToServerTunnelMessageKind(kind) {
-  switch (kind.tag) {
-    case "DeprecatedTunnelAck":
-      return "DeprecatedTunnelAck";
-    case "ToServerResponseStart": {
-      const { status, headers, body, stream } = kind.val;
-      const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
-      return `ToServerResponseStart{status: ${status}, headers: ${stringifyMap(headers)}, body: ${bodyStr}, stream: ${stream}}`;
-    }
-    case "ToServerResponseChunk": {
-      const { body, finish } = kind.val;
-      return `ToServerResponseChunk{body: ${stringifyArrayBuffer(body)}, finish: ${finish}}`;
-    }
-    case "ToServerResponseAbort":
-      return "ToServerResponseAbort";
-    case "ToServerWebSocketOpen": {
-      const { canHibernate } = kind.val;
-      return `ToServerWebSocketOpen{canHibernate: ${canHibernate}}`;
-    }
-    case "ToServerWebSocketMessage": {
-      const { data, binary } = kind.val;
-      return `ToServerWebSocketMessage{data: ${stringifyArrayBuffer(data)}, binary: ${binary}}`;
-    }
-    case "ToServerWebSocketMessageAck": {
-      const { index } = kind.val;
-      return `ToServerWebSocketMessageAck{index: ${index}}`;
-    }
-    case "ToServerWebSocketClose": {
-      const { code, reason, hibernate } = kind.val;
-      const codeStr = code === null ? "null" : code.toString();
-      const reasonStr = reason === null ? "null" : `"${reason}"`;
-      return `ToServerWebSocketClose{code: ${codeStr}, reason: ${reasonStr}, hibernate: ${hibernate}}`;
-    }
-  }
-}
-function stringifyToClientTunnelMessageKind(kind) {
-  switch (kind.tag) {
-    case "DeprecatedTunnelAck":
-      return "DeprecatedTunnelAck";
-    case "ToClientRequestStart": {
-      const { actorId, method, path, headers, body, stream } = kind.val;
-      const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
-      return `ToClientRequestStart{actorId: "${actorId}", method: "${method}", path: "${path}", headers: ${stringifyMap(headers)}, body: ${bodyStr}, stream: ${stream}}`;
-    }
-    case "ToClientRequestChunk": {
-      const { body, finish } = kind.val;
-      return `ToClientRequestChunk{body: ${stringifyArrayBuffer(body)}, finish: ${finish}}`;
-    }
-    case "ToClientRequestAbort":
-      return "ToClientRequestAbort";
-    case "ToClientWebSocketOpen": {
-      const { actorId, path, headers } = kind.val;
-      return `ToClientWebSocketOpen{actorId: "${actorId}", path: "${path}", headers: ${stringifyMap(headers)}}`;
-    }
-    case "ToClientWebSocketMessage": {
-      const { data, binary } = kind.val;
-      return `ToClientWebSocketMessage{data: ${stringifyArrayBuffer(data)}, binary: ${binary}}`;
-    }
-    case "ToClientWebSocketClose": {
-      const { code, reason } = kind.val;
-      const codeStr = code === null ? "null" : code.toString();
-      const reasonStr = reason === null ? "null" : `"${reason}"`;
-      return `ToClientWebSocketClose{code: ${codeStr}, reason: ${reasonStr}}`;
-    }
-  }
-}
-function stringifyCommand(command) {
-  switch (command.tag) {
-    case "CommandStartActor": {
-      const { actorId, generation, config, hibernatingRequests } = command.val;
-      const keyStr = config.key === null ? "null" : `"${config.key}"`;
-      const inputStr = config.input === null ? "null" : stringifyArrayBuffer(config.input);
-      const hibernatingRequestsStr = hibernatingRequests.length > 0 ? `[${hibernatingRequests.map((hr) => `{gatewayId: ${idToStr(hr.gatewayId)}, requestId: ${idToStr(hr.requestId)}}`).join(", ")}]` : "[]";
-      return `CommandStartActor{actorId: "${actorId}", generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
-    }
-    case "CommandStopActor": {
-      const { actorId, generation } = command.val;
-      return `CommandStopActor{actorId: "${actorId}", generation: ${generation}}`;
-    }
-  }
-}
-function stringifyCommandWrapper(wrapper) {
-  return `CommandWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
-}
-function stringifyEvent(event) {
-  switch (event.tag) {
-    case "EventActorIntent": {
-      const { actorId, generation, intent } = event.val;
-      const intentStr = intent.tag === "ActorIntentSleep" ? "Sleep" : intent.tag === "ActorIntentStop" ? "Stop" : "Unknown";
-      return `EventActorIntent{actorId: "${actorId}", generation: ${generation}, intent: ${intentStr}}`;
-    }
-    case "EventActorStateUpdate": {
-      const { actorId, generation, state } = event.val;
-      let stateStr;
-      if (state.tag === "ActorStateRunning") {
-        stateStr = "Running";
-      } else if (state.tag === "ActorStateStopped") {
-        const { code, message } = state.val;
-        const messageStr = message === null ? "null" : `"${message}"`;
-        stateStr = `Stopped{code: ${code}, message: ${messageStr}}`;
-      } else {
-        stateStr = "Unknown";
-      }
-      return `EventActorStateUpdate{actorId: "${actorId}", generation: ${generation}, state: ${stateStr}}`;
-    }
-    case "EventActorSetAlarm": {
-      const { actorId, generation, alarmTs } = event.val;
-      const alarmTsStr = alarmTs === null ? "null" : stringifyBigInt(alarmTs);
-      return `EventActorSetAlarm{actorId: "${actorId}", generation: ${generation}, alarmTs: ${alarmTsStr}}`;
-    }
-  }
-}
-function stringifyEventWrapper(wrapper) {
-  return `EventWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
-}
-function stringifyToServer(message) {
-  switch (message.tag) {
-    case "ToServerInit": {
-      const {
-        name,
-        version,
-        totalSlots,
-        lastCommandIdx,
-        prepopulateActorNames,
-        metadata
-      } = message.val;
-      const lastCommandIdxStr = lastCommandIdx === null ? "null" : stringifyBigInt(lastCommandIdx);
-      const prepopulateActorNamesStr = prepopulateActorNames === null ? "null" : `Map(${prepopulateActorNames.size})`;
-      const metadataStr = metadata === null ? "null" : `"${metadata}"`;
-      return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, lastCommandIdx: ${lastCommandIdxStr}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
-    }
-    case "ToServerEvents": {
-      const events = message.val;
-      return `ToServerEvents{count: ${events.length}, events: [${events.map((e) => stringifyEventWrapper(e)).join(", ")}]}`;
-    }
-    case "ToServerAckCommands": {
-      const { lastCommandIdx } = message.val;
-      return `ToServerAckCommands{lastCommandIdx: ${stringifyBigInt(lastCommandIdx)}}`;
-    }
-    case "ToServerStopping":
-      return "ToServerStopping";
-    case "ToServerPing": {
-      const { ts } = message.val;
-      return `ToServerPing{ts: ${stringifyBigInt(ts)}}`;
-    }
-    case "ToServerKvRequest": {
-      const { actorId, requestId, data } = message.val;
-      const dataStr = stringifyKvRequestData(data);
-      return `ToServerKvRequest{actorId: "${actorId}", requestId: ${requestId}, data: ${dataStr}}`;
-    }
-    case "ToServerTunnelMessage": {
-      const { messageId, messageKind } = message.val;
-      return `ToServerTunnelMessage{messageId: ${stringifyMessageId(messageId)}, messageKind: ${stringifyToServerTunnelMessageKind(messageKind)}}`;
-    }
-  }
-}
-function stringifyToClient(message) {
-  switch (message.tag) {
-    case "ToClientInit": {
-      const { runnerId, lastEventIdx, metadata } = message.val;
-      const metadataStr = `{runnerLostThreshold: ${stringifyBigInt(metadata.runnerLostThreshold)}}`;
-      return `ToClientInit{runnerId: "${runnerId}", lastEventIdx: ${stringifyBigInt(lastEventIdx)}, metadata: ${metadataStr}}`;
-    }
-    case "ToClientClose":
-      return "ToClientClose";
-    case "ToClientCommands": {
-      const commands = message.val;
-      return `ToClientCommands{count: ${commands.length}, commands: [${commands.map((c) => stringifyCommandWrapper(c)).join(", ")}]}`;
-    }
-    case "ToClientAckEvents": {
-      const { lastEventIdx } = message.val;
-      return `ToClientAckEvents{lastEventIdx: ${stringifyBigInt(lastEventIdx)}}`;
-    }
-    case "ToClientKvResponse": {
-      const { requestId, data } = message.val;
-      const dataStr = stringifyKvResponseData(data);
-      return `ToClientKvResponse{requestId: ${requestId}, data: ${dataStr}}`;
-    }
-    case "ToClientTunnelMessage": {
-      const { messageId, messageKind } = message.val;
-      return `ToClientTunnelMessage{messageId: ${stringifyMessageId(messageId)}, messageKind: ${stringifyToClientTunnelMessageKind(messageKind)}}`;
-    }
-  }
-}
-function stringifyKvRequestData(data) {
-  switch (data.tag) {
-    case "KvGetRequest": {
-      const { keys } = data.val;
-      return `KvGetRequest{keys: ${keys.length}}`;
-    }
-    case "KvListRequest": {
-      const { query, reverse, limit } = data.val;
-      const reverseStr = reverse === null ? "null" : reverse.toString();
-      const limitStr = limit === null ? "null" : stringifyBigInt(limit);
-      return `KvListRequest{query: ${stringifyKvListQuery(query)}, reverse: ${reverseStr}, limit: ${limitStr}}`;
-    }
-    case "KvPutRequest": {
-      const { keys, values } = data.val;
-      return `KvPutRequest{keys: ${keys.length}, values: ${values.length}}`;
-    }
-    case "KvDeleteRequest": {
-      const { keys } = data.val;
-      return `KvDeleteRequest{keys: ${keys.length}}`;
-    }
-    case "KvDropRequest":
-      return "KvDropRequest";
-  }
-}
-function stringifyKvListQuery(query) {
-  switch (query.tag) {
-    case "KvListAllQuery":
-      return "KvListAllQuery";
-    case "KvListRangeQuery": {
-      const { start, end, exclusive } = query.val;
-      return `KvListRangeQuery{start: ${stringifyArrayBuffer(start)}, end: ${stringifyArrayBuffer(end)}, exclusive: ${exclusive}}`;
-    }
-    case "KvListPrefixQuery": {
-      const { key } = query.val;
-      return `KvListPrefixQuery{key: ${stringifyArrayBuffer(key)}}`;
-    }
-  }
-}
-function stringifyKvResponseData(data) {
-  switch (data.tag) {
-    case "KvErrorResponse": {
-      const { message } = data.val;
-      return `KvErrorResponse{message: "${message}"}`;
-    }
-    case "KvGetResponse": {
-      const { keys, values, metadata } = data.val;
-      return `KvGetResponse{keys: ${keys.length}, values: ${values.length}, metadata: ${metadata.length}}`;
-    }
-    case "KvListResponse": {
-      const { keys, values, metadata } = data.val;
-      return `KvListResponse{keys: ${keys.length}, values: ${values.length}, metadata: ${metadata.length}}`;
-    }
-    case "KvPutResponse":
-      return "KvPutResponse";
-    case "KvDeleteResponse":
-      return "KvDeleteResponse";
-    case "KvDropResponse":
-      return "KvDropResponse";
-  }
-}
-
-// src/websocket-tunnel-adapter.ts
-var HIBERNATABLE_SYMBOL = Symbol("hibernatable");
-var WebSocketTunnelAdapter = class {
-  constructor(tunnel, actorId, requestId, serverMessageIndex, hibernatable, isRestoringHibernatable, request, sendCallback, closeCallback) {
-    this.request = request;
-    var _a;
-    this.#tunnel = tunnel;
-    this.#actorId = actorId;
-    this.#requestId = requestId;
-    this.#hibernatable = hibernatable;
-    this.#serverMessageIndex = serverMessageIndex;
-    this.#sendCallback = sendCallback;
-    this.#closeCallback = closeCallback;
-    if (isRestoringHibernatable) {
-      (_a = this.#log) == null ? void 0 : _a.debug({
-        msg: "setting WebSocket to OPEN state for restored connection",
-        actorId: this.#actorId,
-        requestId: this.#requestId,
-        hibernatable: this.#hibernatable
-      });
-      this.#readyState = 1;
-    }
-  }
-  // MARK: - WebSocket Compat Variables
-  #readyState = 0;
-  // CONNECTING
-  #eventListeners = /* @__PURE__ */ new Map();
-  #onopen = null;
-  #onclose = null;
-  #onerror = null;
-  #onmessage = null;
-  #bufferedAmount = 0;
-  #binaryType = "nodebuffer";
-  #extensions = "";
-  #protocol = "";
-  #url = "";
-  // mARK: - Internal State
-  #tunnel;
-  #actorId;
-  #requestId;
-  #hibernatable;
-  #serverMessageIndex;
-  get [HIBERNATABLE_SYMBOL]() {
-    return this.#hibernatable;
-  }
-  /**
-   * Called when sending a message from this WebSocket.
-   *
-   * Used to send a tunnel message from Tunnel.
-   */
-  #sendCallback;
-  /**
-   * Called when closing this WebSocket.
-   *
-   * Used to send a tunnel message from Tunnel
-   */
-  #closeCallback;
-  get #log() {
-    return this.#tunnel.log;
-  }
-  // MARK: - Lifecycle
-  get bufferedAmount() {
-    return this.#bufferedAmount;
-  }
-  _handleOpen(requestId) {
-    if (this.#readyState !== 0) {
-      return;
-    }
-    this.#readyState = 1;
-    const event = {
-      type: "open",
-      rivetRequestId: requestId,
-      target: this
-    };
-    this.#fireEvent("open", event);
-  }
-  _handleMessage(requestId, data, serverMessageIndex, isBinary) {
-    var _a, _b, _c;
-    if (this.#readyState !== 1) {
-      (_a = this.#log) == null ? void 0 : _a.warn({
-        msg: "WebSocket message ignored - not in OPEN state",
-        requestId: this.#requestId,
-        actorId: this.#actorId,
-        currentReadyState: this.#readyState,
-        expectedReadyState: 1,
-        serverMessageIndex,
-        hibernatable: this.#hibernatable
-      });
-      return true;
-    }
-    if (this.#hibernatable) {
-      const previousIndex = this.#serverMessageIndex;
-      if (wrappingLteU16(serverMessageIndex, previousIndex)) {
-        (_b = this.#log) == null ? void 0 : _b.info({
-          msg: "received duplicate hibernating websocket message, this indicates the actor failed to ack the message index before restarting",
-          requestId,
-          actorId: this.#actorId,
-          previousIndex,
-          expectedIndex: wrappingAddU16(previousIndex, 1),
-          receivedIndex: serverMessageIndex
-        });
-        return true;
-      }
-      const expectedIndex = wrappingAddU16(previousIndex, 1);
-      if (serverMessageIndex !== expectedIndex) {
-        const closeReason = "ws.message_index_skip";
-        (_c = this.#log) == null ? void 0 : _c.warn({
-          msg: "hibernatable websocket message index out of sequence, closing connection",
-          requestId,
-          actorId: this.#actorId,
-          previousIndex,
-          expectedIndex,
-          receivedIndex: serverMessageIndex,
-          closeReason,
-          gap: wrappingSubU16(
-            wrappingSubU16(serverMessageIndex, previousIndex),
-            1
-          )
-        });
-        this.close(1008, closeReason);
-        return true;
-      }
-      this.#serverMessageIndex = serverMessageIndex;
-    }
-    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 = {
-      type: "message",
-      data: messageData,
-      rivetRequestId: requestId,
-      rivetMessageIndex: serverMessageIndex,
-      target: this
-    };
-    this.#fireEvent("message", event);
-    return false;
-  }
-  _handleClose(_requestId, code, reason) {
-    this.#closeInner(code, reason, true);
-  }
-  _handleError(error) {
-    const event = {
-      type: "error",
-      target: this,
-      error
-    };
-    this.#fireEvent("error", event);
-  }
-  _closeWithoutCallback(code, reason) {
-    this.#closeInner(code, reason, false);
-  }
-  #fireEvent(type, event) {
-    var _a, _b, _c, _d, _e;
-    const listeners = this.#eventListeners.get(type);
-    if (listeners && listeners.size > 0) {
-      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;
-    }
-  }
-  #closeInner(code, reason, callback) {
-    if (this.#readyState === 2 || // CLOSING
-    this.#readyState === 3) {
-      return;
-    }
-    this.#readyState = 2;
-    if (callback) {
-      this.#closeCallback(code, reason);
-    }
-    this.#readyState = 3;
-    const closeEvent = {
-      wasClean: true,
-      code: code || 1e3,
-      reason: reason || "",
-      type: "close",
-      target: this
-    };
-    this.#fireEvent("close", closeEvent);
-  }
-  // MARK: - WebSocket Compatible API
-  get readyState() {
-    return this.#readyState;
-  }
-  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;
-  }
-  get onclose() {
-    return this.#onclose;
-  }
-  set onclose(value) {
-    this.#onclose = value;
-  }
-  get onerror() {
-    return this.#onerror;
-  }
-  set onerror(value) {
-    this.#onerror = value;
-  }
-  get onmessage() {
-    return this.#onmessage;
-  }
-  set onmessage(value) {
-    this.#onmessage = value;
-  }
-  send(data) {
-    if (this.#readyState === 0) {
-      throw new DOMException(
-        "WebSocket is still in CONNECTING state",
-        "InvalidStateError"
-      );
-    }
-    if (this.#readyState === 2 || this.#readyState === 3) {
-      return;
-    }
-    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) {
-    this.#closeInner(code, reason, true);
-  }
-  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);
-    }
-  }
-  removeEventListener(type, listener, options) {
-    if (typeof listener === "function") {
-      const listeners = this.#eventListeners.get(type);
-      if (listeners) {
-        listeners.delete(listener);
-      }
-    }
-  }
-  dispatchEvent(event) {
-    return true;
-  }
-  static CONNECTING = 0;
-  static OPEN = 1;
-  static CLOSING = 2;
-  static CLOSED = 3;
-  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"));
-  }
-  /** @experimental */
-  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 RunnerShutdownError = class extends Error {
-  constructor() {
-    super("Runner shut down");
-  }
-};
-var Tunnel = class {
-  #runner;
-  /** Maps request IDs to actor IDs for lookup */
-  #requestToActor = [];
-  /** Buffer for messages when not connected */
-  #bufferedMessages = [];
-  get log() {
-    return this.#runner.log;
-  }
-  constructor(runner) {
-    this.#runner = runner;
-  }
-  start() {
-  }
-  resendBufferedEvents() {
-    var _a;
-    if (this.#bufferedMessages.length === 0) {
-      return;
-    }
-    (_a = this.log) == null ? void 0 : _a.info({
-      msg: "resending buffered tunnel messages",
-      count: this.#bufferedMessages.length
-    });
-    const messages = this.#bufferedMessages;
-    this.#bufferedMessages = [];
-    for (const { gatewayId, requestId, messageKind } of messages) {
-      this.#sendMessage(gatewayId, requestId, messageKind);
-    }
-  }
-  shutdown() {
-    for (const [_actorId, actor] of this.#runner.actors) {
-      for (const entry of actor.pendingRequests) {
-        entry.request.reject(new RunnerShutdownError());
-      }
-      actor.pendingRequests = [];
-      for (const entry of actor.webSockets) {
-        if (!entry.ws[HIBERNATABLE_SYMBOL]) {
-          entry.ws._closeWithoutCallback(1e3, "ws.tunnel_shutdown");
-        }
-      }
-      actor.webSockets = [];
-    }
-    this.#requestToActor = [];
-  }
-  async restoreHibernatingRequests(actorId, metaEntries) {
-    var _a, _b, _c, _d;
-    const actor = this.#runner.getActor(actorId);
-    if (!actor) {
-      throw new Error(
-        `Actor ${actorId} not found for restoring hibernating requests`
-      );
-    }
-    if (actor.hibernationRestored) {
-      throw new Error(
-        `Actor ${actorId} already restored hibernating requests`
-      );
-    }
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "restoring hibernating requests",
-      actorId,
-      requests: actor.hibernatingRequests.length
-    });
-    const backgroundOperations = [];
-    let connectedButNotLoadedCount = 0;
-    let restoredCount = 0;
-    for (const { gatewayId, requestId } of actor.hibernatingRequests) {
-      const requestIdStr = idToStr(requestId);
-      const meta = metaEntries.find(
-        (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-      );
-      if (!meta) {
-        (_b = this.log) == null ? void 0 : _b.warn({
-          msg: "closing websocket that is not persisted",
-          requestId: requestIdStr
-        });
-        this.#sendMessage(gatewayId, requestId, {
-          tag: "ToServerWebSocketClose",
-          val: {
-            code: 1e3,
-            reason: "ws.meta_not_found_during_restore",
-            hibernate: false
-          }
-        });
-        connectedButNotLoadedCount++;
-      } else {
-        const request = buildRequestForWebSocket(
-          meta.path,
-          meta.headers
-        );
-        const restoreOperation = this.#createWebSocket(
-          actorId,
-          gatewayId,
-          requestId,
-          requestIdStr,
-          meta.serverMessageIndex,
-          true,
-          true,
-          request,
-          meta.path,
-          meta.headers,
-          false
-        ).then(() => {
-          var _a2;
-          const actor2 = this.#runner.getActor(actorId);
-          if (actor2) {
-            actor2.createPendingRequest(
-              gatewayId,
-              requestId,
-              meta.clientMessageIndex
-            );
-          }
-          (_a2 = this.log) == null ? void 0 : _a2.info({
-            msg: "connection successfully restored",
-            actorId,
-            requestId: requestIdStr
-          });
-        }).catch((err) => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.error({
-            msg: "error creating websocket during restore",
-            requestId: requestIdStr,
-            err
-          });
-          this.#sendMessage(gatewayId, requestId, {
-            tag: "ToServerWebSocketClose",
-            val: {
-              code: 1011,
-              reason: "ws.restore_error",
-              hibernate: false
-            }
-          });
-        });
-        backgroundOperations.push(restoreOperation);
-        restoredCount++;
-      }
-    }
-    let loadedButNotConnectedCount = 0;
-    for (const meta of metaEntries) {
-      const requestIdStr = idToStr(meta.requestId);
-      const isConnected = actor.hibernatingRequests.some(
-        (req) => arraysEqual(req.gatewayId, meta.gatewayId) && arraysEqual(req.requestId, meta.requestId)
-      );
-      if (!isConnected) {
-        (_c = this.log) == null ? void 0 : _c.warn({
-          msg: "removing stale persisted websocket",
-          requestId: requestIdStr
-        });
-        const request = buildRequestForWebSocket(
-          meta.path,
-          meta.headers
-        );
-        const cleanupOperation = this.#createWebSocket(
-          actorId,
-          meta.gatewayId,
-          meta.requestId,
-          requestIdStr,
-          meta.serverMessageIndex,
-          true,
-          true,
-          request,
-          meta.path,
-          meta.headers,
-          true
-        ).then((adapter) => {
-          adapter.close(1e3, "ws.stale_metadata");
-        }).catch((err) => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.error({
-            msg: "error creating stale websocket during restore",
-            requestId: requestIdStr,
-            err
-          });
-        });
-        backgroundOperations.push(cleanupOperation);
-        loadedButNotConnectedCount++;
-      }
-    }
-    await Promise.allSettled(backgroundOperations);
-    actor.hibernationRestored = true;
-    (_d = this.log) == null ? void 0 : _d.info({
-      msg: "restored hibernatable websockets",
-      actorId,
-      restoredCount,
-      connectedButNotLoadedCount,
-      loadedButNotConnectedCount
-    });
-  }
-  /**
-   * Called from WebSocketOpen message and when restoring hibernatable WebSockets.
-   *
-   * engineAlreadyClosed will be true if this is only being called to trigger
-   * the close callback and not to send a close message to the server. This
-   * is used specifically to clean up zombie WebSocket connections.
-   */
-  async #createWebSocket(actorId, gatewayId, requestId, requestIdStr, serverMessageIndex, isHibernatable, isRestoringHibernatable, request, path, headers, engineAlreadyClosed) {
-    var _a;
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "createWebSocket creating adapter",
-      actorId,
-      requestIdStr,
-      isHibernatable,
-      path
-    });
-    const adapter = new WebSocketTunnelAdapter(
-      this,
-      actorId,
-      requestIdStr,
-      serverMessageIndex,
-      isHibernatable,
-      isRestoringHibernatable,
-      request,
-      (data, isBinary) => {
-        const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data).buffer : data;
-        this.#sendMessage(gatewayId, requestId, {
-          tag: "ToServerWebSocketMessage",
-          val: {
-            data: dataBuffer,
-            binary: isBinary
-          }
-        });
-      },
-      (code, reason) => {
-        if (!engineAlreadyClosed) {
-          this.#sendMessage(gatewayId, requestId, {
-            tag: "ToServerWebSocketClose",
-            val: {
-              code: code || null,
-              reason: reason || null,
-              hibernate: false
-            }
-          });
-        }
-        const actor2 = this.#runner.getActor(actorId);
-        if (actor2) {
-          actor2.deleteWebSocket(gatewayId, requestId);
-          actor2.deletePendingRequest(gatewayId, requestId);
-        }
-        this.#removeRequestToActor(gatewayId, requestId);
-      }
-    );
-    const actor = this.#runner.getActor(actorId);
-    if (!actor) {
-      throw new Error(`Actor ${actorId} not found`);
-    }
-    actor.setWebSocket(gatewayId, requestId, adapter);
-    this.addRequestToActor(gatewayId, requestId, actorId);
-    await this.#runner.config.websocket(
-      this.#runner,
-      actorId,
-      adapter,
-      gatewayId,
-      requestId,
-      request,
-      path,
-      headers,
-      isHibernatable,
-      isRestoringHibernatable
-    );
-    return adapter;
-  }
-  addRequestToActor(gatewayId, requestId, actorId) {
-    this.#requestToActor.push({ gatewayId, requestId, actorId });
-  }
-  #removeRequestToActor(gatewayId, requestId) {
-    const index = this.#requestToActor.findIndex(
-      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
-    );
-    if (index !== -1) {
-      this.#requestToActor.splice(index, 1);
-    }
-  }
-  getRequestActor(gatewayId, requestId) {
-    var _a, _b;
-    const entry = this.#requestToActor.find(
-      (entry2) => arraysEqual(entry2.gatewayId, gatewayId) && arraysEqual(entry2.requestId, requestId)
-    );
-    if (!entry) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "missing requestToActor entry",
-        requestId: idToStr(requestId)
-      });
-      return void 0;
-    }
-    const actor = this.#runner.getActor(entry.actorId);
-    if (!actor) {
-      (_b = this.log) == null ? void 0 : _b.warn({
-        msg: "missing actor for requestToActor lookup",
-        requestId: idToStr(requestId),
-        actorId: entry.actorId
-      });
-      return void 0;
-    }
-    return actor;
-  }
-  async getAndWaitForRequestActor(gatewayId, requestId) {
-    const actor = this.getRequestActor(gatewayId, requestId);
-    if (!actor) return;
-    await actor.actorStartPromise.promise;
-    return actor;
-  }
-  #sendMessage(gatewayId, requestId, messageKind) {
-    var _a, _b, _c, _d;
-    if (!this.#runner.__webSocketReady()) {
-      (_a = this.log) == null ? void 0 : _a.debug({
-        msg: "buffering tunnel message, socket not connected to engine",
-        requestId: idToStr(requestId),
-        message: stringifyToServerTunnelMessageKind(messageKind)
-      });
-      this.#bufferedMessages.push({ gatewayId, requestId, messageKind });
-      return;
-    }
-    const gatewayIdStr = idToStr(gatewayId);
-    const requestIdStr = idToStr(requestId);
-    const actor = this.getRequestActor(gatewayId, requestId);
-    if (!actor) {
-      (_b = this.log) == null ? void 0 : _b.warn({
-        msg: "cannot send tunnel message, actor not found",
-        gatewayId: gatewayIdStr,
-        requestId: requestIdStr
-      });
-      return;
-    }
-    let clientMessageIndex;
-    const pending = actor.getPendingRequest(gatewayId, requestId);
-    if (pending) {
-      clientMessageIndex = pending.clientMessageIndex;
-      pending.clientMessageIndex++;
-    } else {
-      (_c = this.log) == null ? void 0 : _c.warn({
-        msg: "missing pending request for send message, defaulting to message index 0",
-        gatewayId: gatewayIdStr,
-        requestId: requestIdStr
-      });
-      clientMessageIndex = 0;
-    }
-    const messageId = {
-      gatewayId,
-      requestId,
-      messageIndex: clientMessageIndex
-    };
-    const messageIdStr = `${idToStr(messageId.gatewayId)}-${idToStr(messageId.requestId)}-${messageId.messageIndex}`;
-    (_d = this.log) == null ? void 0 : _d.debug({
-      msg: "sending tunnel msg",
-      messageId: messageIdStr,
-      gatewayId: gatewayIdStr,
-      requestId: requestIdStr,
-      messageIndex: clientMessageIndex,
-      message: stringifyToServerTunnelMessageKind(messageKind)
-    });
-    const message = {
-      tag: "ToServerTunnelMessage",
-      val: {
-        messageId,
-        messageKind
-      }
-    };
-    this.#runner.__sendToServer(message);
-  }
-  closeActiveRequests(actor) {
-    const actorId = actor.actorId;
-    for (const entry of actor.pendingRequests) {
-      entry.request.reject(new Error(`Actor ${actorId} stopped`));
-      if (entry.gatewayId && entry.requestId) {
-        this.#removeRequestToActor(entry.gatewayId, entry.requestId);
-      }
-    }
-    for (const entry of actor.webSockets) {
-      const isHibernatable = entry.ws[HIBERNATABLE_SYMBOL];
-      if (!isHibernatable) {
-        entry.ws._closeWithoutCallback(1e3, "actor.stopped");
-      }
-    }
-  }
-  async #fetch(actorId, gatewayId, requestId, request) {
-    var _a;
-    if (!this.#runner.hasActor(actorId)) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "ignoring request for unknown actor",
-        actorId
-      });
-      return new Response("Actor not found", {
-        status: 503,
-        headers: { "x-rivet-error": "runner.actor_not_found" }
-      });
-    }
-    const fetchHandler = this.#runner.config.fetch(
-      this.#runner,
-      actorId,
-      gatewayId,
-      requestId,
-      request
-    );
-    if (!fetchHandler) {
-      return new Response("Not Implemented", { status: 501 });
-    }
-    return fetchHandler;
-  }
-  async handleTunnelMessage(message) {
-    var _a;
-    const { gatewayId, requestId, messageIndex } = message.messageId;
-    const gatewayIdStr = idToStr(gatewayId);
-    const requestIdStr = idToStr(requestId);
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "receive tunnel msg",
-      gatewayId: gatewayIdStr,
-      requestId: requestIdStr,
-      messageIndex: message.messageId.messageIndex,
-      message: stringifyToClientTunnelMessageKind(message.messageKind)
-    });
-    switch (message.messageKind.tag) {
-      case "ToClientRequestStart":
-        await this.#handleRequestStart(
-          gatewayId,
-          requestId,
-          message.messageKind.val
-        );
-        break;
-      case "ToClientRequestChunk":
-        await this.#handleRequestChunk(
-          gatewayId,
-          requestId,
-          message.messageKind.val
-        );
-        break;
-      case "ToClientRequestAbort":
-        await this.#handleRequestAbort(gatewayId, requestId);
-        break;
-      case "ToClientWebSocketOpen":
-        await this.#handleWebSocketOpen(
-          gatewayId,
-          requestId,
-          message.messageKind.val
-        );
-        break;
-      case "ToClientWebSocketMessage": {
-        await this.#handleWebSocketMessage(
-          gatewayId,
-          requestId,
-          messageIndex,
-          message.messageKind.val
-        );
-        break;
-      }
-      case "ToClientWebSocketClose":
-        await this.#handleWebSocketClose(
-          gatewayId,
-          requestId,
-          message.messageKind.val
-        );
-        break;
-      case "DeprecatedTunnelAck":
-        break;
-      default:
-        unreachable(message.messageKind);
-    }
-  }
-  async #handleRequestStart(gatewayId, requestId, req) {
-    var _a, _b, _c;
-    const requestIdStr = idToStr(requestId);
-    const actor = await this.#runner.getAndWaitForActor(req.actorId);
-    if (!actor) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "actor does not exist in handleRequestStart, request will leak",
-        actorId: req.actorId,
-        requestId: requestIdStr
-      });
-      return;
-    }
-    this.addRequestToActor(gatewayId, requestId, req.actorId);
-    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 = actor.getPendingRequest(
-              gatewayId,
-              requestId
-            );
-            if (existing) {
-              existing.streamController = controller;
-              existing.actorId = req.actorId;
-              existing.gatewayId = gatewayId;
-              existing.requestId = requestId;
-            } else {
-              actor.createPendingRequestWithStreamController(
-                gatewayId,
-                requestId,
-                0,
-                controller
-              );
-            }
-          }
-        });
-        const streamingRequest = new Request(request, {
-          body: stream,
-          duplex: "half"
-        });
-        const response = await this.#fetch(
-          req.actorId,
-          gatewayId,
-          requestId,
-          streamingRequest
-        );
-        await this.#sendResponse(
-          actor.actorId,
-          actor.generation,
-          gatewayId,
-          requestId,
-          response
-        );
-      } else {
-        actor.createPendingRequest(gatewayId, requestId, 0);
-        const response = await this.#fetch(
-          req.actorId,
-          gatewayId,
-          requestId,
-          request
-        );
-        await this.#sendResponse(
-          actor.actorId,
-          actor.generation,
-          gatewayId,
-          requestId,
-          response
-        );
-      }
-    } catch (error) {
-      if (error instanceof RunnerShutdownError) {
-        (_b = this.log) == null ? void 0 : _b.debug({ msg: "catught runner shutdown error" });
-      } else {
-        (_c = this.log) == null ? void 0 : _c.error({ msg: "error handling request", error });
-        this.#sendResponseError(
-          actor.actorId,
-          actor.generation,
-          gatewayId,
-          requestId,
-          500,
-          "Internal Server Error"
-        );
-      }
-    } finally {
-      if (this.#runner.hasActor(req.actorId, actor.generation)) {
-        actor.deletePendingRequest(gatewayId, requestId);
-        this.#removeRequestToActor(gatewayId, requestId);
-      }
-    }
-  }
-  async #handleRequestChunk(gatewayId, requestId, chunk) {
-    const actor = await this.getAndWaitForRequestActor(
-      gatewayId,
-      requestId
-    );
-    if (actor) {
-      const pending = actor.getPendingRequest(gatewayId, requestId);
-      if (pending == null ? void 0 : pending.streamController) {
-        pending.streamController.enqueue(new Uint8Array(chunk.body));
-        if (chunk.finish) {
-          pending.streamController.close();
-          actor.deletePendingRequest(gatewayId, requestId);
-          this.#removeRequestToActor(gatewayId, requestId);
-        }
-      }
-    }
-  }
-  async #handleRequestAbort(gatewayId, requestId) {
-    const actor = await this.getAndWaitForRequestActor(
-      gatewayId,
-      requestId
-    );
-    if (actor) {
-      const pending = actor.getPendingRequest(gatewayId, requestId);
-      if (pending == null ? void 0 : pending.streamController) {
-        pending.streamController.error(new Error("Request aborted"));
-      }
-      actor.deletePendingRequest(gatewayId, requestId);
-      this.#removeRequestToActor(gatewayId, requestId);
-    }
-  }
-  async #sendResponse(actorId, generation, gatewayId, requestId, response) {
-    var _a;
-    if (!this.#runner.hasActor(actorId, generation)) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "actor not loaded to send response, assuming gateway has closed request",
-        actorId,
-        generation,
-        requestId
-      });
-      return;
-    }
-    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(gatewayId, requestId, {
-      tag: "ToServerResponseStart",
-      val: {
-        status: response.status,
-        headers,
-        body: body || null,
-        stream: false
-      }
-    });
-  }
-  #sendResponseError(actorId, generation, gatewayId, requestId, status, message) {
-    var _a;
-    if (!this.#runner.hasActor(actorId, generation)) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "actor not loaded to send response, assuming gateway has closed request",
-        actorId,
-        generation,
-        requestId
-      });
-      return;
-    }
-    const headers = /* @__PURE__ */ new Map();
-    headers.set("content-type", "text/plain");
-    this.#sendMessage(gatewayId, requestId, {
-      tag: "ToServerResponseStart",
-      val: {
-        status,
-        headers,
-        body: new TextEncoder().encode(message).buffer,
-        stream: false
-      }
-    });
-  }
-  async #handleWebSocketOpen(gatewayId, requestId, open) {
-    var _a, _b, _c;
-    const requestIdStr = idToStr(requestId);
-    const actor = await this.#runner.getAndWaitForActor(open.actorId);
-    if (!actor) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "ignoring websocket for unknown actor",
-        actorId: open.actorId
-      });
-      this.#sendMessage(gatewayId, requestId, {
-        tag: "ToServerWebSocketClose",
-        val: {
-          code: 1011,
-          reason: "Actor not found",
-          hibernate: false
-        }
-      });
-      return;
-    }
-    const existingAdapter = actor.getWebSocket(gatewayId, requestId);
-    if (existingAdapter) {
-      (_b = this.log) == null ? void 0 : _b.warn({
-        msg: "closing existing websocket for duplicate open event for the same request id",
-        requestId: requestIdStr
-      });
-      existingAdapter._closeWithoutCallback(1e3, "ws.duplicate_open");
-    }
-    try {
-      const request = buildRequestForWebSocket(
-        open.path,
-        Object.fromEntries(open.headers)
-      );
-      const canHibernate = this.#runner.config.hibernatableWebSocket.canHibernate(
-        actor.actorId,
-        gatewayId,
-        requestId,
-        request
-      );
-      const adapter = await this.#createWebSocket(
-        actor.actorId,
-        gatewayId,
-        requestId,
-        requestIdStr,
-        0,
-        canHibernate,
-        false,
-        request,
-        open.path,
-        Object.fromEntries(open.headers),
-        false
-      );
-      actor.createPendingRequest(gatewayId, requestId, 0);
-      this.#sendMessage(gatewayId, requestId, {
-        tag: "ToServerWebSocketOpen",
-        val: {
-          canHibernate
-        }
-      });
-      adapter._handleOpen(requestId);
-    } catch (error) {
-      (_c = this.log) == null ? void 0 : _c.error({ msg: "error handling websocket open", error });
-      this.#sendMessage(gatewayId, requestId, {
-        tag: "ToServerWebSocketClose",
-        val: {
-          code: 1011,
-          reason: "Server Error",
-          hibernate: false
-        }
-      });
-      actor.deleteWebSocket(gatewayId, requestId);
-      actor.deletePendingRequest(gatewayId, requestId);
-      this.#removeRequestToActor(gatewayId, requestId);
-    }
-  }
-  async #handleWebSocketMessage(gatewayId, requestId, serverMessageIndex, msg) {
-    var _a;
-    const actor = await this.getAndWaitForRequestActor(
-      gatewayId,
-      requestId
-    );
-    if (actor) {
-      const adapter = actor.getWebSocket(gatewayId, requestId);
-      if (adapter) {
-        const data = msg.binary ? new Uint8Array(msg.data) : new TextDecoder().decode(new Uint8Array(msg.data));
-        adapter._handleMessage(
-          requestId,
-          data,
-          serverMessageIndex,
-          msg.binary
-        );
-        return;
-      }
-    }
-    (_a = this.log) == null ? void 0 : _a.warn({
-      msg: "missing websocket for incoming websocket message, this may indicate the actor stopped before processing a message",
-      requestId
-    });
-  }
-  sendHibernatableWebSocketMessageAck(gatewayId, requestId, clientMessageIndex) {
-    var _a, _b, _c;
-    const requestIdStr = idToStr(requestId);
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "ack ws msg",
-      requestId: requestIdStr,
-      index: clientMessageIndex
-    });
-    if (clientMessageIndex < 0 || clientMessageIndex > 65535)
-      throw new Error("invalid websocket ack index");
-    const actor = this.getRequestActor(gatewayId, requestId);
-    if (!actor) {
-      (_b = this.log) == null ? void 0 : _b.warn({
-        msg: "cannot send websocket ack, actor not found",
-        requestId: requestIdStr
-      });
-      return;
-    }
-    const pending = actor.getPendingRequest(gatewayId, requestId);
-    if (!(pending == null ? void 0 : pending.gatewayId)) {
-      (_c = this.log) == null ? void 0 : _c.warn({
-        msg: "cannot send websocket ack, gatewayId not found in pending request",
-        requestId: requestIdStr
-      });
-      return;
-    }
-    this.#sendMessage(pending.gatewayId, requestId, {
-      tag: "ToServerWebSocketMessageAck",
-      val: {
-        index: clientMessageIndex
-      }
-    });
-  }
-  async #handleWebSocketClose(gatewayId, requestId, close) {
-    const actor = await this.getAndWaitForRequestActor(
-      gatewayId,
-      requestId
-    );
-    if (actor) {
-      const adapter = actor.getWebSocket(gatewayId, requestId);
-      if (adapter) {
-        adapter._handleClose(
-          requestId,
-          close.code || void 0,
-          close.reason || void 0
-        );
-        actor.deleteWebSocket(gatewayId, requestId);
-        actor.deletePendingRequest(gatewayId, requestId);
-        this.#removeRequestToActor(gatewayId, requestId);
-      }
-    }
-  }
-};
-function buildRequestForWebSocket(path, headers) {
-  const fullHeaders = {
-    ...headers,
-    Upgrade: "websocket",
-    Connection: "Upgrade"
-  };
-  if (!path.startsWith("/")) {
-    throw new Error("path must start with leading slash");
-  }
-  const request = new Request(`http://actor${path}`, {
-    method: "GET",
-    headers: fullHeaders
-  });
-  return request;
-}
-
-// 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 = 3;
-var RUNNER_PING_INTERVAL = 3e3;
-var EVENT_BACKLOG_WARN_THRESHOLD = 1e4;
-var SIGNAL_HANDLERS = [];
-var Runner = class {
-  #config;
-  get config() {
-    return this.#config;
-  }
-  #actors = /* @__PURE__ */ new Map();
-  // WebSocket
-  __pegboardWebSocket;
-  runnerId;
-  #lastCommandIdx = -1;
-  #pingLoop;
-  #nextEventIdx = 0n;
-  #started = false;
-  #shutdown = false;
-  #shuttingDown = false;
-  #reconnectAttempt = 0;
-  #reconnectTimeout;
-  // Runner lost threshold management
-  #runnerLostThreshold;
-  #runnerLostTimeout;
-  // Event storage for resending
-  #eventHistory = [];
-  #eventBacklogWarned = false;
-  // Command acknowledgment
-  #ackInterval;
-  // KV operations
-  #nextKvRequestId = 0;
-  #kvRequests = /* @__PURE__ */ new Map();
-  #kvCleanupInterval;
-  // Tunnel for HTTP/WebSocket forwarding
-  #tunnel;
-  // Cached child logger with runner-specific attributes
-  #logCached;
-  get log() {
-    if (this.#logCached) return this.#logCached;
-    const l = logger();
-    if (l) {
-      if (this.runnerId) {
-        this.#logCached = l.child({
-          runnerId: this.runnerId
-        });
-        return this.#logCached;
-      } else {
-        return l;
-      }
-    }
-    return void 0;
-  }
-  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.getActor(actorId, generation);
-    if (!actor) return;
-    try {
-      await this.#config.onActorStop(actorId, actor.generation);
-    } catch (err) {
-      console.error(`Error in onActorStop for actor ${actorId}:`, err);
-    }
-    (_a = this.#tunnel) == null ? void 0 : _a.closeActiveRequests(actor);
-    this.#removeActor(actorId, generation);
-    this.#sendActorStateUpdate(actorId, actor.generation, "stopped");
-  }
-  #stopAllActors() {
-    var _a;
-    (_a = this.log) == null ? void 0 : _a.info({
-      msg: "stopping all actors due to runner lost threshold exceeded"
-    });
-    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 = this.log) == null ? void 0 : _a.warn({
-        msg: "actor not found",
-        actorId
-      });
-      return void 0;
-    }
-    if (generation !== void 0 && actor.generation !== generation) {
-      (_b = this.log) == null ? void 0 : _b.warn({
-        msg: "actor generation mismatch",
-        actorId,
-        generation
-      });
-      return void 0;
-    }
-    return actor;
-  }
-  async getAndWaitForActor(actorId, generation) {
-    const actor = this.getActor(actorId, generation);
-    if (!actor) return;
-    await actor.actorStartPromise.promise;
-    return actor;
-  }
-  hasActor(actorId, generation) {
-    const actor = this.#actors.get(actorId);
-    return !!actor && (generation === void 0 || actor.generation === generation);
-  }
-  get actors() {
-    return this.#actors;
-  }
-  // IMPORTANT: Make sure to call stopActiveRequests if calling #removeActor
-  #removeActor(actorId, generation) {
-    var _a, _b, _c;
-    const actor = this.#actors.get(actorId);
-    if (!actor) {
-      (_a = this.log) == null ? void 0 : _a.error({
-        msg: "actor not found for removal",
-        actorId
-      });
-      return void 0;
-    }
-    if (generation !== void 0 && actor.generation !== generation) {
-      (_b = this.log) == null ? void 0 : _b.error({
-        msg: "actor generation mismatch",
-        actorId,
-        generation
-      });
-      return void 0;
-    }
-    this.#actors.delete(actorId);
-    (_c = this.log) == null ? void 0 : _c.info({
-      msg: "removed actor",
-      actorId,
-      actors: this.#actors.size
-    });
-    return actor;
-  }
-  // MARK: Start
-  async start() {
-    var _a, _b;
-    if (this.#started) throw new Error("Cannot call runner.start twice");
-    this.#started = true;
-    (_a = this.log) == 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", async () => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.debug("received SIGTERM");
-          for (const handler of SIGNAL_HANDLERS) {
-            await handler();
-          }
-        });
-        process.on("SIGINT", async () => {
-          var _a2;
-          (_a2 = this.log) == null ? void 0 : _a2.debug("received SIGINT");
-          for (const handler of SIGNAL_HANDLERS) {
-            await handler();
-          }
-        });
-        (_b = this.log) == null ? void 0 : _b.debug({
-          msg: "added SIGTERM listeners"
-        });
-      }
-      SIGNAL_HANDLERS.push(async () => {
-        var _a2;
-        const weak = new WeakRef(this);
-        await ((_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;
-    if (this.#shuttingDown) {
-      (_a = this.log) == null ? void 0 : _a.debug({
-        msg: "shutdown already in progress, ignoring"
-      });
-      return;
-    }
-    this.#shuttingDown = true;
-    (_b = this.log) == null ? void 0 : _b.info({
-      msg: "starting shutdown",
-      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.__webSocketReady()) {
-      const pegboardWebSocket = this.__pegboardWebSocket;
-      if (immediate) {
-        pegboardWebSocket.close(1e3, "pegboard.runner_shutdown");
-      } else {
-        try {
-          (_c = this.log) == null ? void 0 : _c.info({
-            msg: "sending stopping message",
-            readyState: pegboardWebSocket.readyState
-          });
-          this.__sendToServer({
-            tag: "ToServerStopping",
-            val: null
-          });
-          const closePromise = new Promise((resolve) => {
-            if (!pegboardWebSocket)
-              throw new Error("missing pegboardWebSocket");
-            pegboardWebSocket.addEventListener("close", (ev) => {
-              var _a2;
-              (_a2 = this.log) == null ? void 0 : _a2.info({
-                msg: "connection closed",
-                code: ev.code,
-                reason: ev.reason.toString()
-              });
-              resolve();
-            });
-          });
-          await this.#waitForActorsToStop(pegboardWebSocket);
-          (_d = this.log) == null ? void 0 : _d.info({
-            msg: "closing WebSocket"
-          });
-          pegboardWebSocket.close(1e3, "pegboard.runner_shutdown");
-          await closePromise;
-          (_e = this.log) == null ? void 0 : _e.info({
-            msg: "websocket shutdown completed"
-          });
-        } catch (error) {
-          (_f = this.log) == null ? void 0 : _f.error({
-            msg: "error during websocket shutdown:",
-            error
-          });
-          pegboardWebSocket.close();
-        }
-      }
-    } else {
-      (_h = this.log) == null ? void 0 : _h.debug({
-        msg: "no runner WebSocket to shutdown or already closed",
-        readyState: (_g = this.__pegboardWebSocket) == null ? void 0 : _g.readyState
-      });
-    }
-    if (this.#tunnel) {
-      this.#tunnel.shutdown();
-      this.#tunnel = void 0;
-    }
-    this.#config.onShutdown();
-    if (exit) process.exit(0);
-  }
-  /**
-   * Wait for all actors to stop before proceeding with shutdown.
-   *
-   * This method polls every 100ms to check if all actors have been stopped.
-   *
-   * It will resolve early if:
-   * - All actors are stopped
-   * - The WebSocket connection is closed
-   * - The shutdown timeout is reached (120 seconds)
-   */
-  async #waitForActorsToStop(ws) {
-    const shutdownTimeout = 12e4;
-    const shutdownCheckInterval = 100;
-    const progressLogInterval = 5e3;
-    const shutdownStartTs = Date.now();
-    let lastProgressLogTs = 0;
-    return new Promise((resolve) => {
-      var _a, _b;
-      const checkActors = () => {
-        var _a2, _b2, _c, _d;
-        const now = Date.now();
-        const elapsed = now - shutdownStartTs;
-        const wsIsClosed = ws.readyState === 2 || ws.readyState === 3;
-        if (this.#actors.size === 0) {
-          (_a2 = this.log) == null ? void 0 : _a2.info({
-            msg: "all actors stopped",
-            elapsed
-          });
-          return true;
-        } else if (wsIsClosed) {
-          (_b2 = this.log) == null ? void 0 : _b2.warn({
-            msg: "websocket closed before all actors stopped",
-            remainingActors: this.#actors.size,
-            elapsed
-          });
-          return true;
-        } else if (elapsed >= shutdownTimeout) {
-          (_c = this.log) == null ? void 0 : _c.warn({
-            msg: "shutdown timeout reached, forcing close",
-            remainingActors: this.#actors.size,
-            elapsed
-          });
-          return true;
-        } else {
-          if (now - lastProgressLogTs >= progressLogInterval) {
-            (_d = this.log) == null ? void 0 : _d.info({
-              msg: "waiting for actors to stop",
-              remainingActors: this.#actors.size,
-              elapsed
-            });
-            lastProgressLogTs = now;
-          }
-          return false;
-        }
-      };
-      if (checkActors()) {
-        (_a = this.log) == null ? void 0 : _a.debug({
-          msg: "actors check completed immediately"
-        });
-        resolve();
-        return;
-      }
-      (_b = this.log) == null ? void 0 : _b.debug({
-        msg: "starting actor wait interval",
-        checkInterval: shutdownCheckInterval
-      });
-      const interval = setInterval(() => {
-        var _a2, _b2;
-        (_a2 = this.log) == null ? void 0 : _a2.debug({
-          msg: "actor wait interval tick",
-          actorCount: this.#actors.size
-        });
-        if (checkActors()) {
-          (_b2 = this.log) == null ? void 0 : _b2.debug({
-            msg: "actors check completed, clearing interval"
-          });
-          clearInterval(interval);
-          resolve();
-        }
-      }, shutdownCheckInterval);
-    });
-  }
-  // MARK: Networking
-  get pegboardEndpoint() {
-    return this.#config.pegboardEndpoint || this.#config.endpoint;
-  }
-  get pegboardUrl() {
-    const wsEndpoint = this.pegboardEndpoint.replace("http://", "ws://").replace("https://", "wss://");
-    const baseUrl = wsEndpoint.endsWith("/") ? wsEndpoint.slice(0, -1) : wsEndpoint;
-    return `${baseUrl}/runners/connect?protocol_version=${PROTOCOL_VERSION}&namespace=${encodeURIComponent(this.#config.namespace)}&runner_key=${encodeURIComponent(this.#config.runnerKey)}`;
-  }
-  // MARK: Runner protocol
-  async #openPegboardWebSocket() {
-    var _a;
-    const protocols = ["rivet"];
-    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;
-    (_a = this.log) == null ? void 0 : _a.info({
-      msg: "connecting",
-      endpoint: this.pegboardEndpoint,
-      namespace: this.#config.namespace,
-      runnerKey: this.#config.runnerKey,
-      hasToken: !!this.config.token
-    });
-    ws.addEventListener("open", () => {
-      var _a2, _b;
-      if (this.#reconnectAttempt > 0) {
-        (_a2 = this.log) == null ? void 0 : _a2.info({
-          msg: "runner reconnected",
-          namespace: this.#config.namespace,
-          runnerName: this.#config.runnerName,
-          reconnectAttempt: this.#reconnectAttempt
-        });
-      } else {
-        (_b = this.log) == null ? void 0 : _b.debug({
-          msg: "runner connected",
-          namespace: this.#config.namespace,
-          runnerName: this.#config.runnerName
-        });
-      }
-      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
-      });
-      const pingLoop = setInterval(() => {
-        var _a3;
-        if (ws.readyState === 1) {
-          this.__sendToServer({
-            tag: "ToServerPing",
-            val: {
-              ts: BigInt(Date.now())
-            }
-          });
-        } else {
-          clearInterval(pingLoop);
-          (_a3 = this.log) == null ? void 0 : _a3.info({
-            msg: "WebSocket not open, stopping ping loop"
-          });
-        }
-      }, RUNNER_PING_INTERVAL);
-      this.#pingLoop = pingLoop;
-      const ackInterval = 5 * 60 * 1e3;
-      const ackLoop = setInterval(() => {
-        var _a3;
-        if (ws.readyState === 1) {
-          this.#sendCommandAcknowledgment();
-        } else {
-          clearInterval(ackLoop);
-          (_a3 = this.log) == null ? void 0 : _a3.info({
-            msg: "WebSocket not open, stopping ack loop"
-          });
-        }
-      }, ackInterval);
-      this.#ackInterval = ackLoop;
-    });
-    ws.addEventListener("message", async (ev) => {
-      var _a2, _b, _c, _d, _e, _f;
-      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);
-      (_a2 = this.log) == null ? void 0 : _a2.debug({
-        msg: "received runner message",
-        data: stringifyToClient(message)
-      });
-      if (message.tag === "ToClientInit") {
-        const init = message.val;
-        if (this.runnerId !== init.runnerId) {
-          this.runnerId = init.runnerId;
-          this.#eventHistory.length = 0;
-        }
-        this.#runnerLostThreshold = ((_b = init.metadata) == null ? void 0 : _b.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
-        (_c = this.log) == null ? void 0 : _c.info({
-          msg: "received init",
-          lastEventIdx: init.lastEventIdx,
-          runnerLostThreshold: this.#runnerLostThreshold
-        });
-        this.#processUnsentKvRequests();
-        this.#resendUnacknowledgedEvents(init.lastEventIdx);
-        (_d = this.#tunnel) == null ? void 0 : _d.resendBufferedEvents();
-        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") {
-        (_e = this.#tunnel) == null ? void 0 : _e.handleTunnelMessage(message.val);
-      } else if (message.tag === "ToClientClose") {
-        (_f = this.#tunnel) == null ? void 0 : _f.shutdown();
-        ws.close(1e3, "manual closure");
-      } else {
-        unreachable(message);
-      }
-    });
-    ws.addEventListener("error", (ev) => {
-      var _a2, _b;
-      (_a2 = this.log) == null ? void 0 : _a2.error({
-        msg: `WebSocket error: ${ev.error}`
-      });
-      if (!this.#shutdown) {
-        if (!this.#runnerLostTimeout && this.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
-          (_b = this.log) == null ? void 0 : _b.info({
-            msg: "starting runner lost timeout",
-            seconds: this.#runnerLostThreshold / 1e3
-          });
-          this.#runnerLostTimeout = setTimeout(() => {
-            this.#stopAllActors();
-          }, this.#runnerLostThreshold);
-        }
-        this.#scheduleReconnect();
-      }
-    });
-    ws.addEventListener("close", async (ev) => {
-      var _a2, _b, _c, _d;
-      const closeError = parseWebSocketCloseReason(ev.reason);
-      if ((closeError == null ? void 0 : closeError.group) === "ws" && (closeError == null ? void 0 : closeError.error) === "eviction") {
-        (_a2 = this.log) == null ? void 0 : _a2.info("runner websocket evicted");
-        this.#config.onDisconnected(ev.code, ev.reason);
-        await this.shutdown(true);
-      } else {
-        if ((closeError == null ? void 0 : closeError.group) === "pegboard" && (closeError == null ? void 0 : closeError.error) === "runner_shutdown") {
-          (_b = this.log) == null ? void 0 : _b.info("runner shutdown");
-        } else {
-          (_c = this.log) == null ? void 0 : _c.warn({
-            msg: "runner disconnected",
-            code: ev.code,
-            reason: ev.reason.toString(),
-            closeError
-          });
-        }
-        this.#config.onDisconnected(ev.code, ev.reason);
-      }
-      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) {
-          (_d = this.log) == null ? void 0 : _d.info({
-            msg: "starting runner lost timeout",
-            seconds: this.#runnerLostThreshold / 1e3
-          });
-          this.#runnerLostTimeout = setTimeout(() => {
-            this.#stopAllActors();
-          }, this.#runnerLostThreshold);
-        }
-        this.#scheduleReconnect();
-      }
-    });
-  }
-  #handleCommands(commands) {
-    var _a;
-    (_a = this.log) == null ? void 0 : _a.info({
-      msg: "received commands",
-      commandCount: commands.length
-    });
-    for (const commandWrapper of commands) {
-      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 = this.log) == null ? void 0 : _a.info({
-        msg: "pruned acknowledged events",
-        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 = this.log) == null ? void 0 : _a.warn({
-        msg: "unacknowledged event backlog exceeds threshold",
-        backlogSize: this.#eventHistory.length,
-        threshold: EVENT_BACKLOG_WARN_THRESHOLD
-      });
-    }
-  }
-  async #handleCommandStartActor(commandWrapper) {
-    var _a, _b, _c, _d;
-    if (!this.#tunnel) throw new Error("missing tunnel on actor start");
-    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 = new RunnerActor(
-      actorId,
-      generation,
-      actorConfig,
-      startCommand.hibernatingRequests
-    );
-    const existingActor = this.#actors.get(actorId);
-    if (existingActor) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "replacing existing actor in actors map",
-        actorId,
-        existingGeneration: existingActor.generation,
-        newGeneration: generation,
-        existingPendingRequests: existingActor.pendingRequests.length
-      });
-    }
-    this.#actors.set(actorId, instance);
-    for (const hr of startCommand.hibernatingRequests) {
-      this.#tunnel.addRequestToActor(hr.gatewayId, hr.requestId, actorId);
-    }
-    (_b = this.log) == null ? void 0 : _b.info({
-      msg: "created actor",
-      actors: this.#actors.size,
-      actorId,
-      name: config.name,
-      key: config.key,
-      generation,
-      hibernatingRequests: startCommand.hibernatingRequests.length
-    });
-    this.#sendActorStateUpdate(actorId, generation, "running");
-    try {
-      (_c = this.log) == null ? void 0 : _c.debug({
-        msg: "calling onActorStart",
-        actorId,
-        generation
-      });
-      await this.#config.onActorStart(actorId, generation, actorConfig);
-      instance.actorStartPromise.resolve();
-    } catch (err) {
-      (_d = this.log) == null ? void 0 : _d.error({
-        msg: "error starting runner actor",
-        actorId,
-        err
-      });
-      instance.actorStartPromise.reject(err);
-      await this.forceStopActor(actorId, generation);
-    }
-  }
-  async #handleCommandStopActor(commandWrapper) {
-    const stopCommand = commandWrapper.inner.val;
-    const actorId = stopCommand.actorId;
-    const generation = stopCommand.generation;
-    await this.forceStopActor(actorId, generation);
-  }
-  #sendActorIntent(actorId, generation, intentType) {
-    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);
-    this.__sendToServer({
-      tag: "ToServerEvents",
-      val: [eventWrapper]
-    });
-  }
-  #sendActorStateUpdate(actorId, generation, stateType) {
-    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);
-    this.__sendToServer({
-      tag: "ToServerEvents",
-      val: [eventWrapper]
-    });
-  }
-  #sendCommandAcknowledgment() {
-    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) {
-      (_a = this.log) == null ? void 0 : _a.error({
-        msg: "received kv response for unknown request id",
-        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;
-    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) => {
-      const requestId = this.#nextKvRequestId++;
-      const requestEntry = {
-        actorId,
-        data: requestData,
-        resolve,
-        reject,
-        sent: false,
-        timestamp: Date.now()
-      };
-      this.#kvRequests.set(requestId, requestEntry);
-      if (this.__webSocketReady()) {
-        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.__webSocketReady()) {
-      return;
-    }
-    let processedCount = 0;
-    for (const [requestId, request] of this.#kvRequests.entries()) {
-      if (!request.sent) {
-        this.#sendSingleKvRequest(requestId);
-        processedCount++;
-      }
-    }
-    if (processedCount > 0) {
-    }
-  }
-  /** Asserts WebSocket exists and is ready. */
-  __webSocketReady() {
-    return !!this.__pegboardWebSocket && this.__pegboardWebSocket.readyState === 1;
-  }
-  __sendToServer(message) {
-    var _a, _b;
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "sending runner message",
-      data: stringifyToServer(message)
-    });
-    const encoded = protocol.encodeToServer(message);
-    if (this.__webSocketReady()) {
-      this.__pegboardWebSocket.send(encoded);
-    } else {
-      (_b = this.log) == null ? void 0 : _b.error({
-        msg: "WebSocket not available or not open for sending data"
-      });
-    }
-  }
-  sendHibernatableWebSocketMessageAck(gatewayId, requestId, index) {
-    if (!this.#tunnel)
-      throw new Error("missing tunnel to send message ack");
-    this.#tunnel.sendHibernatableWebSocketMessageAck(
-      gatewayId,
-      requestId,
-      index
-    );
-  }
-  /**
-   * Restores hibernatable WebSocket connections for an actor.
-   *
-   * This method should be called at the end of `onActorStart` after the
-   * actor instance is fully initialized.
-   *
-   * This method will:
-   * - Restore all provided hibernatable WebSocket connections
-   * - Attach event listeners to the restored WebSockets
-   * - Close any WebSocket connections that failed to restore
-   *
-   * The provided metadata list should include all hibernatable WebSockets
-   * that were persisted for this actor. The gateway will automatically
-   * close any connections that are not restored (i.e., not included in
-   * this list).
-   *
-   * **Important:** This method must be called after `onActorStart` completes
-   * and before marking the actor as "ready" to ensure all hibernatable
-   * connections are fully restored.
-   *
-   * @param actorId - The ID of the actor to restore connections for
-   * @param metaEntries - Array of hibernatable WebSocket metadata to restore
-   */
-  async restoreHibernatingRequests(actorId, metaEntries) {
-    if (!this.#tunnel)
-      throw new Error("missing tunnel to restore hibernating requests");
-    await this.#tunnel.restoreHibernatingRequests(actorId, metaEntries);
-  }
-  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 = this.log) == null ? void 0 : _a.debug({
-        msg: "Runner is shut down, not attempting reconnect"
-      });
-      return;
-    }
-    const delay = calculateBackoff(this.#reconnectAttempt, {
-      initialDelay: 1e3,
-      maxDelay: 3e4,
-      multiplier: 2,
-      jitter: true
-    });
-    (_b = this.log) == null ? void 0 : _b.debug({
-      msg: `Scheduling reconnect attempt ${this.#reconnectAttempt + 1} in ${delay}ms`
-    });
-    this.#reconnectTimeout = setTimeout(async () => {
-      var _a2;
-      if (!this.#shutdown) {
-        this.#reconnectAttempt++;
-        (_a2 = this.log) == null ? void 0 : _a2.debug({
-          msg: `Attempting to reconnect (attempt ${this.#reconnectAttempt})...`
-        });
-        await this.#openPegboardWebSocket();
-      }
-    }, delay);
-  }
-  #resendUnacknowledgedEvents(lastEventIdx) {
-    var _a;
-    const eventsToResend = this.#eventHistory.filter(
-      (event) => event.index > lastEventIdx
-    );
-    if (eventsToResend.length === 0) return;
-    (_a = this.log) == null ? void 0 : _a.info({
-      msg: "resending unacknowledged events",
-      fromIndex: lastEventIdx + 1n
-    });
-    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,
-  RunnerActor,
-  idToStr
-};
-//# sourceMappingURL=mod.js.map