Method ackDelivered

src/proxy/sync/inbound.js:144–208

(channel = 'evomap-hub')

  }

  async ackDelivered(channel = 'evomap-hub') {
    const waitMs = this._hubUnreachableWaitMs();
    if (waitMs > 0) {
      return {
        acked: 0,
        error: 'hub_unreachable_backoff',
        hubUnreachable: true,
        retryAfterMs: waitMs,
      };
    }

    const delivered = this.store.list({
      type: '%',
      direction: 'inbound',
      status: 'delivered',
      limit: 100,
    }).filter(m => m.channel === channel);

    if (delivered.length === 0) return { acked: 0 };

    const endpoint = `${this.hubUrl}/a2a/mailbox/ack`;

    try {
      const senderId = this.store.getState('node_id');
      // Round-8 (§21.5): drain the response body so the undici long-poll
      // dispatcher pool is not leaked one socket per ack. ackDelivered
      // is called every inbound poll cycle (default 1-10s); the
      // pre-round-8 code captured no reference to res and never called
      // .json()/.text()/body.cancel(), so each ack pinned a socket
      // until GC. After a few minutes of activity the strict-pool was
      // exhausted and proxy-mode heartbeats hung on next acquire --
      // matches the "alive once then dead" user symptom in proxy mode.
      const res = await hubFetch(endpoint, {
        method: 'POST',
        headers: this.getHeaders(),
        body: JSON.stringify({ sender_id: senderId, message_ids: delivered.map(m => m.id) }),
        signal: AbortSignal.timeout(10_000),
      });
      await throwIfHubUnreachableResponse(res, 'inbound ack');
      this._recordHubReachable();
      if (res.status === 403 || res.status === 401) {
        const errText = await readHubResponseText(res).catch(() => 'unknown');
        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
      }
      if (!res.ok) {
        const errText = await readHubResponseText(res).catch(() => 'unknown');
        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
      }
      await drainHubResponse(res);
      return { acked: delivered.length };
    } catch (err) {
      if (err instanceof AuthError) throw err;
      if (isHubUnreachableError(err)) {
        const retryAfterMs = this._recordHubUnreachable(err);
        return {
          acked: 0,
          error: 'hub_unreachable',
          hubUnreachable: true,