Challenge 1: Add a Maximum Retry Count — Possible Solution
====================================================================

class ReconnectingSocket {
  constructor(url, maxAttempts = 10) {
    this.url = url;
    this.attempt = 0;
    this.maxAttempts = maxAttempts;
    this.gaveUp = false;
    this.connect();
  }

  connect() {
    this.socket = new WebSocket(this.url);

    this.socket.addEventListener("open", () => {
      this.attempt = 0; // reset backoff once actually connected
    });

    this.socket.addEventListener("close", () => {
      if (this.attempt >= this.maxAttempts) {
        this.gaveUp = true;
        this._notifyGaveUp();
        return; // stop retrying — no further setTimeout is scheduled
      }

      const delay = Math.min(1000 * 2 ** this.attempt, 30000);
      const jitter = Math.random() * 0.3 * delay;
      this.attempt++;
      setTimeout(() => this.connect(), delay + jitter);
    });
  }

  onGiveUp(callback) {
    this._notifyGaveUp = callback; // UI registers a callback for this event
  }

  _notifyGaveUp() {
    // no-op default until onGiveUp() registers a real callback
  }
}

// Usage:
// const socket = new ReconnectingSocket("wss://example.com/chat");
// socket.onGiveUp(() => showPermanentDisconnectBanner());

WHY THIS WORKS
--------------
- this.attempt already existed in the original class as the backoff
  counter — reusing it as the retry counter avoids introducing a second,
  redundant piece of state that could drift out of sync with it.
- The check "if (this.attempt >= this.maxAttempts)" happens INSIDE the
  "close" handler, BEFORE scheduling another setTimeout — this is the
  critical change: once the limit is hit, connect() is simply never
  called again, which is what actually stops the infinite retry loop
  rather than just suppressing a symptom of it.
- this.gaveUp is a plain boolean flag the rest of the application can
  check at any time (e.g. before attempting a manual "Retry" button
  action) to know whether this instance has permanently stopped trying.
- onGiveUp(callback) gives the UI an explicit, observable hook rather
  than requiring it to poll this.gaveUp on a timer — this mirrors how
  the existing code already uses addEventListener-style callbacks for
  "open" and "close," keeping the pattern consistent with the rest of
  the class.
- Critically, a successful reconnect (the "open" handler firing) resets
  this.attempt back to 0 — so a connection that reconnects successfully
  after, say, 3 attempts gets a fresh full budget of maxAttempts if it
  drops again later, rather than counting toward some lifetime total.