@rivetkit/engine-runner 2.0.23 → 2.0.24

package/dist/mod.js

@@ -10,6 +10,213 @@ function logger() {
   return LOGGER;
 }
 
+// src/utils.ts
+function unreachable(x) {
+  throw `Unreachable: ${x}`;
+}
+function calculateBackoff(attempt, options = {}) {
+  const {
+    initialDelay = 1e3,
+    maxDelay = 3e4,
+    multiplier = 2,
+    jitter = true
+  } = options;
+  let delay = Math.min(initialDelay * multiplier ** attempt, maxDelay);
+  if (jitter) {
+    delay = delay * (1 + Math.random() * 0.25);
+  }
+  return Math.floor(delay);
+}
+function parseWebSocketCloseReason(reason) {
+  var _a;
+  const [mainPart, rayId] = reason.split("#");
+  const [group, error] = mainPart.split(".");
+  if (!group || !error) {
+    (_a = logger()) == null ? void 0 : _a.warn({ msg: "failed to parse close reason", reason });
+    return void 0;
+  }
+  return {
+    group,
+    error,
+    rayId
+  };
+}
+var U16_MAX = 65535;
+function wrappingLtU16(a, b) {
+  return a !== b && wrappingSub(b, a, U16_MAX) < U16_MAX / 2;
+}
+function wrappingLteU16(a, b) {
+  return a === b || wrappingLtU16(a, b);
+}
+function wrappingAddU16(a, b) {
+  return (a + b) % (U16_MAX + 1);
+}
+function wrappingSubU16(a, b) {
+  return wrappingSub(a, b, U16_MAX);
+}
+function wrappingSub(a, b, max) {
+  const result = a - b;
+  if (result < 0) {
+    return result + max + 1;
+  }
+  return result;
+}
+function arraysEqual(a, b) {
+  const ua = new Uint8Array(a);
+  const ub = new Uint8Array(b);
+  if (ua.length !== ub.length) return false;
+  for (let i = 0; i < ua.length; i++) {
+    if (ua[i] !== ub[i]) return false;
+  }
+  return true;
+}
+function promiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+function idToStr(id) {
+  const bytes = new Uint8Array(id);
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+
+// src/actor.ts
+var RunnerActor = class {
+  constructor(actorId, generation, config, hibernatingRequests) {
+    this.hibernatingRequests = hibernatingRequests;
+    this.actorId = actorId;
+    this.generation = generation;
+    this.config = config;
+    this.actorStartPromise = promiseWithResolvers();
+  }
+  actorId;
+  generation;
+  config;
+  pendingRequests = [];
+  webSockets = [];
+  actorStartPromise;
+  /**
+   * If restoreHibernatingRequests has been called. This is used to assert
+   * that the caller is implemented correctly.
+   **/
+  hibernationRestored = false;
+  // Pending request methods
+  getPendingRequest(gatewayId, requestId) {
+    var _a;
+    return (_a = this.pendingRequests.find(
+      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+    )) == null ? void 0 : _a.request;
+  }
+  createPendingRequest(gatewayId, requestId, clientMessageIndex) {
+    var _a, _b;
+    const exists = this.getPendingRequest(gatewayId, requestId) !== void 0;
+    if (exists) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "attempting to set pending request twice, replacing existing",
+        gatewayId: idToStr(gatewayId),
+        requestId: idToStr(requestId)
+      });
+      this.deletePendingRequest(gatewayId, requestId);
+    }
+    this.pendingRequests.push({
+      gatewayId,
+      requestId,
+      request: {
+        resolve: () => {
+        },
+        reject: () => {
+        },
+        actorId: this.actorId,
+        gatewayId,
+        requestId,
+        clientMessageIndex
+      }
+    });
+    (_b = logger()) == null ? void 0 : _b.debug({
+      msg: "added pending request",
+      gatewayId: idToStr(gatewayId),
+      requestId: idToStr(requestId),
+      length: this.pendingRequests.length
+    });
+  }
+  createPendingRequestWithStreamController(gatewayId, requestId, clientMessageIndex, streamController) {
+    var _a, _b;
+    const exists = this.getPendingRequest(gatewayId, requestId) !== void 0;
+    if (exists) {
+      (_a = logger()) == null ? void 0 : _a.warn({
+        msg: "attempting to set pending request twice, replacing existing",
+        gatewayId: idToStr(gatewayId),
+        requestId: idToStr(requestId)
+      });
+      this.deletePendingRequest(gatewayId, requestId);
+    }
+    this.pendingRequests.push({
+      gatewayId,
+      requestId,
+      request: {
+        resolve: () => {
+        },
+        reject: () => {
+        },
+        actorId: this.actorId,
+        gatewayId,
+        requestId,
+        clientMessageIndex,
+        streamController
+      }
+    });
+    (_b = logger()) == null ? void 0 : _b.debug({
+      msg: "added pending request with stream controller",
+      gatewayId: idToStr(gatewayId),
+      requestId: idToStr(requestId),
+      length: this.pendingRequests.length
+    });
+  }
+  deletePendingRequest(gatewayId, requestId) {
+    var _a;
+    const index = this.pendingRequests.findIndex(
+      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+    );
+    if (index !== -1) {
+      this.pendingRequests.splice(index, 1);
+      (_a = logger()) == null ? void 0 : _a.debug({
+        msg: "removed pending request",
+        gatewayId: idToStr(gatewayId),
+        requestId: idToStr(requestId),
+        length: this.pendingRequests.length
+      });
+    }
+  }
+  // WebSocket methods
+  getWebSocket(gatewayId, requestId) {
+    var _a;
+    return (_a = this.webSockets.find(
+      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+    )) == null ? void 0 : _a.ws;
+  }
+  setWebSocket(gatewayId, requestId, ws) {
+    var _a;
+    const exists = this.getWebSocket(gatewayId, requestId) !== void 0;
+    if (exists) {
+      (_a = logger()) == null ? void 0 : _a.warn({ msg: "attempting to set websocket twice" });
+      return;
+    }
+    this.webSockets.push({ gatewayId, requestId, ws });
+  }
+  deleteWebSocket(gatewayId, requestId) {
+    const index = this.webSockets.findIndex(
+      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+    );
+    if (index !== -1) {
+      this.webSockets.splice(index, 1);
+    }
+  }
+};
+
 // src/stringify.ts
 function stringifyArrayBuffer(buffer) {
   return `ArrayBuffer(${buffer.byteLength})`;
@@ -21,10 +228,13 @@ 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 "TunnelAck":
-      return "TunnelAck";
+    case "DeprecatedTunnelAck":
+      return "DeprecatedTunnelAck";
     case "ToServerResponseStart": {
       const { status, headers, body, stream } = kind.val;
       const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -37,8 +247,8 @@ function stringifyToServerTunnelMessageKind(kind) {
     case "ToServerResponseAbort":
       return "ToServerResponseAbort";
     case "ToServerWebSocketOpen": {
-      const { canHibernate, lastMsgIndex } = kind.val;
-      return `ToServerWebSocketOpen{canHibernate: ${canHibernate}, lastMsgIndex: ${stringifyBigInt(lastMsgIndex)}}`;
+      const { canHibernate } = kind.val;
+      return `ToServerWebSocketOpen{canHibernate: ${canHibernate}}`;
     }
     case "ToServerWebSocketMessage": {
       const { data, binary } = kind.val;
@@ -49,17 +259,17 @@ function stringifyToServerTunnelMessageKind(kind) {
       return `ToServerWebSocketMessageAck{index: ${index}}`;
     }
     case "ToServerWebSocketClose": {
-      const { code, reason, retry } = kind.val;
+      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}, retry: ${retry}}`;
+      return `ToServerWebSocketClose{code: ${codeStr}, reason: ${reasonStr}, hibernate: ${hibernate}}`;
     }
   }
 }
 function stringifyToClientTunnelMessageKind(kind) {
   switch (kind.tag) {
-    case "TunnelAck":
-      return "TunnelAck";
+    case "DeprecatedTunnelAck":
+      return "DeprecatedTunnelAck";
     case "ToClientRequestStart": {
       const { actorId, method, path, headers, body, stream } = kind.val;
       const bodyStr = body === null ? "null" : stringifyArrayBuffer(body);
@@ -76,8 +286,8 @@ function stringifyToClientTunnelMessageKind(kind) {
       return `ToClientWebSocketOpen{actorId: "${actorId}", path: "${path}", headers: ${stringifyMap(headers)}}`;
     }
     case "ToClientWebSocketMessage": {
-      const { index, data, binary } = kind.val;
-      return `ToClientWebSocketMessage{index: ${index}, data: ${stringifyArrayBuffer(data)}, binary: ${binary}}`;
+      const { data, binary } = kind.val;
+      return `ToClientWebSocketMessage{data: ${stringifyArrayBuffer(data)}, binary: ${binary}}`;
     }
     case "ToClientWebSocketClose": {
       const { code, reason } = kind.val;
@@ -90,10 +300,11 @@ function stringifyToClientTunnelMessageKind(kind) {
 function stringifyCommand(command) {
   switch (command.tag) {
     case "CommandStartActor": {
-      const { actorId, generation, config } = command.val;
+      const { actorId, generation, config, hibernatingRequests } = command.val;
       const keyStr = config.key === null ? "null" : `"${config.key}"`;
       const inputStr = config.input === null ? "null" : stringifyArrayBuffer(config.input);
-      return `CommandStartActor{actorId: "${actorId}", generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}}`;
+      const hibernatingRequestsStr = hibernatingRequests.length > 0 ? `[${hibernatingRequests.map((hr) => `{gatewayId: ${idToStr(hr.gatewayId)}, requestId: ${idToStr(hr.requestId)}}`).join(", ")}]` : "[]";
+      return `CommandStartActor{actorId: "${actorId}", generation: ${generation}, config: {name: "${config.name}", key: ${keyStr}, createTs: ${stringifyBigInt(config.createTs)}, input: ${inputStr}}, hibernatingRequests: ${hibernatingRequestsStr}}`;
     }
     case "CommandStopActor": {
       const { actorId, generation } = command.val;
@@ -132,45 +343,163 @@ function stringifyEvent(event) {
     }
   }
 }
-
-// src/tunnel.ts
-import { stringify as uuidstringify, v4 as uuidv4 } from "uuid";
-
-// src/utils.ts
-function unreachable(x) {
-  throw `Unreachable: ${x}`;
+function stringifyEventWrapper(wrapper) {
+  return `EventWrapper{index: ${stringifyBigInt(wrapper.index)}, inner: ${stringifyEvent(wrapper.inner)}}`;
 }
-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);
+function stringifyToServer(message) {
+  switch (message.tag) {
+    case "ToServerInit": {
+      const {
+        name,
+        version,
+        totalSlots,
+        lastCommandIdx,
+        prepopulateActorNames,
+        metadata
+      } = message.val;
+      const lastCommandIdxStr = lastCommandIdx === null ? "null" : stringifyBigInt(lastCommandIdx);
+      const prepopulateActorNamesStr = prepopulateActorNames === null ? "null" : `Map(${prepopulateActorNames.size})`;
+      const metadataStr = metadata === null ? "null" : `"${metadata}"`;
+      return `ToServerInit{name: "${name}", version: ${version}, totalSlots: ${totalSlots}, lastCommandIdx: ${lastCommandIdxStr}, prepopulateActorNames: ${prepopulateActorNamesStr}, metadata: ${metadataStr}}`;
+    }
+    case "ToServerEvents": {
+      const events = message.val;
+      return `ToServerEvents{count: ${events.length}, events: [${events.map((e) => stringifyEventWrapper(e)).join(", ")}]}`;
+    }
+    case "ToServerAckCommands": {
+      const { lastCommandIdx } = message.val;
+      return `ToServerAckCommands{lastCommandIdx: ${stringifyBigInt(lastCommandIdx)}}`;
+    }
+    case "ToServerStopping":
+      return "ToServerStopping";
+    case "ToServerPing": {
+      const { ts } = message.val;
+      return `ToServerPing{ts: ${stringifyBigInt(ts)}}`;
+    }
+    case "ToServerKvRequest": {
+      const { actorId, requestId, data } = message.val;
+      const dataStr = stringifyKvRequestData(data);
+      return `ToServerKvRequest{actorId: "${actorId}", requestId: ${requestId}, data: ${dataStr}}`;
+    }
+    case "ToServerTunnelMessage": {
+      const { messageId, messageKind } = message.val;
+      return `ToServerTunnelMessage{messageId: ${stringifyMessageId(messageId)}, messageKind: ${stringifyToServerTunnelMessageKind(messageKind)}}`;
+    }
   }
-  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;
+function stringifyToClient(message) {
+  switch (message.tag) {
+    case "ToClientInit": {
+      const { runnerId, lastEventIdx, metadata } = message.val;
+      const metadataStr = `{runnerLostThreshold: ${stringifyBigInt(metadata.runnerLostThreshold)}}`;
+      return `ToClientInit{runnerId: "${runnerId}", lastEventIdx: ${stringifyBigInt(lastEventIdx)}, metadata: ${metadataStr}}`;
+    }
+    case "ToClientClose":
+      return "ToClientClose";
+    case "ToClientCommands": {
+      const commands = message.val;
+      return `ToClientCommands{count: ${commands.length}, commands: [${commands.map((c) => stringifyCommandWrapper(c)).join(", ")}]}`;
+    }
+    case "ToClientAckEvents": {
+      const { lastEventIdx } = message.val;
+      return `ToClientAckEvents{lastEventIdx: ${stringifyBigInt(lastEventIdx)}}`;
+    }
+    case "ToClientKvResponse": {
+      const { requestId, data } = message.val;
+      const dataStr = stringifyKvResponseData(data);
+      return `ToClientKvResponse{requestId: ${requestId}, data: ${dataStr}}`;
+    }
+    case "ToClientTunnelMessage": {
+      const { messageId, messageKind } = message.val;
+      return `ToClientTunnelMessage{messageId: ${stringifyMessageId(messageId)}, messageKind: ${stringifyToClientTunnelMessageKind(messageKind)}}`;
+    }
+  }
+}
+function stringifyKvRequestData(data) {
+  switch (data.tag) {
+    case "KvGetRequest": {
+      const { keys } = data.val;
+      return `KvGetRequest{keys: ${keys.length}}`;
+    }
+    case "KvListRequest": {
+      const { query, reverse, limit } = data.val;
+      const reverseStr = reverse === null ? "null" : reverse.toString();
+      const limitStr = limit === null ? "null" : stringifyBigInt(limit);
+      return `KvListRequest{query: ${stringifyKvListQuery(query)}, reverse: ${reverseStr}, limit: ${limitStr}}`;
+    }
+    case "KvPutRequest": {
+      const { keys, values } = data.val;
+      return `KvPutRequest{keys: ${keys.length}, values: ${values.length}}`;
+    }
+    case "KvDeleteRequest": {
+      const { keys } = data.val;
+      return `KvDeleteRequest{keys: ${keys.length}}`;
+    }
+    case "KvDropRequest":
+      return "KvDropRequest";
+  }
+}
+function stringifyKvListQuery(query) {
+  switch (query.tag) {
+    case "KvListAllQuery":
+      return "KvListAllQuery";
+    case "KvListRangeQuery": {
+      const { start, end, exclusive } = query.val;
+      return `KvListRangeQuery{start: ${stringifyArrayBuffer(start)}, end: ${stringifyArrayBuffer(end)}, exclusive: ${exclusive}}`;
+    }
+    case "KvListPrefixQuery": {
+      const { key } = query.val;
+      return `KvListPrefixQuery{key: ${stringifyArrayBuffer(key)}}`;
+    }
+  }
+}
+function stringifyKvResponseData(data) {
+  switch (data.tag) {
+    case "KvErrorResponse": {
+      const { message } = data.val;
+      return `KvErrorResponse{message: "${message}"}`;
+    }
+    case "KvGetResponse": {
+      const { keys, values, metadata } = data.val;
+      return `KvGetResponse{keys: ${keys.length}, values: ${values.length}, metadata: ${metadata.length}}`;
+    }
+    case "KvListResponse": {
+      const { keys, values, metadata } = data.val;
+      return `KvListResponse{keys: ${keys.length}, values: ${values.length}, metadata: ${metadata.length}}`;
+    }
+    case "KvPutResponse":
+      return "KvPutResponse";
+    case "KvDeleteResponse":
+      return "KvDeleteResponse";
+    case "KvDropResponse":
+      return "KvDropResponse";
   }
-  return {
-    group,
-    error,
-    rayId
-  };
 }
 
 // src/websocket-tunnel-adapter.ts
+var HIBERNATABLE_SYMBOL = Symbol("hibernatable");
 var WebSocketTunnelAdapter = class {
-  #webSocketId;
+  constructor(tunnel, actorId, requestId, serverMessageIndex, hibernatable, isRestoringHibernatable, request, sendCallback, closeCallback) {
+    this.request = request;
+    var _a;
+    this.#tunnel = tunnel;
+    this.#actorId = actorId;
+    this.#requestId = requestId;
+    this.#hibernatable = hibernatable;
+    this.#serverMessageIndex = serverMessageIndex;
+    this.#sendCallback = sendCallback;
+    this.#closeCallback = closeCallback;
+    if (isRestoringHibernatable) {
+      (_a = this.#log) == null ? void 0 : _a.debug({
+        msg: "setting WebSocket to OPEN state for restored connection",
+        actorId: this.#actorId,
+        requestId: this.#requestId,
+        hibernatable: this.#hibernatable
+      });
+      this.#readyState = 1;
+    }
+  }
+  // MARK: - WebSocket Compat Variables
   #readyState = 0;
   // CONNECTING
   #eventListeners = /* @__PURE__ */ new Map();
@@ -183,195 +512,143 @@ var WebSocketTunnelAdapter = class {
   #extensions = "";
   #protocol = "";
   #url = "";
+  // mARK: - Internal State
+  #tunnel;
+  #actorId;
+  #requestId;
+  #hibernatable;
+  #serverMessageIndex;
+  get [HIBERNATABLE_SYMBOL]() {
+    return this.#hibernatable;
+  }
+  /**
+   * Called when sending a message from this WebSocket.
+   *
+   * Used to send a tunnel message from Tunnel.
+   */
   #sendCallback;
+  /**
+   * Called when closing this WebSocket.
+   *
+   * Used to send a tunnel message from Tunnel
+   */
   #closeCallback;
-  #canHibernate = false;
-  // Event buffering for events fired before listeners are attached
-  #bufferedEvents = [];
-  constructor(webSocketId, sendCallback, closeCallback) {
-    this.#webSocketId = webSocketId;
-    this.#sendCallback = sendCallback;
-    this.#closeCallback = closeCallback;
-  }
-  get readyState() {
-    return this.#readyState;
+  get #log() {
+    return this.#tunnel.log;
   }
+  // MARK: - Lifecycle
   get bufferedAmount() {
     return this.#bufferedAmount;
   }
-  get binaryType() {
-    return this.#binaryType;
-  }
-  set binaryType(value) {
-    if (value === "nodebuffer" || value === "arraybuffer" || value === "blob") {
-      this.#binaryType = value;
-    }
-  }
-  get extensions() {
-    return this.#extensions;
-  }
-  get protocol() {
-    return this.#protocol;
-  }
-  get url() {
-    return this.#url;
-  }
-  /** @experimental */
-  get canHibernate() {
-    return this.#canHibernate;
-  }
-  /** @experimental */
-  set canHibernate(value) {
-    this.#canHibernate = value;
-  }
-  get onopen() {
-    return this.#onopen;
-  }
-  set onopen(value) {
-    this.#onopen = value;
-    if (value) {
-      this.#flushBufferedEvents("open");
-    }
-  }
-  get onclose() {
-    return this.#onclose;
-  }
-  set onclose(value) {
-    this.#onclose = value;
-    if (value) {
-      this.#flushBufferedEvents("close");
-    }
-  }
-  get onerror() {
-    return this.#onerror;
-  }
-  set onerror(value) {
-    this.#onerror = value;
-    if (value) {
-      this.#flushBufferedEvents("error");
-    }
-  }
-  get onmessage() {
-    return this.#onmessage;
-  }
-  set onmessage(value) {
-    this.#onmessage = value;
-    if (value) {
-      this.#flushBufferedEvents("message");
+  _handleOpen(requestId) {
+    if (this.#readyState !== 0) {
+      return;
     }
+    this.#readyState = 1;
+    const event = {
+      type: "open",
+      rivetRequestId: requestId,
+      target: this
+    };
+    this.#fireEvent("open", event);
   }
-  send(data) {
+  _handleMessage(requestId, data, serverMessageIndex, isBinary) {
+    var _a, _b, _c;
     if (this.#readyState !== 1) {
-      throw new Error("WebSocket is not open");
+      (_a = this.#log) == null ? void 0 : _a.warn({
+        msg: "WebSocket message ignored - not in OPEN state",
+        requestId: this.#requestId,
+        actorId: this.#actorId,
+        currentReadyState: this.#readyState,
+        expectedReadyState: 1,
+        serverMessageIndex,
+        hibernatable: this.#hibernatable
+      });
+      return true;
+    }
+    if (this.#hibernatable) {
+      const previousIndex = this.#serverMessageIndex;
+      if (wrappingLteU16(serverMessageIndex, previousIndex)) {
+        (_b = this.#log) == null ? void 0 : _b.info({
+          msg: "received duplicate hibernating websocket message, this indicates the actor failed to ack the message index before restarting",
+          requestId,
+          actorId: this.#actorId,
+          previousIndex,
+          expectedIndex: wrappingAddU16(previousIndex, 1),
+          receivedIndex: serverMessageIndex
+        });
+        return true;
+      }
+      const expectedIndex = wrappingAddU16(previousIndex, 1);
+      if (serverMessageIndex !== expectedIndex) {
+        const closeReason = "ws.message_index_skip";
+        (_c = this.#log) == null ? void 0 : _c.warn({
+          msg: "hibernatable websocket message index out of sequence, closing connection",
+          requestId,
+          actorId: this.#actorId,
+          previousIndex,
+          expectedIndex,
+          receivedIndex: serverMessageIndex,
+          closeReason,
+          gap: wrappingSubU16(
+            wrappingSubU16(serverMessageIndex, previousIndex),
+            1
+          )
+        });
+        this.close(1008, closeReason);
+        return true;
+      }
+      this.#serverMessageIndex = serverMessageIndex;
     }
-    let isBinary = false;
     let messageData;
-    if (typeof data === "string") {
-      messageData = data;
-    } else if (data instanceof ArrayBuffer) {
-      isBinary = true;
-      messageData = data;
-    } else if (ArrayBuffer.isView(data)) {
-      isBinary = true;
-      const view = data;
-      if (view.buffer instanceof SharedArrayBuffer) {
-        const bytes = new Uint8Array(
-          view.buffer,
-          view.byteOffset,
-          view.byteLength
-        );
-        messageData = bytes.buffer.slice(
-          bytes.byteOffset,
-          bytes.byteOffset + bytes.byteLength
-        );
+    if (isBinary) {
+      if (this.#binaryType === "nodebuffer") {
+        messageData = Buffer.from(data);
+      } else if (this.#binaryType === "arraybuffer") {
+        if (data instanceof Uint8Array) {
+          messageData = data.buffer.slice(
+            data.byteOffset,
+            data.byteOffset + data.byteLength
+          );
+        } else {
+          messageData = data;
+        }
       } else {
-        messageData = view.buffer.slice(
-          view.byteOffset,
-          view.byteOffset + view.byteLength
-        );
-      }
-    } else if (data instanceof Blob) {
-      throw new Error("Blob sending not implemented in tunnel adapter");
-    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
-      isBinary = true;
-      const buf = data;
-      if (buf.buffer instanceof SharedArrayBuffer) {
-        const bytes = new Uint8Array(
-          buf.buffer,
-          buf.byteOffset,
-          buf.byteLength
-        );
-        messageData = bytes.buffer.slice(
-          bytes.byteOffset,
-          bytes.byteOffset + bytes.byteLength
-        );
-      } else {
-        messageData = buf.buffer.slice(
-          buf.byteOffset,
-          buf.byteOffset + buf.byteLength
+        throw new Error(
+          "Blob binaryType not supported in tunnel adapter"
         );
       }
     } else {
-      throw new Error("Invalid data type");
-    }
-    this.#sendCallback(messageData, isBinary);
-  }
-  close(code, reason) {
-    this.closeInner(code, reason, false, true);
-  }
-  __closeWithRetry(code, reason) {
-    this.closeInner(code, reason, true, true);
-  }
-  __closeWithoutCallback(code, reason) {
-    this.closeInner(code, reason, false, false);
-  }
-  closeInner(code, reason, retry, callback) {
-    if (this.#readyState === 2 || // CLOSING
-    this.#readyState === 3) {
-      return;
-    }
-    this.#readyState = 2;
-    if (callback) {
-      this.#closeCallback(code, reason, retry);
+      messageData = data;
     }
-    this.#readyState = 3;
-    const closeEvent = {
-      wasClean: true,
-      code: code || 1e3,
-      reason: reason || "",
-      type: "close",
+    const event = {
+      type: "message",
+      data: messageData,
+      rivetRequestId: requestId,
+      rivetMessageIndex: serverMessageIndex,
       target: this
     };
-    this.#fireEvent("close", closeEvent);
+    this.#fireEvent("message", event);
+    return false;
   }
-  addEventListener(type, listener, options) {
-    if (typeof listener === "function") {
-      let listeners = this.#eventListeners.get(type);
-      if (!listeners) {
-        listeners = /* @__PURE__ */ new Set();
-        this.#eventListeners.set(type, listeners);
-      }
-      listeners.add(listener);
-      this.#flushBufferedEvents(type);
-    }
+  _handleClose(_requestId, code, reason) {
+    this.#closeInner(code, reason, true);
   }
-  removeEventListener(type, listener, options) {
-    if (typeof listener === "function") {
-      const listeners = this.#eventListeners.get(type);
-      if (listeners) {
-        listeners.delete(listener);
-      }
-    }
+  _handleError(error) {
+    const event = {
+      type: "error",
+      target: this,
+      error
+    };
+    this.#fireEvent("error", event);
   }
-  dispatchEvent(event) {
-    return true;
+  _closeWithoutCallback(code, reason) {
+    this.#closeInner(code, reason, false);
   }
   #fireEvent(type, event) {
     var _a, _b, _c, _d, _e;
     const listeners = this.#eventListeners.get(type);
-    let hasListeners = false;
     if (listeners && listeners.size > 0) {
-      hasListeners = true;
       for (const listener of listeners) {
         try {
           listener.call(this, event);
@@ -387,7 +664,6 @@ var WebSocketTunnelAdapter = class {
     switch (type) {
       case "open":
         if (this.#onopen) {
-          hasListeners = true;
           try {
             this.#onopen.call(this, event);
           } catch (error) {
@@ -400,7 +676,6 @@ var WebSocketTunnelAdapter = class {
         break;
       case "close":
         if (this.#onclose) {
-          hasListeners = true;
           try {
             this.#onclose.call(this, event);
           } catch (error) {
@@ -413,7 +688,6 @@ var WebSocketTunnelAdapter = class {
         break;
       case "error":
         if (this.#onerror) {
-          hasListeners = true;
           try {
             this.#onerror.call(this, event);
           } catch (error) {
@@ -426,7 +700,6 @@ var WebSocketTunnelAdapter = class {
         break;
       case "message":
         if (this.#onmessage) {
-          hasListeners = true;
           try {
             this.#onmessage.call(this, event);
           } catch (error) {
@@ -438,163 +711,161 @@ var WebSocketTunnelAdapter = class {
         }
         break;
     }
-    if (!hasListeners) {
-      this.#bufferedEvents.push({ type, event });
-    }
-  }
-  #flushBufferedEvents(type) {
-    var _a, _b, _c, _d, _e;
-    const eventsToFlush = this.#bufferedEvents.filter(
-      (buffered) => buffered.type === type
-    );
-    this.#bufferedEvents = this.#bufferedEvents.filter(
-      (buffered) => buffered.type !== type
-    );
-    for (const { event } of eventsToFlush) {
-      const listeners = this.#eventListeners.get(type);
-      if (listeners) {
-        for (const listener of listeners) {
-          try {
-            listener.call(this, event);
-          } catch (error) {
-            (_a = logger()) == null ? void 0 : _a.error({
-              msg: "error in websocket event listener",
-              error,
-              type
-            });
-          }
-        }
-      }
-      switch (type) {
-        case "open":
-          if (this.#onopen) {
-            try {
-              this.#onopen.call(this, event);
-            } catch (error) {
-              (_b = logger()) == null ? void 0 : _b.error({
-                msg: "error in onopen handler",
-                error
-              });
-            }
-          }
-          break;
-        case "close":
-          if (this.#onclose) {
-            try {
-              this.#onclose.call(this, event);
-            } catch (error) {
-              (_c = logger()) == null ? void 0 : _c.error({
-                msg: "error in onclose handler",
-                error
-              });
-            }
-          }
-          break;
-        case "error":
-          if (this.#onerror) {
-            try {
-              this.#onerror.call(this, event);
-            } catch (error) {
-              (_d = logger()) == null ? void 0 : _d.error({
-                msg: "error in onerror handler",
-                error
-              });
-            }
-          }
-          break;
-        case "message":
-          if (this.#onmessage) {
-            try {
-              this.#onmessage.call(this, event);
-            } catch (error) {
-              (_e = logger()) == null ? void 0 : _e.error({
-                msg: "error in onmessage handler",
-                error
-              });
-            }
-          }
-          break;
-      }
-    }
   }
-  // Internal methods called by the Tunnel class
-  _handleOpen(requestId) {
-    if (this.#readyState !== 0) {
+  #closeInner(code, reason, callback) {
+    if (this.#readyState === 2 || // CLOSING
+    this.#readyState === 3) {
       return;
     }
-    this.#readyState = 1;
-    const event = {
-      type: "open",
-      rivetRequestId: requestId,
+    this.#readyState = 2;
+    if (callback) {
+      this.#closeCallback(code, reason);
+    }
+    this.#readyState = 3;
+    const closeEvent = {
+      wasClean: true,
+      code: code || 1e3,
+      reason: reason || "",
+      type: "close",
       target: this
     };
-    this.#fireEvent("open", event);
+    this.#fireEvent("close", closeEvent);
   }
-  /// Returns false if the message was sent off.
-  _handleMessage(requestId, data, index, isBinary) {
-    if (this.#readyState !== 1) {
-      return true;
+  // MARK: - WebSocket Compatible API
+  get readyState() {
+    return this.#readyState;
+  }
+  get binaryType() {
+    return this.#binaryType;
+  }
+  set binaryType(value) {
+    if (value === "nodebuffer" || value === "arraybuffer" || value === "blob") {
+      this.#binaryType = value;
+    }
+  }
+  get extensions() {
+    return this.#extensions;
+  }
+  get protocol() {
+    return this.#protocol;
+  }
+  get url() {
+    return this.#url;
+  }
+  get onopen() {
+    return this.#onopen;
+  }
+  set onopen(value) {
+    this.#onopen = value;
+  }
+  get onclose() {
+    return this.#onclose;
+  }
+  set onclose(value) {
+    this.#onclose = value;
+  }
+  get onerror() {
+    return this.#onerror;
+  }
+  set onerror(value) {
+    this.#onerror = value;
+  }
+  get onmessage() {
+    return this.#onmessage;
+  }
+  set onmessage(value) {
+    this.#onmessage = value;
+  }
+  send(data) {
+    if (this.#readyState === 0) {
+      throw new DOMException(
+        "WebSocket is still in CONNECTING state",
+        "InvalidStateError"
+      );
+    }
+    if (this.#readyState === 2 || this.#readyState === 3) {
+      return;
     }
+    let isBinary = false;
     let messageData;
-    if (isBinary) {
-      if (this.#binaryType === "nodebuffer") {
-        messageData = Buffer.from(data);
-      } else if (this.#binaryType === "arraybuffer") {
-        if (data instanceof Uint8Array) {
-          messageData = data.buffer.slice(
-            data.byteOffset,
-            data.byteOffset + data.byteLength
-          );
-        } else {
-          messageData = data;
-        }
+    if (typeof data === "string") {
+      messageData = data;
+    } else if (data instanceof ArrayBuffer) {
+      isBinary = true;
+      messageData = data;
+    } else if (ArrayBuffer.isView(data)) {
+      isBinary = true;
+      const view = data;
+      if (view.buffer instanceof SharedArrayBuffer) {
+        const bytes = new Uint8Array(
+          view.buffer,
+          view.byteOffset,
+          view.byteLength
+        );
+        messageData = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
       } else {
-        throw new Error(
-          "Blob binaryType not supported in tunnel adapter"
+        messageData = view.buffer.slice(
+          view.byteOffset,
+          view.byteOffset + view.byteLength
+        );
+      }
+    } else if (data instanceof Blob) {
+      throw new Error("Blob sending not implemented in tunnel adapter");
+    } else if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
+      isBinary = true;
+      const buf = data;
+      if (buf.buffer instanceof SharedArrayBuffer) {
+        const bytes = new Uint8Array(
+          buf.buffer,
+          buf.byteOffset,
+          buf.byteLength
+        );
+        messageData = bytes.buffer.slice(
+          bytes.byteOffset,
+          bytes.byteOffset + bytes.byteLength
+        );
+      } else {
+        messageData = buf.buffer.slice(
+          buf.byteOffset,
+          buf.byteOffset + buf.byteLength
         );
       }
     } else {
-      messageData = data;
+      throw new Error("Invalid data type");
     }
-    const event = {
-      type: "message",
-      data: messageData,
-      rivetRequestId: requestId,
-      rivetMessageIndex: index,
-      target: this
-    };
-    this.#fireEvent("message", event);
-    return false;
+    this.#sendCallback(messageData, isBinary);
   }
-  _handleClose(requestId, code, reason) {
-    if (this.#readyState === 3) {
-      return;
+  close(code, reason) {
+    this.#closeInner(code, reason, true);
+  }
+  addEventListener(type, listener, options) {
+    if (typeof listener === "function") {
+      let listeners = this.#eventListeners.get(type);
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        this.#eventListeners.set(type, listeners);
+      }
+      listeners.add(listener);
     }
-    this.#readyState = 3;
-    const event = {
-      type: "close",
-      wasClean: true,
-      code: code || 1e3,
-      reason: reason || "",
-      rivetRequestId: requestId,
-      target: this
-    };
-    this.#fireEvent("close", event);
   }
-  _handleError(error) {
-    const event = {
-      type: "error",
-      target: this,
-      error
-    };
-    this.#fireEvent("error", event);
+  removeEventListener(type, listener, options) {
+    if (typeof listener === "function") {
+      const listeners = this.#eventListeners.get(type);
+      if (listeners) {
+        listeners.delete(listener);
+      }
+    }
+  }
+  dispatchEvent(event) {
+    return true;
   }
-  // WebSocket constants for compatibility
   static CONNECTING = 0;
   static OPEN = 1;
   static CLOSING = 2;
   static CLOSED = 3;
-  // Instance constants
   CONNECTING = 0;
   OPEN = 1;
   CLOSING = 2;
@@ -606,6 +877,7 @@ var WebSocketTunnelAdapter = class {
   pong(data, mask, cb) {
     if (cb) cb(new Error("Pong not supported in tunnel adapter"));
   }
+  /** @experimental */
   terminate() {
     this.#readyState = 3;
     this.#closeCallback(1006, "Abnormal Closure");
@@ -621,8 +893,6 @@ var WebSocketTunnelAdapter = class {
 };
 
 // src/tunnel.ts
-var GC_INTERVAL = 6e4;
-var MESSAGE_ACK_TIMEOUT = 5e3;
 var RunnerShutdownError = class extends Error {
   constructor() {
     super("Runner shut down");
@@ -630,13 +900,10 @@ var RunnerShutdownError = class extends Error {
 };
 var Tunnel = class {
   #runner;
-  /** Requests over the tunnel to the actor that are in flight. */
-  #actorPendingRequests = /* @__PURE__ */ new Map();
-  /** WebSockets over the tunnel to the actor that are in flight. */
-  #actorWebSockets = /* @__PURE__ */ new Map();
-  /** Messages sent from the actor over the tunnel that have not been acked by the gateway. */
-  #pendingTunnelMessages = /* @__PURE__ */ new Map();
-  #gcInterval;
+  /** Maps request IDs to actor IDs for lookup */
+  #requestToActor = [];
+  /** Buffer for messages when not connected */
+  #bufferedMessages = [];
   get log() {
     return this.#runner.log;
   }
@@ -644,145 +911,367 @@ var Tunnel = class {
     this.#runner = runner;
   }
   start() {
-    this.#startGarbageCollector();
+  }
+  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() {
-    if (this.#gcInterval) {
-      clearInterval(this.#gcInterval);
-      this.#gcInterval = void 0;
+    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`
+      );
     }
-    for (const [_, request] of this.#actorPendingRequests) {
-      request.reject(new RunnerShutdownError());
+    if (actor.hibernationRestored) {
+      throw new Error(
+        `Actor ${actorId} already restored hibernating requests`
+      );
+    }
+    (_a = this.log) == null ? void 0 : _a.debug({
+      msg: "restoring hibernating requests",
+      actorId,
+      requests: actor.hibernatingRequests.length
+    });
+    const backgroundOperations = [];
+    let connectedButNotLoadedCount = 0;
+    let restoredCount = 0;
+    for (const { gatewayId, requestId } of actor.hibernatingRequests) {
+      const requestIdStr = idToStr(requestId);
+      const meta = metaEntries.find(
+        (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+      );
+      if (!meta) {
+        (_b = this.log) == null ? void 0 : _b.warn({
+          msg: "closing websocket that is not persisted",
+          requestId: requestIdStr
+        });
+        this.#sendMessage(gatewayId, requestId, {
+          tag: "ToServerWebSocketClose",
+          val: {
+            code: 1e3,
+            reason: "ws.meta_not_found_during_restore",
+            hibernate: false
+          }
+        });
+        connectedButNotLoadedCount++;
+      } else {
+        const request = buildRequestForWebSocket(
+          meta.path,
+          meta.headers
+        );
+        const restoreOperation = this.#createWebSocket(
+          actorId,
+          gatewayId,
+          requestId,
+          requestIdStr,
+          meta.serverMessageIndex,
+          true,
+          true,
+          request,
+          meta.path,
+          meta.headers,
+          false
+        ).then(() => {
+          var _a2;
+          const actor2 = this.#runner.getActor(actorId);
+          if (actor2) {
+            actor2.createPendingRequest(
+              gatewayId,
+              requestId,
+              meta.clientMessageIndex
+            );
+          }
+          (_a2 = this.log) == null ? void 0 : _a2.info({
+            msg: "connection successfully restored",
+            actorId,
+            requestId: requestIdStr
+          });
+        }).catch((err) => {
+          var _a2;
+          (_a2 = this.log) == null ? void 0 : _a2.error({
+            msg: "error creating websocket during restore",
+            requestId: requestIdStr,
+            err
+          });
+          this.#sendMessage(gatewayId, requestId, {
+            tag: "ToServerWebSocketClose",
+            val: {
+              code: 1011,
+              reason: "ws.restore_error",
+              hibernate: false
+            }
+          });
+        });
+        backgroundOperations.push(restoreOperation);
+        restoredCount++;
+      }
     }
-    this.#actorPendingRequests.clear();
-    for (const [_, ws] of this.#actorWebSockets) {
-      if (!ws.canHibernate) {
-        ws.__closeWithoutCallback(1e3, "ws.tunnel_shutdown");
+    let loadedButNotConnectedCount = 0;
+    for (const meta of metaEntries) {
+      const requestIdStr = idToStr(meta.requestId);
+      const isConnected = actor.hibernatingRequests.some(
+        (req) => arraysEqual(req.gatewayId, meta.gatewayId) && arraysEqual(req.requestId, meta.requestId)
+      );
+      if (!isConnected) {
+        (_c = this.log) == null ? void 0 : _c.warn({
+          msg: "removing stale persisted websocket",
+          requestId: requestIdStr
+        });
+        const request = buildRequestForWebSocket(
+          meta.path,
+          meta.headers
+        );
+        const cleanupOperation = this.#createWebSocket(
+          actorId,
+          meta.gatewayId,
+          meta.requestId,
+          requestIdStr,
+          meta.serverMessageIndex,
+          true,
+          true,
+          request,
+          meta.path,
+          meta.headers,
+          true
+        ).then((adapter) => {
+          adapter.close(1e3, "ws.stale_metadata");
+        }).catch((err) => {
+          var _a2;
+          (_a2 = this.log) == null ? void 0 : _a2.error({
+            msg: "error creating stale websocket during restore",
+            requestId: requestIdStr,
+            err
+          });
+        });
+        backgroundOperations.push(cleanupOperation);
+        loadedButNotConnectedCount++;
       }
     }
-    this.#actorWebSockets.clear();
+    await Promise.allSettled(backgroundOperations);
+    actor.hibernationRestored = true;
+    (_d = this.log) == null ? void 0 : _d.info({
+      msg: "restored hibernatable websockets",
+      actorId,
+      restoredCount,
+      connectedButNotLoadedCount,
+      loadedButNotConnectedCount
+    });
   }
-  #sendMessage(requestId, messageKind) {
+  /**
+   * Called from WebSocketOpen message and when restoring hibernatable WebSockets.
+   *
+   * engineAlreadyClosed will be true if this is only being called to trigger
+   * the close callback and not to send a close message to the server. This
+   * is used specifically to clean up zombie WebSocket connections.
+   */
+  async #createWebSocket(actorId, gatewayId, requestId, requestIdStr, serverMessageIndex, isHibernatable, isRestoringHibernatable, request, path, headers, engineAlreadyClosed) {
+    var _a;
+    (_a = this.log) == null ? void 0 : _a.debug({
+      msg: "createWebSocket creating adapter",
+      actorId,
+      requestIdStr,
+      isHibernatable,
+      path
+    });
+    const adapter = new WebSocketTunnelAdapter(
+      this,
+      actorId,
+      requestIdStr,
+      serverMessageIndex,
+      isHibernatable,
+      isRestoringHibernatable,
+      request,
+      (data, isBinary) => {
+        const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data).buffer : data;
+        this.#sendMessage(gatewayId, requestId, {
+          tag: "ToServerWebSocketMessage",
+          val: {
+            data: dataBuffer,
+            binary: isBinary
+          }
+        });
+      },
+      (code, reason) => {
+        if (!engineAlreadyClosed) {
+          this.#sendMessage(gatewayId, requestId, {
+            tag: "ToServerWebSocketClose",
+            val: {
+              code: code || null,
+              reason: reason || null,
+              hibernate: false
+            }
+          });
+        }
+        const actor2 = this.#runner.getActor(actorId);
+        if (actor2) {
+          actor2.deleteWebSocket(gatewayId, requestId);
+          actor2.deletePendingRequest(gatewayId, requestId);
+        }
+        this.#removeRequestToActor(gatewayId, requestId);
+      }
+    );
+    const actor = this.#runner.getActor(actorId);
+    if (!actor) {
+      throw new Error(`Actor ${actorId} not found`);
+    }
+    actor.setWebSocket(gatewayId, requestId, adapter);
+    this.addRequestToActor(gatewayId, requestId, actorId);
+    await this.#runner.config.websocket(
+      this.#runner,
+      actorId,
+      adapter,
+      gatewayId,
+      requestId,
+      request,
+      path,
+      headers,
+      isHibernatable,
+      isRestoringHibernatable
+    );
+    return adapter;
+  }
+  addRequestToActor(gatewayId, requestId, actorId) {
+    this.#requestToActor.push({ gatewayId, requestId, actorId });
+  }
+  #removeRequestToActor(gatewayId, requestId) {
+    const index = this.#requestToActor.findIndex(
+      (entry) => arraysEqual(entry.gatewayId, gatewayId) && arraysEqual(entry.requestId, requestId)
+    );
+    if (index !== -1) {
+      this.#requestToActor.splice(index, 1);
+    }
+  }
+  getRequestActor(gatewayId, requestId) {
     var _a, _b;
-    if (!this.#runner.__webSocketReady()) {
+    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: "cannot send tunnel message, socket not connected to engine",
+        msg: "missing requestToActor entry",
+        requestId: idToStr(requestId)
+      });
+      return void 0;
+    }
+    const actor = this.#runner.getActor(entry.actorId);
+    if (!actor) {
+      (_b = this.log) == null ? void 0 : _b.warn({
+        msg: "missing actor for requestToActor lookup",
+        requestId: idToStr(requestId),
+        actorId: entry.actorId
+      });
+      return void 0;
+    }
+    return actor;
+  }
+  async getAndWaitForRequestActor(gatewayId, requestId) {
+    const actor = this.getRequestActor(gatewayId, requestId);
+    if (!actor) return;
+    await actor.actorStartPromise.promise;
+    return actor;
+  }
+  #sendMessage(gatewayId, requestId, messageKind) {
+    var _a, _b, _c, _d;
+    if (!this.#runner.__webSocketReady()) {
+      (_a = this.log) == null ? void 0 : _a.debug({
+        msg: "buffering tunnel message, socket not connected to engine",
         requestId: idToStr(requestId),
         message: stringifyToServerTunnelMessageKind(messageKind)
       });
+      this.#bufferedMessages.push({ gatewayId, requestId, messageKind });
       return;
     }
-    const messageId = generateUuidBuffer();
+    const gatewayIdStr = idToStr(gatewayId);
     const requestIdStr = idToStr(requestId);
-    const messageIdStr = idToStr(messageId);
-    this.#pendingTunnelMessages.set(messageIdStr, {
-      sentAt: Date.now(),
-      requestIdStr
-    });
-    (_b = this.log) == null ? void 0 : _b.debug({
-      msg: "send tunnel msg",
-      requestId: requestIdStr,
+    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: {
-        requestId,
         messageId,
         messageKind
       }
     };
     this.#runner.__sendToServer(message);
   }
-  #sendAck(requestId, messageId) {
-    var _a;
-    if (!this.#runner.__webSocketReady()) {
-      return;
-    }
-    const message = {
-      tag: "ToServerTunnelMessage",
-      val: {
-        requestId,
-        messageId,
-        messageKind: { tag: "TunnelAck", val: null }
-      }
-    };
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "ack tunnel msg",
-      requestId: idToStr(requestId),
-      messageId: idToStr(messageId)
-    });
-    this.#runner.__sendToServer(message);
-  }
-  #startGarbageCollector() {
-    if (this.#gcInterval) {
-      clearInterval(this.#gcInterval);
-    }
-    this.#gcInterval = setInterval(() => {
-      this.#gc();
-    }, GC_INTERVAL);
-  }
-  #gc() {
-    var _a;
-    const now = Date.now();
-    const messagesToDelete = [];
-    for (const [messageId, pendingMessage] of this.#pendingTunnelMessages) {
-      if (now - pendingMessage.sentAt > MESSAGE_ACK_TIMEOUT) {
-        messagesToDelete.push(messageId);
-        const requestIdStr = pendingMessage.requestIdStr;
-        const pendingRequest = this.#actorPendingRequests.get(requestIdStr);
-        if (pendingRequest) {
-          pendingRequest.reject(
-            new Error("Message acknowledgment timeout")
-          );
-          if (pendingRequest.streamController) {
-            pendingRequest.streamController.error(
-              new Error("Message acknowledgment timeout")
-            );
-          }
-          this.#actorPendingRequests.delete(requestIdStr);
-        }
-        const webSocket = this.#actorWebSockets.get(requestIdStr);
-        if (webSocket) {
-          webSocket.__closeWithRetry(
-            1e3,
-            "Message acknowledgment timeout"
-          );
-          this.#actorWebSockets.delete(requestIdStr);
-        }
-      }
-    }
-    if (messagesToDelete.length > 0) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "purging unacked tunnel messages, this indicates that the Rivet Engine is disconnected or not responding",
-        count: messagesToDelete.length
-      });
-      for (const messageId of messagesToDelete) {
-        this.#pendingTunnelMessages.delete(messageId);
-      }
-    }
-  }
   closeActiveRequests(actor) {
     const actorId = actor.actorId;
-    for (const requestId of actor.requests) {
-      const pending = this.#actorPendingRequests.get(requestId);
-      if (pending) {
-        pending.reject(new Error(`Actor ${actorId} stopped`));
-        this.#actorPendingRequests.delete(requestId);
+    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);
       }
     }
-    actor.requests.clear();
-    for (const requestIdStr of actor.webSockets) {
-      const ws = this.#actorWebSockets.get(requestIdStr);
-      if (ws) {
-        ws.__closeWithRetry(1e3, "Actor stopped");
-        this.#actorWebSockets.delete(requestIdStr);
+    for (const entry of actor.webSockets) {
+      const isHibernatable = entry.ws[HIBERNATABLE_SYMBOL];
+      if (!isHibernatable) {
+        entry.ws._closeWithoutCallback(1e3, "actor.stopped");
       }
     }
-    actor.webSockets.clear();
   }
-  async #fetch(actorId, requestId, request) {
+  async #fetch(actorId, gatewayId, requestId, request) {
     var _a;
     if (!this.#runner.hasActor(actorId)) {
       (_a = this.log) == null ? void 0 : _a.warn({
@@ -797,6 +1286,7 @@ var Tunnel = class {
     const fetchHandler = this.#runner.config.fetch(
       this.#runner,
       actorId,
+      gatewayId,
       requestId,
       request
     );
@@ -806,81 +1296,77 @@ var Tunnel = class {
     return fetchHandler;
   }
   async handleTunnelMessage(message) {
-    var _a, _b;
-    const requestIdStr = idToStr(message.requestId);
-    const messageIdStr = idToStr(message.messageId);
-    (_a = this.log) == null ? void 0 : _a.debug({
-      msg: "receive tunnel msg",
-      requestId: requestIdStr,
-      messageId: messageIdStr,
-      message: stringifyToClientTunnelMessageKind(message.messageKind)
-    });
-    if (message.messageKind.tag === "TunnelAck") {
-      const pending = this.#pendingTunnelMessages.get(messageIdStr);
-      if (pending) {
-        const didDelete = this.#pendingTunnelMessages.delete(messageIdStr);
-        if (!didDelete) {
-          (_b = this.log) == null ? void 0 : _b.warn({
-            msg: "received tunnel ack for nonexistent message",
-            requestId: requestIdStr,
-            messageId: messageIdStr
-          });
-        }
-      }
-    } else {
-      switch (message.messageKind.tag) {
-        case "ToClientRequestStart":
-          this.#sendAck(message.requestId, message.messageId);
-          await this.#handleRequestStart(
-            message.requestId,
-            message.messageKind.val
-          );
-          break;
-        case "ToClientRequestChunk":
-          this.#sendAck(message.requestId, message.messageId);
-          await this.#handleRequestChunk(
-            message.requestId,
-            message.messageKind.val
-          );
-          break;
-        case "ToClientRequestAbort":
-          this.#sendAck(message.requestId, message.messageId);
-          await this.#handleRequestAbort(message.requestId);
-          break;
-        case "ToClientWebSocketOpen":
-          this.#sendAck(message.requestId, message.messageId);
-          await this.#handleWebSocketOpen(
-            message.requestId,
-            message.messageKind.val
-          );
-          break;
-        case "ToClientWebSocketMessage": {
-          this.#sendAck(message.requestId, message.messageId);
-          const _unhandled = await this.#handleWebSocketMessage(
-            message.requestId,
-            message.messageKind.val
-          );
-          break;
-        }
-        case "ToClientWebSocketClose":
-          this.#sendAck(message.requestId, message.messageId);
-          await this.#handleWebSocketClose(
-            message.requestId,
-            message.messageKind.val
-          );
-          break;
-        default:
-          unreachable(message.messageKind);
+    var _a;
+    const { gatewayId, requestId, messageIndex } = message.messageId;
+    const gatewayIdStr = idToStr(gatewayId);
+    const requestIdStr = idToStr(requestId);
+    (_a = this.log) == null ? void 0 : _a.debug({
+      msg: "receive tunnel msg",
+      gatewayId: gatewayIdStr,
+      requestId: requestIdStr,
+      messageIndex: message.messageId.messageIndex,
+      message: stringifyToClientTunnelMessageKind(message.messageKind)
+    });
+    switch (message.messageKind.tag) {
+      case "ToClientRequestStart":
+        await this.#handleRequestStart(
+          gatewayId,
+          requestId,
+          message.messageKind.val
+        );
+        break;
+      case "ToClientRequestChunk":
+        await this.#handleRequestChunk(
+          gatewayId,
+          requestId,
+          message.messageKind.val
+        );
+        break;
+      case "ToClientRequestAbort":
+        await this.#handleRequestAbort(gatewayId, requestId);
+        break;
+      case "ToClientWebSocketOpen":
+        await this.#handleWebSocketOpen(
+          gatewayId,
+          requestId,
+          message.messageKind.val
+        );
+        break;
+      case "ToClientWebSocketMessage": {
+        await this.#handleWebSocketMessage(
+          gatewayId,
+          requestId,
+          messageIndex,
+          message.messageKind.val
+        );
+        break;
       }
+      case "ToClientWebSocketClose":
+        await this.#handleWebSocketClose(
+          gatewayId,
+          requestId,
+          message.messageKind.val
+        );
+        break;
+      case "DeprecatedTunnelAck":
+        break;
+      default:
+        unreachable(message.messageKind);
     }
   }
-  async #handleRequestStart(requestId, req) {
-    var _a, _b;
+  async #handleRequestStart(gatewayId, requestId, req) {
+    var _a, _b, _c;
     const requestIdStr = idToStr(requestId);
-    const actor = this.#runner.getActor(req.actorId);
-    if (actor) {
-      actor.requests.add(requestIdStr);
+    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) {
@@ -894,19 +1380,22 @@ var Tunnel = class {
       if (req.stream) {
         const stream = new ReadableStream({
           start: (controller) => {
-            const existing = this.#actorPendingRequests.get(requestIdStr);
+            const existing = actor.getPendingRequest(
+              gatewayId,
+              requestId
+            );
             if (existing) {
               existing.streamController = controller;
               existing.actorId = req.actorId;
+              existing.gatewayId = gatewayId;
+              existing.requestId = requestId;
             } else {
-              this.#actorPendingRequests.set(requestIdStr, {
-                resolve: () => {
-                },
-                reject: () => {
-                },
-                streamController: controller,
-                actorId: req.actorId
-              });
+              actor.createPendingRequestWithStreamController(
+                gatewayId,
+                requestId,
+                0,
+                controller
+              );
             }
           }
         });
@@ -916,56 +1405,96 @@ var Tunnel = class {
         });
         const response = await this.#fetch(
           req.actorId,
+          gatewayId,
           requestId,
           streamingRequest
         );
-        await this.#sendResponse(requestId, response);
+        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(requestId, response);
+        await this.#sendResponse(
+          actor.actorId,
+          actor.generation,
+          gatewayId,
+          requestId,
+          response
+        );
       }
     } catch (error) {
       if (error instanceof RunnerShutdownError) {
-        (_a = this.log) == null ? void 0 : _a.debug({ msg: "catught runner shutdown error" });
+        (_b = this.log) == null ? void 0 : _b.debug({ msg: "catught runner shutdown error" });
       } else {
-        (_b = this.log) == null ? void 0 : _b.error({ msg: "error handling request", error });
+        (_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 {
-      const actor2 = this.#runner.getActor(req.actorId);
-      if (actor2) {
-        actor2.requests.delete(requestIdStr);
+      if (this.#runner.hasActor(req.actorId, actor.generation)) {
+        actor.deletePendingRequest(gatewayId, requestId);
+        this.#removeRequestToActor(gatewayId, requestId);
       }
     }
   }
-  async #handleRequestChunk(requestId, chunk) {
-    const requestIdStr = idToStr(requestId);
-    const pending = this.#actorPendingRequests.get(requestIdStr);
-    if (pending == null ? void 0 : pending.streamController) {
-      pending.streamController.enqueue(new Uint8Array(chunk.body));
-      if (chunk.finish) {
-        pending.streamController.close();
-        this.#actorPendingRequests.delete(requestIdStr);
+  async #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(requestId) {
-    const requestIdStr = idToStr(requestId);
-    const pending = this.#actorPendingRequests.get(requestIdStr);
-    if (pending == null ? void 0 : pending.streamController) {
-      pending.streamController.error(new Error("Request aborted"));
+  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);
     }
-    this.#actorPendingRequests.delete(requestIdStr);
   }
-  async #sendResponse(requestId, response) {
+  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) => {
@@ -974,7 +1503,7 @@ var Tunnel = class {
     if (body && !headers.has("content-length")) {
       headers.set("content-length", String(body.byteLength));
     }
-    this.#sendMessage(requestId, {
+    this.#sendMessage(gatewayId, requestId, {
       tag: "ToServerResponseStart",
       val: {
         status: response.status,
@@ -984,10 +1513,20 @@ var Tunnel = class {
       }
     });
   }
-  #sendResponseError(requestId, status, message) {
+  #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(requestId, {
+    this.#sendMessage(gatewayId, requestId, {
       tag: "ToServerResponseStart",
       val: {
         status,
@@ -997,181 +1536,171 @@ var Tunnel = class {
       }
     });
   }
-  async #handleWebSocketOpen(requestId, open) {
-    var _a, _b, _c, _d;
+  async #handleWebSocketOpen(gatewayId, requestId, open) {
+    var _a, _b, _c;
     const requestIdStr = idToStr(requestId);
-    const actor = this.#runner.getActor(open.actorId);
+    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(requestId, {
+      this.#sendMessage(gatewayId, requestId, {
         tag: "ToServerWebSocketClose",
         val: {
           code: 1011,
           reason: "Actor not found",
-          retry: false
-        }
-      });
-      return;
-    }
-    const websocketHandler = this.#runner.config.websocket;
-    if (!websocketHandler) {
-      (_b = this.log) == null ? void 0 : _b.error({
-        msg: "no websocket handler configured for tunnel"
-      });
-      this.#sendMessage(requestId, {
-        tag: "ToServerWebSocketClose",
-        val: {
-          code: 1011,
-          reason: "Not Implemented",
-          retry: false
+          hibernate: false
         }
       });
       return;
     }
-    const existingAdapter = this.#actorWebSockets.get(requestIdStr);
+    const existingAdapter = actor.getWebSocket(gatewayId, requestId);
     if (existingAdapter) {
-      (_c = this.log) == null ? void 0 : _c.warn({
+      (_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");
-    }
-    if (actor) {
-      actor.webSockets.add(requestIdStr);
+      existingAdapter._closeWithoutCallback(1e3, "ws.duplicate_open");
     }
     try {
-      const adapter = new WebSocketTunnelAdapter(
-        requestIdStr,
-        (data, isBinary) => {
-          const dataBuffer = typeof data === "string" ? new TextEncoder().encode(data).buffer : data;
-          this.#sendMessage(requestId, {
-            tag: "ToServerWebSocketMessage",
-            val: {
-              data: dataBuffer,
-              binary: isBinary
-            }
-          });
-        },
-        (code, reason, retry = false) => {
-          this.#sendMessage(requestId, {
-            tag: "ToServerWebSocketClose",
-            val: {
-              code: code || null,
-              reason: reason || null,
-              retry
-            }
-          });
-          this.#actorWebSockets.delete(requestIdStr);
-          if (actor) {
-            actor.webSockets.delete(requestIdStr);
-          }
-        }
+      const request = buildRequestForWebSocket(
+        open.path,
+        Object.fromEntries(open.headers)
       );
-      this.#actorWebSockets.set(requestIdStr, adapter);
-      const headerInit = {};
-      if (open.headers) {
-        for (const [k, v] of open.headers) {
-          headerInit[k] = v;
-        }
-      }
-      headerInit["Upgrade"] = "websocket";
-      headerInit["Connection"] = "Upgrade";
-      const request = new Request(`http://localhost${open.path}`, {
-        method: "GET",
-        headers: headerInit
-      });
-      const hibernationConfig = this.#runner.config.getActorHibernationConfig(
+      const canHibernate = this.#runner.config.hibernatableWebSocket.canHibernate(
         actor.actorId,
+        gatewayId,
         requestId,
         request
       );
-      adapter.canHibernate = hibernationConfig.enabled;
-      this.#sendMessage(requestId, {
+      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: hibernationConfig.enabled,
-          lastMsgIndex: BigInt(hibernationConfig.lastMsgIndex ?? -1)
+          canHibernate
         }
       });
       adapter._handleOpen(requestId);
-      await websocketHandler(
-        this.#runner,
-        open.actorId,
-        adapter,
-        requestId,
-        request
-      );
     } catch (error) {
-      (_d = this.log) == null ? void 0 : _d.error({ msg: "error handling websocket open", error });
-      this.#sendMessage(requestId, {
+      (_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",
-          retry: false
+          hibernate: false
         }
       });
-      this.#actorWebSockets.delete(requestIdStr);
-      if (actor) {
-        actor.webSockets.delete(requestIdStr);
-      }
+      actor.deleteWebSocket(gatewayId, requestId);
+      actor.deletePendingRequest(gatewayId, requestId);
+      this.#removeRequestToActor(gatewayId, requestId);
     }
   }
-  /// Returns false if the message was sent off
-  async #handleWebSocketMessage(requestId, msg) {
-    const requestIdStr = idToStr(requestId);
-    const adapter = this.#actorWebSockets.get(requestIdStr);
-    if (adapter) {
-      const data = msg.binary ? new Uint8Array(msg.data) : new TextDecoder().decode(new Uint8Array(msg.data));
-      return adapter._handleMessage(
-        requestId,
-        data,
-        msg.index,
-        msg.binary
-      );
-    } else {
-      return true;
+  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
+    });
   }
-  __ackWebsocketMessage(requestId, index) {
-    var _a;
+  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: idToStr(requestId),
-      index
+      requestId: requestIdStr,
+      index: clientMessageIndex
     });
-    if (index < 0 || index > 65535)
+    if (clientMessageIndex < 0 || clientMessageIndex > 65535)
       throw new Error("invalid websocket ack index");
-    this.#sendMessage(requestId, {
+    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
+        index: clientMessageIndex
       }
     });
   }
-  async #handleWebSocketClose(requestId, close) {
-    const requestIdStr = idToStr(requestId);
-    const adapter = this.#actorWebSockets.get(requestIdStr);
-    if (adapter) {
-      adapter._handleClose(
-        requestId,
-        close.code || void 0,
-        close.reason || void 0
-      );
-      this.#actorWebSockets.delete(requestIdStr);
+  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 generateUuidBuffer() {
-  const buffer = new Uint8Array(16);
-  uuidv4(void 0, buffer);
-  return buffer.buffer;
-}
-function idToStr(id) {
-  return uuidstringify(new Uint8Array(id));
+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
@@ -1209,7 +1738,7 @@ async function importWebSocket() {
 
 // src/mod.ts
 var KV_EXPIRE = 3e4;
-var PROTOCOL_VERSION = 2;
+var PROTOCOL_VERSION = 3;
 var RUNNER_PING_INTERVAL = 3e3;
 var EVENT_BACKLOG_WARN_THRESHOLD = 1e4;
 var SIGNAL_HANDLERS = [];
@@ -1219,15 +1748,15 @@ var Runner = class {
     return this.#config;
   }
   #actors = /* @__PURE__ */ new Map();
-  #actorWebSockets = /* @__PURE__ */ new Map();
   // WebSocket
-  #pegboardWebSocket;
+  __pegboardWebSocket;
   runnerId;
   #lastCommandIdx = -1;
   #pingLoop;
   #nextEventIdx = 0n;
   #started = false;
   #shutdown = false;
+  #shuttingDown = false;
   #reconnectAttempt = 0;
   #reconnectTimeout;
   // Runner lost threshold management
@@ -1239,7 +1768,7 @@ var Runner = class {
   // Command acknowledgment
   #ackInterval;
   // KV operations
-  #nextRequestId = 0;
+  #nextKvRequestId = 0;
   #kvRequests = /* @__PURE__ */ new Map();
   #kvCleanupInterval;
   // Tunnel for HTTP/WebSocket forwarding
@@ -1270,13 +1799,6 @@ var Runner = class {
   }
   // MARK: Manage actors
   sleepActor(actorId, generation) {
-    var _a;
-    if (this.#shutdown) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "runner is shut down, cannot sleep actor"
-      });
-      return;
-    }
     const actor = this.getActor(actorId, generation);
     if (!actor) return;
     this.#sendActorIntent(actorId, actor.generation, "sleep");
@@ -1288,7 +1810,7 @@ var Runner = class {
   }
   async forceStopActor(actorId, generation) {
     var _a;
-    const actor = this.#removeActor(actorId, generation);
+    const actor = this.getActor(actorId, generation);
     if (!actor) return;
     try {
       await this.#config.onActorStop(actorId, actor.generation);
@@ -1296,6 +1818,7 @@ var Runner = class {
       console.error(`Error in onActorStop for actor ${actorId}:`, err);
     }
     (_a = this.#tunnel) == null ? void 0 : _a.closeActiveRequests(actor);
+    this.#removeActor(actorId, generation);
     this.#sendActorStateUpdate(actorId, actor.generation, "stopped");
   }
   #stopAllActors() {
@@ -1312,14 +1835,14 @@ var Runner = class {
     var _a, _b;
     const actor = this.#actors.get(actorId);
     if (!actor) {
-      (_a = this.log) == null ? void 0 : _a.error({
+      (_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.error({
+      (_b = this.log) == null ? void 0 : _b.warn({
         msg: "actor generation mismatch",
         actorId,
         generation
@@ -1328,13 +1851,22 @@ var Runner = class {
     }
     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;
+    var _a, _b, _c;
     const actor = this.#actors.get(actorId);
     if (!actor) {
       (_a = this.log) == null ? void 0 : _a.error({
@@ -1352,6 +1884,11 @@ var Runner = class {
       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
@@ -1370,37 +1907,42 @@ var Runner = class {
     }
     if (!this.#config.noAutoShutdown) {
       if (!SIGNAL_HANDLERS.length) {
-        process.on("SIGTERM", () => {
+        process.on("SIGTERM", async () => {
           var _a2;
           (_a2 = this.log) == null ? void 0 : _a2.debug("received SIGTERM");
           for (const handler of SIGNAL_HANDLERS) {
-            handler();
+            await handler();
           }
-          process.exit(0);
         });
-        process.on("SIGINT", () => {
+        process.on("SIGINT", async () => {
           var _a2;
           (_a2 = this.log) == null ? void 0 : _a2.debug("received SIGINT");
           for (const handler of SIGNAL_HANDLERS) {
-            handler();
+            await handler();
           }
-          process.exit(0);
         });
         (_b = this.log) == null ? void 0 : _b.debug({
           msg: "added SIGTERM listeners"
         });
       }
-      SIGNAL_HANDLERS.push(() => {
+      SIGNAL_HANDLERS.push(async () => {
         var _a2;
         const weak = new WeakRef(this);
-        (_a2 = weak.deref()) == null ? void 0 : _a2.shutdown(false, false);
+        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;
-    (_a = this.log) == null ? void 0 : _a.info({
+    if (this.#shuttingDown) {
+      (_a = this.log) == null ? void 0 : _a.debug({
+        msg: "shutdown already in progress, ignoring"
+      });
+      return;
+    }
+    this.#shuttingDown = true;
+    (_b = this.log) == null ? void 0 : _b.info({
       msg: "starting shutdown",
       immediate,
       exit
@@ -1432,27 +1974,20 @@ var Runner = class {
       );
     }
     this.#kvRequests.clear();
-    if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
-      const pegboardWebSocket = this.#pegboardWebSocket;
+    if (this.__webSocketReady()) {
+      const pegboardWebSocket = this.__pegboardWebSocket;
       if (immediate) {
         pegboardWebSocket.close(1e3, "pegboard.runner_shutdown");
       } else {
         try {
-          (_b = this.log) == null ? void 0 : _b.info({
+          (_c = this.log) == null ? void 0 : _c.info({
             msg: "sending stopping message",
             readyState: pegboardWebSocket.readyState
           });
-          const encoded = protocol.encodeToServer({
+          this.__sendToServer({
             tag: "ToServerStopping",
             val: null
           });
-          if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
-            this.#pegboardWebSocket.send(encoded);
-          } else {
-            (_c = this.log) == null ? void 0 : _c.error(
-              "WebSocket not available or not open for sending data"
-            );
-          }
           const closePromise = new Promise((resolve) => {
             if (!pegboardWebSocket)
               throw new Error("missing pegboardWebSocket");
@@ -1466,6 +2001,7 @@ var Runner = class {
               resolve();
             });
           });
+          await this.#waitForActorsToStop(pegboardWebSocket);
           (_d = this.log) == null ? void 0 : _d.info({
             msg: "closing WebSocket"
           });
@@ -1485,15 +2021,97 @@ var Runner = class {
     } 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
+        readyState: (_g = this.__pegboardWebSocket) == null ? void 0 : _g.readyState
       });
     }
     if (this.#tunnel) {
       this.#tunnel.shutdown();
       this.#tunnel = void 0;
     }
-    if (exit) process.exit(0);
     this.#config.onShutdown();
+    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() {
@@ -1512,7 +2130,7 @@ var Runner = class {
       protocols.push(`rivet_token.${this.config.token}`);
     const WS = await importWebSocket();
     const ws = new WS(this.pegboardUrl, protocols);
-    this.#pegboardWebSocket = ws;
+    this.__pegboardWebSocket = ws;
     (_a = this.log) == null ? void 0 : _a.info({
       msg: "connecting",
       endpoint: this.pegboardEndpoint,
@@ -1564,7 +2182,6 @@ var Runner = class {
         tag: "ToServerInit",
         val: init
       });
-      this.#processUnsentKvRequests();
       const pingLoop = setInterval(() => {
         var _a3;
         if (ws.readyState === 1) {
@@ -1597,7 +2214,7 @@ var Runner = class {
       this.#ackInterval = ackLoop;
     });
     ws.addEventListener("message", async (ev) => {
-      var _a2, _b, _c, _d;
+      var _a2, _b, _c, _d, _e, _f;
       let buf;
       if (ev.data instanceof Blob) {
         buf = new Uint8Array(await ev.data.arrayBuffer());
@@ -1607,19 +2224,25 @@ var Runner = class {
         throw new Error(`expected binary data, got ${typeof ev.data}`);
       }
       const message = protocol.decodeToClient(buf);
+      (_a2 = this.log) == null ? void 0 : _a2.debug({
+        msg: "received runner message",
+        data: stringifyToClient(message)
+      });
       if (message.tag === "ToClientInit") {
         const init = message.val;
         if (this.runnerId !== init.runnerId) {
           this.runnerId = init.runnerId;
           this.#eventHistory.length = 0;
         }
-        this.#runnerLostThreshold = ((_a2 = init.metadata) == null ? void 0 : _a2.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
-        (_b = this.log) == null ? void 0 : _b.info({
+        this.#runnerLostThreshold = ((_b = init.metadata) == null ? void 0 : _b.runnerLostThreshold) ? Number(init.metadata.runnerLostThreshold) : void 0;
+        (_c = this.log) == null ? void 0 : _c.info({
           msg: "received init",
           lastEventIdx: init.lastEventIdx,
           runnerLostThreshold: this.#runnerLostThreshold
         });
+        this.#processUnsentKvRequests();
         this.#resendUnacknowledgedEvents(init.lastEventIdx);
+        (_d = this.#tunnel) == null ? void 0 : _d.resendBufferedEvents();
         this.#config.onConnected();
       } else if (message.tag === "ToClientCommands") {
         const commands = message.val;
@@ -1630,9 +2253,9 @@ var Runner = class {
         const kvResponse = message.val;
         this.#handleKvResponse(kvResponse);
       } else if (message.tag === "ToClientTunnelMessage") {
-        (_c = this.#tunnel) == null ? void 0 : _c.handleTunnelMessage(message.val);
+        (_e = this.#tunnel) == null ? void 0 : _e.handleTunnelMessage(message.val);
       } else if (message.tag === "ToClientClose") {
-        (_d = this.#tunnel) == null ? void 0 : _d.shutdown();
+        (_f = this.#tunnel) == null ? void 0 : _f.shutdown();
         ws.close(1e3, "manual closure");
       } else {
         unreachable(message);
@@ -1699,16 +2322,12 @@ var Runner = class {
     });
   }
   #handleCommands(commands) {
-    var _a, _b;
+    var _a;
     (_a = this.log) == null ? void 0 : _a.info({
       msg: "received commands",
       commandCount: commands.length
     });
     for (const commandWrapper of commands) {
-      (_b = this.log) == null ? void 0 : _b.info({
-        msg: "received command",
-        command: stringifyCommandWrapper(commandWrapper)
-      });
       if (commandWrapper.inner.tag === "CommandStartActor") {
         this.#handleCommandStartActor(commandWrapper);
       } else if (commandWrapper.inner.tag === "CommandStopActor") {
@@ -1751,7 +2370,9 @@ var Runner = class {
       });
     }
   }
-  #handleCommandStartActor(commandWrapper) {
+  async #handleCommandStartActor(commandWrapper) {
+    var _a, _b, _c, _d;
+    if (!this.#tunnel) throw new Error("missing tunnel on actor start");
     const startCommand = commandWrapper.inner.val;
     const actorId = startCommand.actorId;
     const generation = startCommand.generation;
@@ -1762,40 +2383,61 @@ var Runner = class {
       createTs: config.createTs,
       input: config.input ? new Uint8Array(config.input) : null
     };
-    const instance = {
+    const instance = new RunnerActor(
       actorId,
       generation,
-      config: actorConfig,
-      requests: /* @__PURE__ */ new Set(),
-      webSockets: /* @__PURE__ */ new Set()
-    };
+      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");
-    this.#config.onActorStart(actorId, generation, actorConfig).catch((err) => {
-      var _a;
-      (_a = this.log) == null ? void 0 : _a.error({
-        msg: "error in onactorstart for actor",
+    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
       });
-      this.forceStopActor(actorId, generation);
-    });
+      instance.actorStartPromise.reject(err);
+      await this.forceStopActor(actorId, generation);
+    }
   }
-  #handleCommandStopActor(commandWrapper) {
+  async #handleCommandStopActor(commandWrapper) {
     const stopCommand = commandWrapper.inner.val;
     const actorId = stopCommand.actorId;
     const generation = stopCommand.generation;
-    this.forceStopActor(actorId, generation);
+    await this.forceStopActor(actorId, generation);
   }
   #sendActorIntent(actorId, generation, intentType) {
-    var _a, _b;
-    if (this.#shutdown) {
-      console.trace("send actor intent", actorId, intentType);
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "Runner is shut down, cannot send actor intent"
-      });
-      return;
-    }
     let actorIntent;
     if (intentType === "sleep") {
       actorIntent = { tag: "ActorIntentSleep", val: null };
@@ -1821,24 +2463,12 @@ var Runner = class {
       }
     };
     this.#recordEvent(eventWrapper);
-    (_b = this.log) == null ? void 0 : _b.info({
-      msg: "sending event to server",
-      event: stringifyEvent(eventWrapper.inner),
-      index: eventWrapper.index.toString()
-    });
     this.__sendToServer({
       tag: "ToServerEvents",
       val: [eventWrapper]
     });
   }
   #sendActorStateUpdate(actorId, generation, stateType) {
-    var _a, _b;
-    if (this.#shutdown) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "Runner is shut down, cannot send actor state update"
-      });
-      return;
-    }
     let actorState;
     if (stateType === "running") {
       actorState = { tag: "ActorStateRunning", val: null };
@@ -1867,24 +2497,12 @@ var Runner = class {
       }
     };
     this.#recordEvent(eventWrapper);
-    (_b = this.log) == null ? void 0 : _b.info({
-      msg: "sending event to server",
-      event: stringifyEvent(eventWrapper.inner),
-      index: eventWrapper.index.toString()
-    });
     this.__sendToServer({
       tag: "ToServerEvents",
       val: [eventWrapper]
     });
   }
   #sendCommandAcknowledgment() {
-    var _a;
-    if (this.#shutdown) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "Runner is shut down, cannot send command acknowledgment"
-      });
-      return;
-    }
     if (this.#lastCommandIdx < 0) {
       return;
     }
@@ -2120,10 +2738,6 @@ var Runner = class {
   setAlarm(actorId, alarmTs, generation) {
     const actor = this.getActor(actorId, generation);
     if (!actor) return;
-    if (this.#shutdown) {
-      console.warn("Runner is shut down, cannot set alarm");
-      return;
-    }
     const alarmEvent = {
       actorId,
       generation: actor.generation,
@@ -2148,12 +2762,7 @@ var Runner = class {
   }
   #sendKvRequest(actorId, requestData) {
     return new Promise((resolve, reject) => {
-      if (this.#shutdown) {
-        reject(new Error("Runner is shut down"));
-        return;
-      }
-      const requestId = this.#nextRequestId++;
-      const isConnected = this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1;
+      const requestId = this.#nextKvRequestId++;
       const requestEntry = {
         actorId,
         data: requestData,
@@ -2163,7 +2772,7 @@ var Runner = class {
         timestamp: Date.now()
       };
       this.#kvRequests.set(requestId, requestEntry);
-      if (isConnected) {
+      if (this.__webSocketReady()) {
         this.#sendSingleKvRequest(requestId);
       }
     });
@@ -2189,7 +2798,7 @@ var Runner = class {
     }
   }
   #processUnsentKvRequests() {
-    if (!this.#pegboardWebSocket || this.#pegboardWebSocket.readyState !== 1) {
+    if (!this.__webSocketReady()) {
       return;
     }
     let processedCount = 0;
@@ -2202,29 +2811,61 @@ var Runner = class {
     if (processedCount > 0) {
     }
   }
+  /** Asserts WebSocket exists and is ready. */
   __webSocketReady() {
-    return this.#pegboardWebSocket ? this.#pegboardWebSocket.readyState === 1 : false;
+    return !!this.__pegboardWebSocket && this.__pegboardWebSocket.readyState === 1;
   }
   __sendToServer(message) {
     var _a, _b;
-    if (this.#shutdown) {
-      (_a = this.log) == null ? void 0 : _a.warn({
-        msg: "Runner is shut down, cannot send message to server"
-      });
-      return;
-    }
+    (_a = this.log) == null ? void 0 : _a.debug({
+      msg: "sending runner message",
+      data: stringifyToServer(message)
+    });
     const encoded = protocol.encodeToServer(message);
-    if (this.#pegboardWebSocket && this.#pegboardWebSocket.readyState === 1) {
-      this.#pegboardWebSocket.send(encoded);
+    if (this.__webSocketReady()) {
+      this.__pegboardWebSocket.send(encoded);
     } else {
       (_b = this.log) == null ? void 0 : _b.error({
         msg: "WebSocket not available or not open for sending data"
       });
     }
   }
-  sendWebsocketMessageAck(requestId, index) {
-    var _a;
-    (_a = this.#tunnel) == null ? void 0 : _a.__ackWebsocketMessage(requestId, index);
+  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;
@@ -2268,10 +2909,15 @@ var Runner = class {
     }, delay);
   }
   #resendUnacknowledgedEvents(lastEventIdx) {
+    var _a;
     const eventsToResend = this.#eventHistory.filter(
       (event) => event.index > lastEventIdx
     );
     if (eventsToResend.length === 0) return;
+    (_a = this.log) == null ? void 0 : _a.info({
+      msg: "resending unacknowledged events",
+      fromIndex: lastEventIdx + 1n
+    });
     this.__sendToServer({
       tag: "ToServerEvents",
       val: eventsToResend
@@ -2298,6 +2944,8 @@ var Runner = class {
   }
 };
 export {
-  Runner
+  Runner,
+  RunnerActor,
+  idToStr
 };
 //# sourceMappingURL=mod.js.map