@aurabase/realtime 0.4.0

package/dist/index.js

@@ -0,0 +1,1225 @@
+import { fetchWithAuth } from '@aurabase/core';
+
+// src/RealtimeService.ts
+
+// src/columnFilter.ts
+var VALID_OPS = /* @__PURE__ */ new Set([
+  "eq",
+  "neq",
+  "lt",
+  "lte",
+  "gt",
+  "gte",
+  "in",
+  "like",
+  "ilike",
+  "is",
+  "match",
+  "imatch",
+  "isdistinct"
+]);
+var MAX_REGEX_PATTERN_LEN = 512;
+var MAX_IN_VALUES = 100;
+function parseColumnFilter(filterStr) {
+  const eqIdx = filterStr.indexOf("=");
+  if (eqIdx === -1) return null;
+  const column = filterStr.slice(0, eqIdx);
+  if (!column) return null;
+  let rest = filterStr.slice(eqIdx + 1);
+  let negated = false;
+  if (rest.startsWith("not.")) {
+    negated = true;
+    rest = rest.slice(4);
+  }
+  const dotIdx = rest.indexOf(".");
+  if (dotIdx === -1) return null;
+  const opStr = rest.slice(0, dotIdx);
+  let value = rest.slice(dotIdx + 1);
+  if (!VALID_OPS.has(opStr)) return null;
+  const op = opStr;
+  if (op === "in") {
+    const stripped = value.replace(/^\(+/, "").replace(/\)+$/, "");
+    if (stripped.split(",").length > MAX_IN_VALUES) return null;
+    value = stripped;
+  } else if (op === "is") {
+    if (value !== "null" && value !== "true" && value !== "false") return null;
+  } else if (op === "match" || op === "imatch") {
+    if (value.length > MAX_REGEX_PATTERN_LEN) return null;
+    try {
+      new RegExp(value, op === "imatch" ? "i" : void 0);
+    } catch {
+      return null;
+    }
+  }
+  return { column, op, value, negated };
+}
+function splitTopLevel(s) {
+  const parts = [];
+  let depth = 0;
+  let start = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s[i];
+    if (c === "(") depth += 1;
+    else if (c === ")") depth = Math.max(0, depth - 1);
+    else if (c === "," && depth === 0) {
+      parts.push(s.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(s.slice(start));
+  return parts;
+}
+function parseFilterSet(s) {
+  const parts = splitTopLevel(s);
+  const out = [];
+  for (const part of parts) {
+    const cf = parseColumnFilter(part.trim());
+    if (!cf) return null;
+    out.push(cf);
+  }
+  return out;
+}
+function jsonValueToString(field) {
+  if (typeof field === "string") return field;
+  if (typeof field === "number" || typeof field === "boolean") return String(field);
+  if (field === null) return "null";
+  try {
+    return JSON.stringify(field) ?? "";
+  } catch {
+    return "";
+  }
+}
+function parseStrictNumber(s) {
+  if (s.trim() === "") return null;
+  const n = Number(s);
+  return Number.isFinite(n) ? n : null;
+}
+function compareNumeric(a, b, cmp) {
+  const an = parseStrictNumber(a);
+  const bn = parseStrictNumber(b);
+  if (an === null || bn === null) return false;
+  return cmp(an, bn);
+}
+function likeToRegExp(pattern, caseInsensitive) {
+  let re = "^";
+  for (const ch of pattern) {
+    if (ch === "%") re += ".*";
+    else if (ch === "_") re += ".";
+    else re += ch.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  re += "$";
+  try {
+    return new RegExp(re, caseInsensitive ? "i" : void 0);
+  } catch {
+    return null;
+  }
+}
+function matchesRaw(cf, record) {
+  if (cf.op === "is") {
+    const field2 = record[cf.column];
+    switch (cf.value) {
+      case "null":
+        return field2 === void 0 || field2 === null;
+      case "true":
+        return field2 === true;
+      case "false":
+        return field2 === false;
+      default:
+        return false;
+    }
+  }
+  if (cf.op === "isdistinct") {
+    const field2 = record[cf.column];
+    const fieldIsNull = field2 === void 0 || field2 === null;
+    if (fieldIsNull) return true;
+    return jsonValueToString(field2) !== cf.value;
+  }
+  if (!(cf.column in record) || record[cf.column] === void 0) return null;
+  const field = record[cf.column];
+  const fieldStr = jsonValueToString(field);
+  switch (cf.op) {
+    case "eq":
+      return fieldStr === cf.value;
+    case "neq":
+      return fieldStr !== cf.value;
+    case "lt":
+      return compareNumeric(fieldStr, cf.value, (a, b) => a < b);
+    case "lte":
+      return compareNumeric(fieldStr, cf.value, (a, b) => a <= b);
+    case "gt":
+      return compareNumeric(fieldStr, cf.value, (a, b) => a > b);
+    case "gte":
+      return compareNumeric(fieldStr, cf.value, (a, b) => a >= b);
+    case "in":
+      return cf.value.split(",").map((v) => v.trim()).some((v) => v === fieldStr);
+    case "like": {
+      const re = likeToRegExp(cf.value, false);
+      return re ? re.test(fieldStr) : null;
+    }
+    case "ilike": {
+      const re = likeToRegExp(cf.value, true);
+      return re ? re.test(fieldStr) : null;
+    }
+    case "match": {
+      try {
+        return new RegExp(cf.value).test(fieldStr);
+      } catch {
+        return null;
+      }
+    }
+    case "imatch": {
+      try {
+        return new RegExp(cf.value, "i").test(fieldStr);
+      } catch {
+        return null;
+      }
+    }
+    default:
+      return null;
+  }
+}
+function matchesSingle(cf, record) {
+  const raw = matchesRaw(cf, record);
+  if (raw === null) return false;
+  return cf.negated ? !raw : raw;
+}
+function matchesColumnFilter(filter, record) {
+  const set = parseFilterSet(filter);
+  if (!set) return false;
+  return set.every((cf) => matchesSingle(cf, record));
+}
+
+// src/AuraChannel.ts
+var DEFAULT_SUBSCRIBE_TIMEOUT_MS = 1e4;
+var AuraChannel = class {
+  name;
+  _projectId;
+  _listeners = [];
+  _subscribed = false;
+  _sendFn = null;
+  _subscribeCallback = null;
+  _presenceState = {};
+  _isPrivate = false;
+  _broadcastAck = false;
+  _broadcastSelf = false;
+  _presenceKey = "";
+  /** ID de subscription retourné par le serveur (utilisé pour le filtre RLS allowed_sub_ids) */
+  _subscriptionId = null;
+  /** Compteur pour générer des ref_id uniques par connexion */
+  _refCounter = 0;
+  /** Dernier event ID recu — utilise pour since_id au reconnect */
+  _lastEventId = null;
+  /** Pending ACK callbacks : ref_id → resolve */
+  _pendingAcks = /* @__PURE__ */ new Map();
+  /**
+   * Timer d'attente de la confirmation `subscribed`. Armé à l'ENVOI effectif du
+   * message subscribe (parité phoenix : `Push#startTimeout` ne démarre qu'au
+   * `send()`), désarmé dès qu'une réponse — `subscribed` ou `error` — arrive.
+   */
+  _subscribeTimer = null;
+  /** Délai avant `TIMED_OUT`, surchargeable par `subscribe(cb, timeout)`. */
+  _subscribeTimeoutMs = DEFAULT_SUBSCRIBE_TIMEOUT_MS;
+  /** `CLOSED` n'est émis qu'une fois par cycle de vie du canal (unsubscribe idempotent). */
+  _closedEmitted = false;
+  constructor(name, projectId, options) {
+    this.name = name;
+    this._projectId = projectId;
+    this._isPrivate = options?.private ?? false;
+    this._broadcastAck = options?.broadcast?.ack ?? false;
+    this._broadcastSelf = options?.broadcast?.self ?? false;
+    this._presenceKey = options?.config?.presence?.key ?? "";
+  }
+  /** Génère un ref_id unique pour la corrélation request/response. */
+  _nextRef() {
+    return `${this.fullName}:r${++this._refCounter}`;
+  }
+  /** Full channel name with project prefix (for server protocol) */
+  get fullName() {
+    return `${this._projectId}:${this.name}`;
+  }
+  on(type, filter, callback) {
+    this._listeners.push({ type, filter, callback });
+    return this;
+  }
+  // ─── Subscribe ──────────────────────────────────────────────────────────
+  /**
+   * Subscribe to the channel. Sends the Subscribe message to the server
+   * with the full config (postgres_changes, broadcast, presence).
+   *
+   * Le callback reçoit les mêmes statuts que `@supabase/realtime-js` :
+   * - `SUBSCRIBED`    — le serveur a confirmé l'abonnement ;
+   * - `CHANNEL_ERROR` — refus serveur (RLS, rate limit…), échec de handshake ou
+   *                     coupure inattendue de la connexion ;
+   * - `TIMED_OUT`     — aucune réponse du serveur dans `timeoutMs` après l'envoi ;
+   * - `CLOSED`        — le canal a été fermé volontairement (`unsubscribe()`,
+   *                     `removeChannel()`, `removeAllChannels()`, `disconnect()`).
+   *
+   * @param callback  Callback de statut (optionnel).
+   * @param timeoutMs Délai avant `TIMED_OUT` (défaut 10 s, comme Supabase).
+   */
+  subscribe(callback, timeoutMs) {
+    this._subscribeCallback = callback ?? null;
+    this._subscribed = true;
+    this._closedEmitted = false;
+    if (typeof timeoutMs === "number" && timeoutMs > 0) {
+      this._subscribeTimeoutMs = timeoutMs;
+    }
+    if (this._sendFn) {
+      this._doSubscribe();
+    }
+    return this;
+  }
+  /** Called by RealtimeService once the WS connection is ready. */
+  _bindSend(sendFn) {
+    this._sendFn = sendFn;
+  }
+  /** Send the subscribe message to the server. */
+  _doSubscribe() {
+    if (!this._sendFn) return;
+    const pgFilters = this._listeners.filter((l) => l.type === "postgres_changes").map((l) => l.filter);
+    const msg = {
+      type: "subscribe",
+      channel: this.fullName,
+      ref_id: this._nextRef(),
+      since_id: this._lastEventId ?? void 0,
+      config: {
+        postgres_changes: pgFilters,
+        broadcast: {
+          self_broadcast: this._broadcastSelf,
+          // ← depuis les options du channel
+          ack: this._broadcastAck
+          // ← depuis les options du channel
+        },
+        presence: { key: this._presenceKey },
+        // ← depuis les options du channel
+        private: this._isPrivate
+      }
+    };
+    this._sendFn(JSON.stringify(msg));
+    this._armSubscribeTimeout();
+  }
+  /** (Re)arme le compte à rebours d'attente de la confirmation `subscribed`. */
+  _armSubscribeTimeout() {
+    this._clearSubscribeTimeout();
+    if (!this._subscribeCallback) return;
+    this._subscribeTimer = setTimeout(() => {
+      this._subscribeTimer = null;
+      this._subscribeCallback?.("TIMED_OUT");
+    }, this._subscribeTimeoutMs);
+  }
+  _clearSubscribeTimeout() {
+    if (this._subscribeTimer) {
+      clearTimeout(this._subscribeTimer);
+      this._subscribeTimer = null;
+    }
+  }
+  /**
+   * Signale une erreur de transport (échec de handshake, coupure inattendue,
+   * connexion morte) — appelé par `RealtimeService`.
+   *
+   * Émet `CHANNEL_ERROR`, comme `@supabase/realtime-js` : chez Supabase, la
+   * fermeture du socket déclenche `Socket#triggerChanError` (phoenix
+   * `socket.js:550`), qui produit `CHANNEL_ERROR` et **jamais** `CLOSED` —
+   * `CLOSED` reste réservé à la fermeture volontaire du canal.
+   */
+  _signalError(err) {
+    this._clearSubscribeTimeout();
+    if (!this._subscribed) return;
+    this._subscribeCallback?.("CHANNEL_ERROR", err);
+  }
+  /** Unsubscribe from the channel. */
+  unsubscribe() {
+    if (this._sendFn) {
+      this._sendFn(JSON.stringify({ type: "unsubscribe", channel: this.fullName }));
+    }
+    this._clearSubscribeTimeout();
+    this._subscribed = false;
+    this._listeners.length = 0;
+    this._presenceState = {};
+    if (!this._closedEmitted) {
+      this._closedEmitted = true;
+      this._subscribeCallback?.("CLOSED");
+    }
+  }
+  // ─── Broadcast ──────────────────────────────────────────────────────────
+  /**
+   * Send a broadcast message to the channel.
+   * If broadcast.ack=true, returns a Promise that resolves when the server ACKs.
+   *
+   * @example
+   * ```ts
+   * // Without ACK (fire & forget)
+   * channel.send({ type: 'broadcast', event: 'cursor-pos', payload: { x: 100, y: 200 } })
+   *
+   * // With ACK (wait for server confirmation)
+   * await channel.send({ type: 'broadcast', event: 'cursor-pos', payload: { x: 100 } })
+   * ```
+   */
+  send(message) {
+    return new Promise((resolve) => {
+      if (!this._sendFn) {
+        resolve("error");
+        return;
+      }
+      const ref_id = message.ref_id ?? this._nextRef();
+      if (this._broadcastAck) {
+        const timer = setTimeout(() => {
+          this._pendingAcks.delete(ref_id);
+          resolve("timeout");
+        }, 5e3);
+        this._pendingAcks.set(ref_id, () => {
+          clearTimeout(timer);
+          resolve("ok");
+        });
+      } else {
+        resolve("ok");
+      }
+      this._sendFn(
+        JSON.stringify({
+          type: "broadcast",
+          channel: this.fullName,
+          ref_id,
+          payload: { event: message.event, ...message.payload }
+        })
+      );
+    });
+  }
+  // ─── Presence ───────────────────────────────────────────────────────────
+  /**
+   * Track presence state for this client.
+   * Returns a Promise that resolves with 'ok' once tracked (compatible Supabase).
+   *
+   * @example
+   * ```ts
+   * await channel.track({ user: 'user-1', online_at: new Date().toISOString() })
+   * ```
+   */
+  async track(state) {
+    if (!this._sendFn) return "error";
+    this._sendFn(
+      JSON.stringify({
+        type: "presence_update",
+        channel: this.fullName,
+        meta: state
+      })
+    );
+    return "ok";
+  }
+  /** Stop tracking presence. */
+  async untrack() {
+    return this.track({});
+  }
+  /** Get the current presence state for this channel. */
+  presenceState() {
+    return { ...this._presenceState };
+  }
+  // ─── Internal: dispatch server messages ──────────────────────────────────
+  /** Called by RealtimeService when a server message arrives for this channel. */
+  _onMessage(msg) {
+    switch (msg.type) {
+      case "subscribed": {
+        const subMsg = msg;
+        if (subMsg.subscription_id) this._subscriptionId = subMsg.subscription_id;
+        this._clearSubscribeTimeout();
+        this._subscribeCallback?.("SUBSCRIBED");
+        break;
+      }
+      case "event": {
+        const evtMsg = msg;
+        if (evtMsg.id) {
+          const event = {
+            id: evtMsg.id,
+            event: evtMsg.event,
+            topic: evtMsg.topic,
+            payload: evtMsg.payload,
+            timestamp: evtMsg.timestamp,
+            allowed_sub_ids: evtMsg.allowed_sub_ids
+          };
+          this._dispatchEvent(event);
+        }
+        break;
+      }
+      case "presence_state": {
+        const presMsg = msg;
+        if (presMsg.presences) {
+          this._presenceState = {};
+          for (const p of presMsg.presences) {
+            const key = p.user_id || p.client_id;
+            if (!this._presenceState[key]) this._presenceState[key] = [];
+            this._presenceState[key].push(p);
+          }
+          for (const l of this._listeners) {
+            if (l.type === "presence" && l.filter.event === "sync") {
+              l.callback(this._presenceState);
+            }
+          }
+        }
+        break;
+      }
+      case "error": {
+        const errMsg = msg;
+        this._clearSubscribeTimeout();
+        this._subscribeCallback?.("CHANNEL_ERROR", new Error(errMsg.message ?? "Unknown error"));
+        break;
+      }
+      case "token_refreshed":
+        break;
+      case "broadcast_ack": {
+        const ackMsg = msg;
+        const refId = ackMsg.ref_id ?? ackMsg.message_id;
+        if (refId) {
+          const resolve = this._pendingAcks.get(refId);
+          if (resolve) {
+            this._pendingAcks.delete(refId);
+            resolve();
+          }
+        }
+        break;
+      }
+    }
+  }
+  /** Dispatch a RealtimeEvent to matching listeners. */
+  _dispatchEvent(event) {
+    if (!event) return;
+    if (event.id) this._lastEventId = event.id;
+    const allowed = event.allowed_sub_ids;
+    if (allowed && this._subscriptionId && !allowed.includes(this._subscriptionId)) {
+      return;
+    }
+    const eventType = event.event;
+    if (eventType === "presence") {
+      const payload = event.payload;
+      const action = payload.action;
+      const key = payload.user_id || payload.client_id;
+      if (action === "join") {
+        if (!this._presenceState[key]) this._presenceState[key] = [];
+        if (!this._presenceState[key].some((p) => p.client_id === payload.client_id)) {
+          const presenceInfo = {
+            client_id: payload.client_id,
+            user_id: payload.user_id ?? void 0,
+            metadata: payload.metadata ?? payload.meta ?? {},
+            joined_at: (/* @__PURE__ */ new Date()).toISOString(),
+            last_seen: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          this._presenceState[key].push(presenceInfo);
+        }
+      } else if (action === "leave") {
+        const arr = this._presenceState[key];
+        if (arr) {
+          const idx = arr.findIndex((p) => p.client_id === payload.client_id);
+          if (idx >= 0) arr.splice(idx, 1);
+          if (arr.length === 0) delete this._presenceState[key];
+        }
+      } else if (action === "update") {
+        const arr = this._presenceState[key];
+        if (arr) {
+          const idx = arr.findIndex((p) => p.client_id === payload.client_id);
+          if (idx >= 0) {
+            arr[idx].metadata = payload.metadata ?? payload.meta ?? {};
+            arr[idx].last_seen = (/* @__PURE__ */ new Date()).toISOString();
+          } else {
+            const presenceInfo = {
+              client_id: payload.client_id,
+              user_id: payload.user_id ?? void 0,
+              metadata: payload.metadata ?? payload.meta ?? {},
+              joined_at: (/* @__PURE__ */ new Date()).toISOString(),
+              last_seen: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            this._presenceState[key].push(presenceInfo);
+          }
+        } else {
+          this._presenceState[key] = [{
+            client_id: payload.client_id,
+            user_id: payload.user_id ?? void 0,
+            metadata: payload.metadata ?? payload.meta ?? {},
+            joined_at: (/* @__PURE__ */ new Date()).toISOString(),
+            last_seen: (/* @__PURE__ */ new Date()).toISOString()
+          }];
+        }
+      }
+    }
+    for (const listener of this._listeners) {
+      if (listener.type === "postgres_changes") {
+        const filter = listener.filter;
+        if (eventType === "insert" || eventType === "update" || eventType === "delete") {
+          const filterEvent = filter.event.toLowerCase();
+          if (filterEvent === "*" || filterEvent === eventType) {
+            const payload = event.payload;
+            if (filter.schema && payload.schema !== filter.schema) continue;
+            if (filter.table && payload.table !== filter.table) continue;
+            if (filter.filter) {
+              const target = eventType === "delete" ? payload.old_record : payload.record;
+              if (target && typeof target === "object") {
+                if (!matchesColumnFilter(filter.filter, target)) {
+                  continue;
+                }
+              }
+            }
+            listener.callback(event);
+          }
+        }
+      } else if (listener.type === "broadcast") {
+        if (eventType === "broadcast") {
+          const filter = listener.filter;
+          const payload = event.payload;
+          if (!filter.event || payload.event === filter.event) {
+            listener.callback(event);
+          }
+        }
+      } else if (listener.type === "presence") {
+        if (eventType === "presence") {
+          const filter = listener.filter;
+          const payload = event.payload;
+          const action = payload.action;
+          if (filter.event === "join" && action === "join") {
+            listener.callback({
+              key: payload.user_id || payload.client_id,
+              newPresences: [payload]
+            });
+          } else if (filter.event === "leave" && action === "leave") {
+            listener.callback({
+              key: payload.user_id || payload.client_id,
+              leftPresences: [payload]
+            });
+          } else if (filter.event === "sync") {
+            listener.callback(this.presenceState());
+          }
+        }
+      }
+    }
+  }
+  /** Whether this channel has been subscribed. */
+  get isSubscribed() {
+    return this._subscribed;
+  }
+  /** Get listeners (for re-subscribe after reconnect). */
+  _getListeners() {
+    return this._listeners;
+  }
+};
+
+// src/HeartbeatManager.ts
+var HeartbeatManager = class {
+  _worker = null;
+  _workerUrl = null;
+  _interval = null;
+  _sendFn = null;
+  start(sendPing, intervalMs = 25e3) {
+    this.stop();
+    this._sendFn = sendPing;
+    if (typeof Worker !== "undefined" && typeof URL !== "undefined" && typeof URL.createObjectURL === "function") {
+      try {
+        const code = `let i=null;onmessage=(e)=>{if(e.data.type==='start'){if(i)clearInterval(i);i=setInterval(()=>postMessage('ping'),e.data.interval||25000);}else if(e.data.type==='stop'){if(i){clearInterval(i);i=null;}}};`;
+        const blob = new Blob([code], { type: "application/javascript" });
+        this._workerUrl = URL.createObjectURL(blob);
+        this._worker = new Worker(this._workerUrl);
+        this._worker.onmessage = () => {
+          this._sendFn?.();
+        };
+        this._worker.postMessage({ type: "start", interval: intervalMs });
+        return;
+      } catch {
+        this._worker = null;
+        if (this._workerUrl) {
+          try {
+            URL.revokeObjectURL(this._workerUrl);
+          } catch {
+          }
+          this._workerUrl = null;
+        }
+      }
+    }
+    this._interval = setInterval(() => {
+      this._sendFn?.();
+    }, intervalMs);
+  }
+  stop() {
+    if (this._worker) {
+      try {
+        this._worker.postMessage({ type: "stop" });
+        this._worker.terminate();
+      } catch {
+      }
+      this._worker = null;
+    }
+    if (this._workerUrl) {
+      try {
+        URL.revokeObjectURL(this._workerUrl);
+      } catch {
+      }
+      this._workerUrl = null;
+    }
+    if (this._interval) {
+      clearInterval(this._interval);
+      this._interval = null;
+    }
+    this._sendFn = null;
+  }
+  get isActive() {
+    return this._worker !== null || this._interval !== null;
+  }
+};
+
+// src/jwt.ts
+function base64UrlToBase64(segment) {
+  let out = segment.replace(/-/g, "+").replace(/_/g, "/");
+  while (out.length % 4 !== 0) out += "=";
+  return out;
+}
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const raw = parts[1];
+    if (!raw) return null;
+    const json = atob(base64UrlToBase64(raw));
+    const parsed = JSON.parse(json);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function getTokenExpiryMs(token) {
+  const payload = decodeJwtPayload(token);
+  if (!payload) return null;
+  const exp = payload.exp;
+  if (typeof exp !== "number" || !Number.isFinite(exp)) return null;
+  return exp * 1e3;
+}
+
+// src/errors.ts
+var RealtimeConnectionError = class _RealtimeConnectionError extends Error {
+  /** Phase du cycle de vie où l'échec s'est produit. */
+  phase;
+  /** Code de fermeture WebSocket (RFC 6455 §7.4), si le runtime l'a fourni. */
+  code;
+  /** Raison de fermeture fournie par le serveur, si présente (souvent vide). */
+  reason;
+  constructor(phase, message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = "RealtimeConnectionError";
+    this.phase = phase;
+    this.code = options?.code;
+    this.reason = options?.reason;
+    Object.setPrototypeOf(this, _RealtimeConnectionError.prototype);
+  }
+};
+
+// src/RealtimeService.ts
+var HEARTBEAT_INTERVAL_MS = 25e3;
+var MAX_TIMEOUT_MS = 2147483647;
+var RealtimeService = class _RealtimeService {
+  client;
+  _ws = null;
+  _channels = /* @__PURE__ */ new Map();
+  _state = "disconnected";
+  _stateListeners = /* @__PURE__ */ new Set();
+  // ─── Reconnection state ──────────────────────────────────────────────
+  _autoReconnect = true;
+  _reconnectAttempts = 0;
+  _maxReconnectAttempts = Infinity;
+  _reconnectTimer = null;
+  _intentionalClose = false;
+  _heartbeat = new HeartbeatManager();
+  _tokenRefreshTimer = null;
+  /** Dernier access_token propagé au serveur — évite les pushs redondants (propagation différentielle). */
+  _lastSentToken = null;
+  /** Listeners d'erreurs de transport (handshake refusé, coupure, connexion morte). */
+  _errorListeners = /* @__PURE__ */ new Set();
+  /**
+   * `true` entre l'envoi d'un ping et la réception du message serveur suivant.
+   * S'il est encore `true` au tick de heartbeat suivant, aucun octet applicatif
+   * n'est revenu en 25 s alors que le serveur en pousse au moins un toutes les
+   * 30 s et répond au ping : la connexion est morte (TCP à demi-fermé).
+   */
+  _awaitingPong = false;
+  /** Backoff delays in ms: 1s, 2s, 4s, 8s, 16s, 30s (cap) */
+  static BACKOFF_MS = [1e3, 2e3, 4e3, 8e3, 16e3, 3e4];
+  constructor(client) {
+    this.client = client;
+  }
+  /** Current connection state. */
+  get connectionState() {
+    return this._state;
+  }
+  /** Listen for connection state changes. */
+  onStateChange(callback) {
+    this._stateListeners.add(callback);
+    return () => this._stateListeners.delete(callback);
+  }
+  _setState(state) {
+    this._state = state;
+    for (const cb of this._stateListeners) {
+      try {
+        cb(state);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Écoute les erreurs de transport de la connexion realtime.
+   *
+   * Complète `onStateChange` (qui ne dit que « ça a bougé ») en fournissant la
+   * CAUSE : handshake refusé (typiquement un 401 sur le token/apikey), coupure
+   * inattendue, ou connexion morte détectée par le heartbeat. Sans ce canal,
+   * un refus d'authentification était totalement silencieux — la boucle de
+   * reconnexion tournait indéfiniment sans que l'appelant puisse le savoir.
+   *
+   * @returns Une fonction de désabonnement.
+   *
+   * @example
+   * ```ts
+   * aura.realtime.onError((err) => {
+   *   if (err.phase === 'handshake') {
+   *     // token expiré / apikey invalide → renouveler la session
+   *   }
+   * })
+   * ```
+   */
+  onError(callback) {
+    this._errorListeners.add(callback);
+    return () => this._errorListeners.delete(callback);
+  }
+  /**
+   * Diffuse une erreur de transport : aux listeners `onError`, puis à tous les
+   * canaux sous forme de `CHANNEL_ERROR` (mécanisme officiel Supabase — chez
+   * phoenix, `Socket#triggerChanError` fait exactement cela).
+   *
+   * Chaque callback est isolé : un listener qui jette ne doit jamais interrompre
+   * la diffusion ni la boucle de reconnexion.
+   */
+  _emitError(err) {
+    const listeners = Array.from(this._errorListeners);
+    const channels = Array.from(this._channels.values());
+    for (const cb of listeners) {
+      try {
+        cb(err);
+      } catch {
+      }
+    }
+    for (const ch of channels) {
+      try {
+        ch._signalError(err);
+      } catch {
+      }
+    }
+  }
+  // ─── WebSocket URL ──────────────────────────────────────────────────────
+  get _wsUrl() {
+    const base = this.client.baseUrl.replace(/^http/, "ws");
+    return `${base}/v1/realtime/ws`;
+  }
+  // ─── Connection management ──────────────────────────────────────────────
+  /** Ensure the WebSocket connection is open. */
+  connect() {
+    if (this._ws && (this._ws.readyState === WebSocket.OPEN || this._ws.readyState === WebSocket.CONNECTING)) {
+      return;
+    }
+    this._intentionalClose = false;
+    this._setState("connecting");
+    const token = this.client.authStore.token;
+    const params = new URLSearchParams();
+    if (token) params.set("token", token);
+    if (this.client.apiKey) params.set("apikey", this.client.apiKey);
+    const url = `${this._wsUrl}?${params.toString()}`;
+    const ws = new WebSocket(url);
+    this._ws = ws;
+    let opened = false;
+    ws.onopen = () => {
+      if (ws !== this._ws) {
+        try {
+          ws.close();
+        } catch {
+        }
+        return;
+      }
+      opened = true;
+      this._reconnectAttempts = 0;
+      this._setState("connected");
+      this._awaitingPong = false;
+      this._heartbeat.start(() => this._heartbeatTick(ws), HEARTBEAT_INTERVAL_MS);
+      this._scheduleTokenRefresh();
+      for (const channel of this._channels.values()) {
+        channel._bindSend((data) => this._send(data));
+        if (channel.isSubscribed) {
+          channel._doSubscribe();
+        }
+      }
+    };
+    ws.onmessage = (evt) => {
+      if (ws !== this._ws) return;
+      this._awaitingPong = false;
+      try {
+        const raw = typeof evt.data === "string" ? evt.data : "";
+        const msg = JSON.parse(raw);
+        this._dispatch(msg);
+      } catch (e) {
+        if (typeof console !== "undefined") {
+          console.warn("[aura-realtime] Failed to parse WS message:", evt.data, e);
+        }
+      }
+    };
+    ws.onclose = (evt) => {
+      if (ws !== this._ws) return;
+      const intentional = this._intentionalClose;
+      this._detachSocket();
+      if (!intentional) {
+        this._emitError(
+          opened ? new RealtimeConnectionError(
+            "connection",
+            "Realtime : connexion WebSocket ferm\xE9e de fa\xE7on inattendue.",
+            { code: evt?.code, reason: evt?.reason }
+          ) : new RealtimeConnectionError(
+            "handshake",
+            "Realtime : \xE9chec du handshake WebSocket (ferm\xE9 avant ouverture). Causes possibles, par ordre de fr\xE9quence : authentification refus\xE9e (HTTP 401/403 \u2014 token JWT absent, expir\xE9 ou invalide, apikey rejet\xE9e), quota de connexions atteint (HTTP 429), ou serveur injoignable / en red\xE9marrage / bloqu\xE9 par un proxy ou TLS. La sp\xE9cification WebSocket n'expose pas le statut HTTP du handshake au client : le SDK ne peut pas trancher entre ces causes.",
+            { code: evt?.code ?? 1006, reason: evt?.reason }
+          )
+        );
+      }
+      if (intentional || this._intentionalClose) {
+        this._setState("disconnected");
+        this._intentionalClose = false;
+      } else if (this._autoReconnect) {
+        this._scheduleReconnect();
+      } else {
+        this._setState("disconnected");
+      }
+    };
+    ws.onerror = (evt) => {
+      if (ws !== this._ws) return;
+      if (typeof console !== "undefined") {
+        console.warn("[aura-realtime] WebSocket error", evt);
+      }
+    };
+  }
+  /**
+   * Détache le socket courant et remet à zéro tout ce qui lui était attaché.
+   * Partagé par `onclose` et par la détection de connexion morte (qui ne peut PAS
+   * compter sur un `onclose` : une socket à demi-fermée n'en émet parfois jamais).
+   */
+  _detachSocket() {
+    this._ws = null;
+    this._lastSentToken = null;
+    this._awaitingPong = false;
+    this._heartbeat.stop();
+  }
+  /**
+   * Un tick de heartbeat : vérifie la liveness du lien puis émet un ping.
+   *
+   * Règle (calquée sur `Socket#sendHeartbeat`/`heartbeatTimeout` de phoenix, que
+   * `@supabase/realtime-js` réutilise) : si le ping du tick précédent n'a été suivi
+   * d'AUCUN message serveur, la connexion est morte. Le contrat serveur rend cette
+   * règle sûre — `aura-realtime` répond au ping immédiatement ET pousse un pong
+   * spontané toutes les 30 s : 25 s de silence total ne peuvent pas être normaux.
+   */
+  _heartbeatTick(ws) {
+    if (ws !== this._ws) return;
+    if (ws.readyState !== WebSocket.OPEN) {
+      this._handleDeadConnection(
+        "Realtime : la connexion WebSocket n\u2019est plus ouverte mais aucun \xE9v\xE9nement de fermeture n\u2019est arriv\xE9 (socket fig\xE9). Reconnexion."
+      );
+      return;
+    }
+    if (this._awaitingPong) {
+      this._handleDeadConnection(
+        `Realtime : connexion inactive \u2014 aucune r\xE9ponse du serveur dans les ${HEARTBEAT_INTERVAL_MS} ms suivant un ping (connexion probablement morte). Reconnexion.`
+      );
+      return;
+    }
+    this._awaitingPong = true;
+    this._send(JSON.stringify({ type: "ping" }));
+  }
+  /**
+   * Connexion « zombie » : ouverte du point de vue du système, muette en pratique.
+   *
+   * On ne peut pas se contenter d'appeler `close()` et d'attendre le `onclose` :
+   * sur un TCP à demi-fermé, la frame Close part dans le vide et l'événement peut
+   * n'arriver que bien plus tard (voire jamais). On détache donc le socket
+   * IMMÉDIATEMENT — la garde `ws !== this._ws` neutralisera son `onclose` tardif —
+   * puis on relance le cycle de reconnexion nous-mêmes.
+   */
+  _handleDeadConnection(message) {
+    const dead = this._ws;
+    this._detachSocket();
+    if (dead) {
+      try {
+        dead.close();
+      } catch {
+      }
+    }
+    this._emitError(new RealtimeConnectionError("liveness", message));
+    if (this._autoReconnect && !this._intentionalClose) {
+      this._scheduleReconnect();
+    } else {
+      this._intentionalClose = false;
+      this._setState("disconnected");
+    }
+  }
+  /** Send raw data through the WebSocket. */
+  _send(data) {
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) {
+      this._ws.send(data);
+    }
+  }
+  /** Refresh the JWT token on an existing connection (no disconnect). */
+  refreshToken(token) {
+    if (token === this._lastSentToken) {
+      this._scheduleTokenRefresh();
+      return;
+    }
+    this._lastSentToken = token;
+    this._send(JSON.stringify({ type: "access_token", token }));
+    this._scheduleTokenRefresh();
+  }
+  /**
+   * Définit/rafraîchit explicitement le token utilisé pour l'autorisation des
+   * canaux privés et broadcast (parité `@supabase/realtime-js` `setAuth`).
+   *
+   * - Avec `token` : utilise ce token. Sinon, reprend `client.authStore.token`.
+   * - Propage via le pipeline existant `refreshToken` (push
+   *   `{ type:'access_token', token }` sur une connexion ouverte, dédupliqué via
+   *   `_lastSentToken`). N'ouvre ni ne ferme aucune connexion WS.
+   * - Hors-ligne : `connect()` lit `client.authStore.token` au moment de l'open,
+   *   donc `setAuth()` doit être appelé avec un token présent dans le store (ou
+   *   après authentification) pour prendre effet sur une future connexion.
+   *
+   * À appeler AVANT de s'abonner à un canal privé (`channel(name,{private:true})`).
+   *
+   * @example
+   * ```ts
+   * aura.realtime.setAuth(session.access_token)
+   * const ch = aura.realtime.channel('secret', { private: true }).subscribe()
+   * ```
+   */
+  setAuth(token) {
+    const resolved = token ?? this.client.authStore.token;
+    if (resolved == null) return;
+    this.refreshToken(resolved);
+  }
+  /**
+   * Envoie un broadcast par HTTP (REST), sans connexion WebSocket ouverte
+   * (parité `@supabase/realtime-js`). Utile côté serveur/edge.
+   *
+   * POST `/v1/realtime/{projectId}/broadcast` avec le contrat du handler backend
+   * (`broadcast.rs`) : `{ channel, payload }`, `channel` préfixé par le projet,
+   * `event` replié dans `payload` (aligné sur le broadcast WS).
+   *
+   * @param channel Nom du canal (préfixé projet automatiquement si absent).
+   * @param event   Nom de l'événement broadcast.
+   * @param payload Données de l'événement.
+   * @returns `AuraResponse<null>` — `error` non nul en cas de 4xx/rate-limit.
+   *
+   * @example
+   * ```ts
+   * await aura.realtime.httpBroadcast('room-1', 'cursor', { x: 10, y: 20 })
+   * ```
+   */
+  httpBroadcast(channel, event, payload = {}) {
+    const prefix = `${this.client.projectId}:`;
+    const fullChannel = channel.startsWith(prefix) ? channel : `${prefix}${channel}`;
+    const body = {
+      channel: fullChannel,
+      payload: { event, ...payload }
+    };
+    return fetchWithAuth(
+      `${this.client.baseUrl}/v1/realtime/${this.client.projectId}/broadcast`,
+      { method: "POST", body },
+      this.client
+    );
+  }
+  /**
+   * Schedule proactive token refresh at 80% of the JWT TTL.
+   * Prevents token expiration during an active WebSocket session.
+   */
+  _scheduleTokenRefresh() {
+    if (this._tokenRefreshTimer) {
+      clearTimeout(this._tokenRefreshTimer);
+      this._tokenRefreshTimer = null;
+    }
+    const token = this.client.authStore.token;
+    if (!token) return;
+    const exp = getTokenExpiryMs(token);
+    if (exp === null) return;
+    const ttl = exp - Date.now();
+    if (ttl <= 0) return;
+    const refreshIn = ttl * 0.8;
+    if (refreshIn > MAX_TIMEOUT_MS) {
+      this._tokenRefreshTimer = setTimeout(() => {
+        this._tokenRefreshTimer = null;
+        this._scheduleTokenRefresh();
+      }, MAX_TIMEOUT_MS);
+      return;
+    }
+    this._tokenRefreshTimer = setTimeout(async () => {
+      this._tokenRefreshTimer = null;
+      try {
+        const res = await this.client.auth.refreshSession();
+        if (res.data) {
+          this.refreshToken(res.data.access_token);
+        }
+      } catch {
+      }
+    }, refreshIn);
+  }
+  /** Schedule a reconnection attempt with exponential backoff + jitter. */
+  _scheduleReconnect() {
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    if (this._reconnectAttempts >= this._maxReconnectAttempts) {
+      this._setState("disconnected");
+      return;
+    }
+    this._reconnectAttempts++;
+    this._setState("reconnecting");
+    const idx = Math.min(this._reconnectAttempts - 1, _RealtimeService.BACKOFF_MS.length - 1);
+    const baseDelay = _RealtimeService.BACKOFF_MS[idx];
+    const jitter = Math.random() * baseDelay * 0.25;
+    const delay = baseDelay + jitter;
+    this._reconnectTimer = setTimeout(() => {
+      this._reconnectTimer = null;
+      this.connect();
+    }, delay);
+  }
+  /** Enable/disable auto-reconnect (enabled by default). */
+  setAutoReconnect(enabled, maxAttempts) {
+    this._autoReconnect = enabled;
+    if (maxAttempts !== void 0) this._maxReconnectAttempts = maxAttempts;
+  }
+  /** Disconnect the WebSocket and clean up all channels. */
+  disconnect() {
+    this._intentionalClose = true;
+    this._heartbeat.stop();
+    if (this._tokenRefreshTimer) {
+      clearTimeout(this._tokenRefreshTimer);
+      this._tokenRefreshTimer = null;
+    }
+    if (this._reconnectTimer) {
+      clearTimeout(this._reconnectTimer);
+      this._reconnectTimer = null;
+    }
+    this._reconnectAttempts = 0;
+    this._awaitingPong = false;
+    for (const channel of this._channels.values()) {
+      channel.unsubscribe();
+    }
+    this._channels.clear();
+    if (this._ws) {
+      this._ws.close();
+      this._ws = null;
+    }
+    this._setState("disconnected");
+    this._lastSentToken = null;
+  }
+  // ─── Channel factory ────────────────────────────────────────────────────
+  /**
+   * Create or retrieve a channel by name.
+   * Returns an `AuraChannel` with chainable `.on()` / `.subscribe()` API.
+   *
+   * @example
+   * ```ts
+   * const channel = aura.realtime.channel('room-1')
+   * ```
+   */
+  channel(name, options) {
+    const existing = this._channels.get(name);
+    if (existing) return existing;
+    const ch = new AuraChannel(name, this.client.projectId, options);
+    this._channels.set(name, ch);
+    this.connect();
+    if (this._ws && this._ws.readyState === WebSocket.OPEN) {
+      ch._bindSend((data) => this._send(data));
+    }
+    return ch;
+  }
+  /** Remove a channel. */
+  removeChannel(name) {
+    const ch = this._channels.get(name);
+    if (ch) {
+      ch.unsubscribe();
+      this._channels.delete(name);
+    }
+  }
+  /** List active channels. */
+  getChannels() {
+    return Array.from(this._channels.values());
+  }
+  /** Remove all channels and subscriptions. */
+  removeAllChannels() {
+    for (const ch of this._channels.values()) {
+      ch.unsubscribe();
+    }
+    this._channels.clear();
+  }
+  // ─── Message dispatch ───────────────────────────────────────────────────
+  /** Route incoming server messages to the correct channel. */
+  _dispatch(msg) {
+    const channelFull = "channel" in msg ? msg.channel : "topic" in msg ? msg.topic : void 0;
+    if (channelFull) {
+      const prefix = `${this.client.projectId}:`;
+      const name = channelFull.startsWith(prefix) ? channelFull.slice(prefix.length) : channelFull;
+      const ch = this._channels.get(name);
+      if (ch) {
+        ch._onMessage(msg);
+        return;
+      }
+      for (const [, channel] of this._channels) {
+        if (channel.fullName === channelFull || channelFull.startsWith(channel.fullName + ":")) {
+          channel._onMessage(msg);
+          return;
+        }
+      }
+    }
+    if (msg.type === "token_refreshed") {
+      return;
+    }
+    if (msg.type === "pong") {
+      return;
+    }
+    if (msg.type === "broadcast_ack") {
+      const ack = msg;
+      const refId = ack.ref_id ?? ack.message_id;
+      if (refId) {
+        const marker = refId.lastIndexOf(":r");
+        if (marker > 0) {
+          const fullName = refId.slice(0, marker);
+          for (const ch of this._channels.values()) {
+            if (ch.fullName === fullName) {
+              ch._onMessage(msg);
+              return;
+            }
+          }
+        }
+      }
+      for (const ch of this._channels.values()) {
+        ch._onMessage(msg);
+      }
+      return;
+    }
+    if (msg.type === "error") {
+      for (const ch of this._channels.values()) {
+        ch._onMessage(msg);
+      }
+    }
+  }
+  // ─── Backward compatibility ─────────────────────────────────────────────
+  /**
+   * Simple callback-based subscription (legacy API).
+   * Prefer using `.channel().on().subscribe()` instead.
+   *
+   * @deprecated Use `channel().on().subscribe()` instead.
+   */
+  on(channelName, callback) {
+    this.connect();
+    const ch = this.channel(channelName);
+    ch.on("postgres_changes", { event: "*" }, callback);
+    ch.subscribe();
+    return {
+      unsubscribe: () => this.removeChannel(channelName)
+    };
+  }
+};
+
+export { AuraChannel, DEFAULT_SUBSCRIBE_TIMEOUT_MS, HEARTBEAT_INTERVAL_MS, HeartbeatManager, RealtimeConnectionError, RealtimeService };