@rivetkit/engine-runner 2.0.4-rc.1

package/dist/mod.js

@@ -0,0 +1,2813 @@
+// 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("");
+}
+function stringifyError(error) {
+  var _a;
+  if (error instanceof Error) {
+    return `${error.name}: ${error.message}${error.stack ? `
+${error.stack}` : ""}`;
+  } else if (typeof error === "string") {
+    return error;
+  } else if (typeof error === "object" && error !== null) {
+    try {
+      return `${JSON.stringify(error)}`;
+    } catch {
+      return `[object ${((_a = error.constructor) == null ? void 0 : _a.name) || "Object"}]`;
+    }
+  } else {
+    return String(error);
+  }
+}
+
+// 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;
+  lastCommandIdx = -1n;
+  nextEventIdx = 0n;
+  eventHistory = [];
+  /**
+   * 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);
+    }
+  }
+  handleAckEvents(lastEventIdx) {
+    this.eventHistory = this.eventHistory.filter(
+      (event) => event.checkpoint.index > lastEventIdx
+    );
+  }
+  recordEvent(eventWrapper) {
+    this.eventHistory.push(eventWrapper);
+  }
+};
+
+// 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 "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 "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 { 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{config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
+    }
+    case "CommandStopActor": {
+      return `CommandStopActor`;
+    }
+  }
+}
+function stringifyCommandWrapper(wrapper) {
+  return `CommandWrapper{actorId: "${wrapper.checkpoint.actorId}", generation: "${wrapper.checkpoint.generation}", index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyCommand(wrapper.inner)}}`;
+}
+function stringifyEvent(event) {
+  switch (event.tag) {
+    case "EventActorIntent": {
+      const { intent } = event.val;
+      const intentStr = intent.tag === "ActorIntentSleep" ? "Sleep" : intent.tag === "ActorIntentStop" ? "Stop" : "Unknown";
+      return `EventActorIntent{intent: ${intentStr}}`;
+    }
+    case "EventActorStateUpdate": {
+      const { 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{state: ${stateStr}}`;
+    }
+    case "EventActorSetAlarm": {
+      const { alarmTs } = event.val;
+      const alarmTsStr = alarmTs === null ? "null" : stringifyBigInt(alarmTs);
+      return `EventActorSetAlarm{alarmTs: ${alarmTsStr}}`;
+    }
+  }
+}
+function stringifyEventWrapper(wrapper) {
+  return `EventWrapper{actorId: ${wrapper.checkpoint.actorId}, generation: "${wrapper.checkpoint.generation}", index: ${stringifyBigInt(wrapper.checkpoint.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
+}
+function stringifyToServer(message) {
+  switch (message.tag) {
+    case "ToServerInit": {
+      const {
+        name,
+        version,
+        totalSlots,
+        prepopulateActorNames,
+        metadata
+      } = message.val;
+      const prepopulateActorNamesStr = prepopulateActorNames === null ? "null" : `Map(${prepopulateActorNames.size})`;
+      const metadataStr = metadata === null ? "null" : `"${metadata}"`;
+      return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, 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 { lastCommandCheckpoints } = message.val;
+      const checkpointsStr = lastCommandCheckpoints.length > 0 ? `[${lastCommandCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]` : "[]";
+      return `ToServerAckCommands{lastCommandCheckpoints: ${checkpointsStr}}`;
+    }
+    case "ToServerStopping":
+      return "ToServerStopping";
+    case "ToServerPong": {
+      const { ts } = message.val;
+      return `ToServerPong{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, metadata } = message.val;
+      const metadataStr = `{runnerLostThreshold: ${stringifyBigInt(metadata.runnerLostThreshold)}}`;
+      return `ToClientInit{runnerId: "${runnerId}", metadata: ${metadataStr}}`;
+    }
+    case "ToClientPing": {
+      const { ts } = message.val;
+      return `ToClientPing{ts: ${stringifyBigInt(ts)}}`;
+    }
+    case "ToClientCommands": {
+      const commands = message.val;
+      return `ToClientCommands{count: ${commands.length}, commands: [${commands.map((c) => stringifyCommandWrapper(c)).join(", ")}]}`;
+    }
+    case "ToClientAckEvents": {
+      const { lastEventCheckpoints } = message.val;
+      const checkpointsStr = lastEventCheckpoints.length > 0 ? `[${lastEventCheckpoints.map((cp) => `{actorId: "${cp.actorId}", index: ${stringifyBigInt(cp.index)}}`).join(", ")}]` : "[]";
+      return `ToClientAckEvents{lastEventCheckpoints: ${checkpointsStr}}`;
+    }
+    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
+import { VirtualWebSocket } from "@rivetkit/virtual-websocket";
+var HIBERNATABLE_SYMBOL = /* @__PURE__ */ 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;
+    this.#ws = new VirtualWebSocket({
+      getReadyState: () => this.#readyState,
+      onSend: (data) => this.#handleSend(data),
+      onClose: (code, reason) => this.#close(code, reason, true),
+      onTerminate: () => this.#terminate()
+    });
+    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
+      });
+      this.#readyState = 1;
+    }
+  }
+  #readyState = 0;
+  #binaryType = "nodebuffer";
+  #ws;
+  #tunnel;
+  #actorId;
+  #requestId;
+  #hibernatable;
+  #serverMessageIndex;
+  #sendCallback;
+  #closeCallback;
+  get [HIBERNATABLE_SYMBOL]() {
+    return this.#hibernatable;
+  }
+  get #log() {
+    return this.#tunnel.log;
+  }
+  get websocket() {
+    return this.#ws;
+  }
+  #handleSend(data) {
+    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;
+      const buffer = view.buffer instanceof SharedArrayBuffer ? new Uint8Array(view.buffer, view.byteOffset, view.byteLength).slice().buffer : view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+      messageData = buffer;
+    } else {
+      throw new Error("Unsupported data type");
+    }
+    this.#sendCallback(messageData, isBinary);
+  }
+  // Called by Tunnel when WebSocket is opened
+  _handleOpen(requestId) {
+    if (this.#readyState !== 0) return;
+    this.#readyState = 1;
+    this.#ws.dispatchEvent({ type: "open", rivetRequestId: requestId, target: this.#ws });
+  }
+  // Called by Tunnel when message is received
+  _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
+      });
+      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",
+          requestId,
+          actorId: this.#actorId,
+          previousIndex,
+          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, true);
+        return true;
+      }
+      this.#serverMessageIndex = serverMessageIndex;
+    }
+    let messageData = data;
+    if (isBinary && data instanceof Uint8Array) {
+      if (this.#binaryType === "nodebuffer") {
+        messageData = Buffer.from(data);
+      } else if (this.#binaryType === "arraybuffer") {
+        messageData = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      }
+    }
+    this.#ws.dispatchEvent({
+      type: "message",
+      data: messageData,
+      rivetRequestId: requestId,
+      rivetMessageIndex: serverMessageIndex,
+      target: this.#ws
+    });
+    return false;
+  }
+  // Called by Tunnel when close is received
+  _handleClose(_requestId, code, reason) {
+    this.#close(code, reason, true);
+  }
+  // Close without sending close message to tunnel
+  _closeWithoutCallback(code, reason) {
+    this.#close(code, reason, false);
+  }
+  // Public close method (used by tunnel.ts for stale websocket cleanup)
+  close(code, reason) {
+    this.#close(code, reason, true);
+  }
+  #close(code, reason, sendCallback) {
+    if (this.#readyState >= 2) return;
+    this.#readyState = 2;
+    if (sendCallback) this.#closeCallback(code, reason);
+    this.#readyState = 3;
+    this.#ws.triggerClose(code ?? 1e3, reason ?? "");
+  }
+  #terminate() {
+    this.#readyState = 3;
+    this.#closeCallback(1006, "Abnormal Closure");
+    this.#ws.triggerClose(1006, "Abnormal Closure", false);
+  }
+};
+
+// src/tunnel.ts
+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,
+            error: stringifyError(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,
+            error: stringifyError(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.websocket,
+      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.getPegboardWebSocketIfReady()) {
+      (_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;
+      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 = 5;
+var EVENT_BACKLOG_WARN_THRESHOLD = 1e4;
+var SIGNAL_HANDLERS = [];
+var RunnerShutdownError = class extends Error {
+  constructor() {
+    super("Runner shut down");
+  }
+};
+var Runner = class {
+  #config;
+  get config() {
+    return this.#config;
+  }
+  #actors = /* @__PURE__ */ new Map();
+  // WebSocket
+  #pegboardWebSocket;
+  runnerId;
+  #started = false;
+  #shutdown = false;
+  #reconnectAttempt = 0;
+  #reconnectTimeout;
+  // Runner lost threshold management
+  #runnerLostThreshold;
+  #runnerLostTimeout;
+  // Event storage for resending
+  #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(() => {
+      var _a;
+      try {
+        this.#cleanupOldKvRequests();
+      } catch (err) {
+        (_a = this.log) == null ? void 0 : _a.error({
+          msg: "error cleaning up kv requests",
+          error: stringifyError(err)
+        });
+      }
+    }, 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, _b;
+    (_a = this.log) == null ? void 0 : _a.debug({
+      msg: "force stopping actor",
+      actorId
+    });
+    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);
+    }
+    (_b = this.#tunnel) == null ? void 0 : _b.closeActiveRequests(actor);
+    this.#sendActorStateUpdate(actorId, actor.generation, "stopped");
+    this.#removeActor(actorId, generation);
+  }
+  #handleLost() {
+    var _a;
+    (_a = this.log) == null ? void 0 : _a.info({
+      msg: "stopping all actors due to runner lost threshold"
+    });
+    for (const [_, request] of this.#kvRequests.entries()) {
+      request.reject(new RunnerShutdownError());
+    }
+    this.#kvRequests.clear();
+    this.#stopAllActors();
+  }
+  #stopAllActors() {
+    const actorIds = Array.from(this.#actors.keys());
+    for (const actorId of actorIds) {
+      this.forceStopActor(actorId).catch((err) => {
+        var _a;
+        (_a = this.log) == null ? void 0 : _a.error({
+          msg: "error stopping actor",
+          actorId,
+          error: stringifyError(err)
+        });
+      });
+    }
+  }
+  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.#shutdown) {
+      (_a = this.log) == null ? void 0 : _a.debug({
+        msg: "shutdown already in progress, ignoring"
+      });
+      return;
+    }
+    this.#shutdown = true;
+    (_b = this.log) == null ? void 0 : _b.info({
+      msg: "starting shutdown",
+      immediate,
+      exit
+    });
+    if (this.#reconnectTimeout) {
+      clearTimeout(this.#reconnectTimeout);
+      this.#reconnectTimeout = void 0;
+    }
+    if (this.#runnerLostTimeout) {
+      clearTimeout(this.#runnerLostTimeout);
+      this.#runnerLostTimeout = 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();
+    const pegboardWebSocket = this.getPegboardWebSocketIfReady();
+    if (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, _b;
+    const protocols = ["rivet"];
+    if (this.config.token)
+      protocols.push(`rivet_token.${this.config.token}`);
+    const WS = await importWebSocket();
+    if (this.#pegboardWebSocket && (this.#pegboardWebSocket.readyState === WS.CONNECTING || this.#pegboardWebSocket.readyState === WS.OPEN)) {
+      (_a = this.log) == null ? void 0 : _a.error(
+        "found duplicate pegboardWebSocket, closing previous"
+      );
+      this.#pegboardWebSocket.close(1e3, "duplicate_websocket");
+    }
+    const ws = new WS(this.pegboardUrl, protocols);
+    this.#pegboardWebSocket = ws;
+    (_b = this.log) == null ? void 0 : _b.info({
+      msg: "connecting",
+      endpoint: this.pegboardEndpoint,
+      namespace: this.#config.namespace,
+      runnerKey: this.#config.runnerKey,
+      hasToken: !!this.config.token
+    });
+    ws.addEventListener("open", () => {
+      var _a2, _b2;
+      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 {
+        (_b2 = this.log) == null ? void 0 : _b2.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,
+        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 ackInterval = 5 * 60 * 1e3;
+      const ackLoop = setInterval(() => {
+        var _a3, _b3;
+        try {
+          if (ws.readyState === 1) {
+            this.#sendCommandAcknowledgment();
+          } else {
+            clearInterval(ackLoop);
+            (_a3 = this.log) == null ? void 0 : _a3.info({
+              msg: "WebSocket not open, stopping ack loop"
+            });
+          }
+        } catch (err) {
+          (_b3 = this.log) == null ? void 0 : _b3.error({
+            msg: "error in command acknowledgment loop",
+            error: stringifyError(err)
+          });
+        }
+      }, ackInterval);
+      this.#ackInterval = ackLoop;
+    });
+    ws.addEventListener("message", async (ev) => {
+      var _a2, _b2, _c, _d, _e;
+      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.#stopAllActors();
+        }
+        this.#runnerLostThreshold = ((_b2 = init.metadata) == null ? void 0 : _b2.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
+        (_c = this.log) == null ? void 0 : _c.info({
+          msg: "received init",
+          runnerLostThreshold: this.#runnerLostThreshold
+        });
+        this.#processUnsentKvRequests();
+        this.#resendUnacknowledgedEvents();
+        (_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).catch((err) => {
+          var _a3;
+          (_a3 = this.log) == null ? void 0 : _a3.error({
+            msg: "error handling tunnel message",
+            error: stringifyError(err)
+          });
+        });
+      } else if (message.tag === "ToClientPing") {
+        this.__sendToServer({
+          tag: "ToServerPong",
+          val: {
+            ts: message.val.ts
+          }
+        });
+      } else {
+        unreachable(message);
+      }
+    });
+    ws.addEventListener("error", (ev) => {
+      var _a2, _b2;
+      (_a2 = this.log) == null ? void 0 : _a2.error({
+        msg: `WebSocket error: ${stringifyError(ev.error)}`
+      });
+      if (!this.#shutdown) {
+        if (!this.#runnerLostTimeout && this.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
+          (_b2 = this.log) == null ? void 0 : _b2.info({
+            msg: "starting runner lost timeout",
+            seconds: this.#runnerLostThreshold / 1e3
+          });
+          this.#runnerLostTimeout = setTimeout(() => {
+            var _a3;
+            try {
+              this.#handleLost();
+            } catch (err) {
+              (_a3 = this.log) == null ? void 0 : _a3.error({
+                msg: "error handling runner lost",
+                error: stringifyError(err)
+              });
+            }
+          }, this.#runnerLostThreshold);
+        }
+        this.#scheduleReconnect();
+      }
+    });
+    ws.addEventListener("close", async (ev) => {
+      var _a2, _b2, _c, _d;
+      if (!this.#shutdown) {
+        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 {
+          (_b2 = this.log) == null ? void 0 : _b2.warn({
+            msg: "runner disconnected",
+            code: ev.code,
+            reason: ev.reason.toString(),
+            closeError
+          });
+          this.#config.onDisconnected(ev.code, ev.reason);
+        }
+        if (this.#ackInterval) {
+          clearInterval(this.#ackInterval);
+          this.#ackInterval = void 0;
+        }
+        if (!this.#runnerLostTimeout && this.#runnerLostThreshold && this.#runnerLostThreshold > 0) {
+          (_c = this.log) == null ? void 0 : _c.info({
+            msg: "starting runner lost timeout",
+            seconds: this.#runnerLostThreshold / 1e3
+          });
+          this.#runnerLostTimeout = setTimeout(() => {
+            var _a3;
+            try {
+              this.#handleLost();
+            } catch (err) {
+              (_a3 = this.log) == null ? void 0 : _a3.error({
+                msg: "error handling runner lost",
+                error: stringifyError(err)
+              });
+            }
+          }, this.#runnerLostThreshold);
+        }
+        this.#scheduleReconnect();
+      } else {
+        (_d = this.log) == null ? void 0 : _d.info("websocket closed");
+        this.#config.onDisconnected(ev.code, ev.reason);
+      }
+    });
+  }
+  #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).catch((err) => {
+          var _a2;
+          (_a2 = this.log) == null ? void 0 : _a2.error({
+            msg: "error handling start actor command",
+            actorId: commandWrapper.checkpoint.actorId,
+            error: stringifyError(err)
+          });
+        });
+        const actor = this.getActor(
+          commandWrapper.checkpoint.actorId,
+          commandWrapper.checkpoint.generation
+        );
+        if (actor)
+          actor.lastCommandIdx = commandWrapper.checkpoint.index;
+      } else if (commandWrapper.inner.tag === "CommandStopActor") {
+        this.#handleCommandStopActor(commandWrapper).catch((err) => {
+          var _a2;
+          (_a2 = this.log) == null ? void 0 : _a2.error({
+            msg: "error handling stop actor command",
+            actorId: commandWrapper.checkpoint.actorId,
+            error: stringifyError(err)
+          });
+        });
+      } else {
+        unreachable(commandWrapper.inner);
+      }
+    }
+  }
+  #handleAckEvents(ack) {
+    var _a;
+    const originalTotalEvents = Array.from(this.#actors).reduce(
+      (s, [_, actor]) => s + actor.eventHistory.length,
+      0
+    );
+    for (const [_, actor] of this.#actors) {
+      const checkpoint = ack.lastEventCheckpoints.find(
+        (x) => x.actorId == actor.actorId
+      );
+      if (checkpoint) actor.handleAckEvents(checkpoint.index);
+    }
+    const totalEvents = Array.from(this.#actors).reduce(
+      (s, [_, actor]) => s + actor.eventHistory.length,
+      0
+    );
+    const prunedCount = originalTotalEvents - totalEvents;
+    if (prunedCount > 0) {
+      (_a = this.log) == null ? void 0 : _a.info({
+        msg: "pruned acknowledged events",
+        prunedCount
+      });
+    }
+    if (totalEvents <= 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;
+    const actor = this.getActor(eventWrapper.checkpoint.actorId);
+    if (!actor) return;
+    actor.recordEvent(eventWrapper);
+    const totalEvents = Array.from(this.#actors).reduce(
+      (s, [_, actor2]) => s + actor2.eventHistory.length,
+      0
+    );
+    if (totalEvents > EVENT_BACKLOG_WARN_THRESHOLD && !this.#eventBacklogWarned) {
+      this.#eventBacklogWarned = true;
+      (_a = this.log) == null ? void 0 : _a.warn({
+        msg: "unacknowledged event backlog exceeds threshold",
+        backlogSize: totalEvents,
+        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 = commandWrapper.checkpoint.actorId;
+    const generation = commandWrapper.checkpoint.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 = commandWrapper.checkpoint.actorId;
+    const generation = commandWrapper.checkpoint.generation;
+    await this.forceStopActor(actorId, generation);
+  }
+  #sendActorIntent(actorId, generation, intentType) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    let actorIntent;
+    if (intentType === "sleep") {
+      actorIntent = { tag: "ActorIntentSleep", val: null };
+    } else if (intentType === "stop") {
+      actorIntent = {
+        tag: "ActorIntentStop",
+        val: null
+      };
+    } else {
+      unreachable(intentType);
+    }
+    const intentEvent = {
+      intent: actorIntent
+    };
+    const eventWrapper = {
+      checkpoint: {
+        actorId,
+        generation,
+        index: actor.nextEventIdx++
+      },
+      inner: {
+        tag: "EventActorIntent",
+        val: intentEvent
+      }
+    };
+    this.#recordEvent(eventWrapper);
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: [eventWrapper]
+    });
+  }
+  #sendActorStateUpdate(actorId, generation, stateType) {
+    const actor = this.getActor(actorId, generation);
+    if (!actor) return;
+    let actorState;
+    if (stateType === "running") {
+      actorState = { tag: "ActorStateRunning", val: null };
+    } else if (stateType === "stopped") {
+      actorState = {
+        tag: "ActorStateStopped",
+        val: {
+          code: protocol.StopCode.Ok,
+          message: null
+        }
+      };
+    } else {
+      unreachable(stateType);
+    }
+    const stateUpdateEvent = {
+      state: actorState
+    };
+    const eventWrapper = {
+      checkpoint: {
+        actorId,
+        generation,
+        index: actor.nextEventIdx++
+      },
+      inner: {
+        tag: "EventActorStateUpdate",
+        val: stateUpdateEvent
+      }
+    };
+    this.#recordEvent(eventWrapper);
+    this.__sendToServer({
+      tag: "ToServerEvents",
+      val: [eventWrapper]
+    });
+  }
+  #sendCommandAcknowledgment() {
+    const lastCommandCheckpoints = [];
+    for (const [_, actor] of this.#actors) {
+      if (actor.lastCommandIdx < 0) {
+        continue;
+      }
+      lastCommandCheckpoints.push({
+        actorId: actor.actorId,
+        generation: actor.generation,
+        index: actor.lastCommandIdx
+      });
+    }
+    this.__sendToServer({
+      tag: "ToServerAckCommands",
+      val: {
+        lastCommandCheckpoints
+      }
+    });
+  }
+  #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 = {
+      alarmTs: alarmTs !== null ? BigInt(alarmTs) : null
+    };
+    const eventWrapper = {
+      checkpoint: {
+        actorId,
+        generation: actor.generation,
+        index: actor.nextEventIdx++
+      },
+      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.getPegboardWebSocketIfReady()) {
+        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.getPegboardWebSocketIfReady()) {
+      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. */
+  getPegboardWebSocketIfReady() {
+    if (!!this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
+      return this.#pegboardWebSocket;
+    } else {
+      return void 0;
+    }
+  }
+  __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);
+    const pegboardWebSocket = this.getPegboardWebSocketIfReady();
+    if (pegboardWebSocket) {
+      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,
+        runnerProtocolVersion: PROTOCOL_VERSION
+      }
+    });
+    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, _c;
+    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`
+    });
+    if (this.#reconnectTimeout) {
+      (_c = this.log) == null ? void 0 : _c.info(
+        "clearing previous reconnect timeout in schedule reconnect"
+      );
+      clearTimeout(this.#reconnectTimeout);
+    }
+    this.#reconnectTimeout = setTimeout(() => {
+      var _a2;
+      if (!this.#shutdown) {
+        this.#reconnectAttempt++;
+        (_a2 = this.log) == null ? void 0 : _a2.debug({
+          msg: `Attempting to reconnect (attempt ${this.#reconnectAttempt})...`
+        });
+        this.#openPegboardWebSocket().catch((err) => {
+          var _a3;
+          (_a3 = this.log) == null ? void 0 : _a3.error({
+            msg: "error during websocket reconnection",
+            error: stringifyError(err)
+          });
+        });
+      }
+    }, delay);
+  }
+  #resendUnacknowledgedEvents() {
+    var _a;
+    const eventsToResend = [];
+    for (const [_, actor] of this.#actors) {
+      eventsToResend.push(...actor.eventHistory);
+    }
+    if (eventsToResend.length === 0) return;
+    (_a = this.log) == null ? void 0 : _a.info({
+      msg: "resending unacknowledged events",
+      count: eventsToResend.length
+    });
+    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,
+  RunnerShutdownError,
+  idToStr
+};
+//# sourceMappingURL=mod.js.map