naro-js 0.5.0 → 0.6.0

package/dist/index.js

@@ -67,6 +67,105 @@ function cryptoUnavailable() {
     message: "This runtime has no crypto.subtle, which signing in with a provider needs (https or localhost)."
   };
 }
+var SERVICE_KEY_OFF_SERVER_MESSAGE = "A Naro service key (naro_sk_\u2026) skips every policy, so createClient accepts it only on a server (Node, Deno, Bun, Cloudflare Workers, an edge runtime), never in a browser, a web worker or a React Native app. Use the anon key (naro_pk_\u2026) here and keep the service key on your server.";
+function websocketUnavailable() {
+  return {
+    code: "WEBSOCKET_UNAVAILABLE",
+    message: "This runtime has no WebSocket. Pass one to createClient({ realtime: { WebSocket } })."
+  };
+}
+function realtimeTimedOut(ms) {
+  const seconds = Math.max(1, Math.round(ms / 1e3));
+  return {
+    code: "TIMED_OUT",
+    message: `The Naro realtime server did not answer within ${String(seconds)} seconds.`
+  };
+}
+function realtimeClosed(code) {
+  return {
+    code: "NETWORK_ERROR",
+    message: `The realtime connection to the Naro backend closed (${String(code)}). It reconnects on its own.`,
+    details: { code }
+  };
+}
+function realtimeDisconnected() {
+  return {
+    code: "ABORTED",
+    message: "The realtime connection was closed by the app (it removed its last channel) before the Naro realtime server answered."
+  };
+}
+function realtimeStopped(code, reason) {
+  return {
+    code: reason === "" ? "NETWORK_ERROR" : reason,
+    message: `The realtime connection to the Naro backend closed (${String(code)}) and does not reconnect.`,
+    details: { code }
+  };
+}
+function socketRefused(error) {
+  return {
+    code: "NETWORK_ERROR",
+    message: "The realtime connection to the Naro backend could not be opened.",
+    details: { cause: error instanceof Error ? error.name : typeof error }
+  };
+}
+function invalidChannel(reason) {
+  return {
+    code: "INVALID_CHANNEL",
+    message: `The channel name is not valid: it ${reason}.`
+  };
+}
+function invalidChannelConfig(path, reason) {
+  return {
+    code: "INVALID_CHANNEL_CONFIG",
+    message: "The channel settings are not valid.",
+    details: { path, reason }
+  };
+}
+function serviceKeyOffServer() {
+  return {
+    code: "SERVICE_KEY_OFF_SERVER",
+    message: SERVICE_KEY_OFF_SERVER_MESSAGE
+  };
+}
+function notJoined(channel) {
+  return {
+    code: "NOT_JOINED",
+    message: `Join ${channel} before sending to it.`
+  };
+}
+function invalidBroadcast() {
+  return {
+    code: "INVALID_MESSAGE",
+    message: "The message is not a valid Naro realtime frame.",
+    details: { reason: "needs type broadcast" }
+  };
+}
+function invalidPresence() {
+  return {
+    code: "INVALID_MESSAGE",
+    message: "The message is not a valid Naro realtime frame.",
+    details: { reason: "needs a presence payload object" }
+  };
+}
+function frameTooLarge(limit) {
+  return {
+    code: "INVALID_MESSAGE",
+    message: "The message is not a valid Naro realtime frame.",
+    details: { reason: `is larger than ${String(limit)} bytes` }
+  };
+}
+function clientFlooding(perSecond) {
+  return {
+    code: "CLIENT_FLOODING",
+    message: `This connection is sending messages faster than a connection may (${String(perSecond)} a second), so this one was not sent. Send less often.`
+  };
+}
+function channelClosed() {
+  return {
+    code: "CHANNEL_CLOSED",
+    message: "The Naro realtime server closed this channel."
+  };
+}
 function describe(cause) {
   if (cause instanceof Error) return `${cause.name}: ${cause.message}`;
   return String(cause);
@@ -91,9 +190,9 @@ function errorFromBody(status, body) {
 }
 
 // src/http.ts
-var AUTH_PREFIX = "/auth/";
+var SESSION_PREFIXES = ["/auth/", "/realtime/"];
 function storeFor(config, path) {
-  return path.startsWith(AUTH_PREFIX) ? config.tokens : config.accessJwt ?? null;
+  return SESSION_PREFIXES.some((prefix) => path.startsWith(prefix)) ? config.tokens : config.accessJwt ?? null;
 }
 async function receive(config, options, init) {
   const controller = options.timeoutMs !== void 0 && typeof AbortController === "function" ? new AbortController() : null;
@@ -245,7 +344,9 @@ var RETRY_AFTER_CODES = /* @__PURE__ */ new Set([
   // Storage (original spec §13): one object written twice within a second
   // (`x-retry-after: 1`), and the daily operation limit (3-1d).
   "OBJECT_RATE_LIMITED",
-  "STORAGE_OPS_QUOTA_EXCEEDED"
+  "STORAGE_OPS_QUOTA_EXCEEDED",
+  // Realtime's REST broadcast over the project's message budget (x-retry-after: 1).
+  "TOO_MANY_MESSAGES"
 ]);
 function withRetryAfter(error, headers) {
   const header = headers.get("x-retry-after")?.trim() ?? "";
@@ -836,7 +937,7 @@ var MAX_FLOWS = 10;
 function isEntry(value) {
   return typeof value === "object" && value !== null && typeof value.verifier === "string" && typeof value.expiresAt === "number";
 }
-function live(text, now) {
+function live(text, now2) {
   if (text === null) return {};
   let parsed;
   try {
@@ -847,7 +948,7 @@ function live(text, now) {
   if (typeof parsed !== "object" || parsed === null) return {};
   const entries = {};
   for (const [flow, entry] of Object.entries(parsed))
-    if (isEntry(entry) && entry.expiresAt > now) entries[flow] = entry;
+    if (isEntry(entry) && entry.expiresAt > now2) entries[flow] = entry;
   return entries;
 }
 function pick(entries, oldest) {
@@ -863,16 +964,16 @@ function serialize(entries) {
 var FlowVerifiers = class {
   #store;
   #now;
-  constructor(store, now = Date.now) {
+  constructor(store, now2 = Date.now) {
     this.#store = store;
-    this.#now = now;
+    this.#now = now2;
   }
   /** Keeps `verifier` for the flow `flow`, for ten minutes. */
   async add(flow, verifier) {
-    const now = this.#now();
+    const now2 = this.#now();
     await this.#store.update((text) => {
-      const entries = live(text, now);
-      entries[flow] = { verifier, expiresAt: now + FLOW_TTL_MS };
+      const entries = live(text, now2);
+      entries[flow] = { verifier, expiresAt: now2 + FLOW_TTL_MS };
       while (Object.keys(entries).length > MAX_FLOWS) {
         const oldest = pick(entries, true);
         if (oldest === void 0) break;
@@ -887,10 +988,10 @@ var FlowVerifiers = class {
    * expired.
    */
   async take(flow) {
-    const now = this.#now();
+    const now2 = this.#now();
     let taken = null;
     await this.#store.update((text) => {
-      const entries = live(text, now);
+      const entries = live(text, now2);
       const id = flow ?? pick(entries, false);
       if (id !== void 0 && Object.hasOwn(entries, id)) {
         taken = entries[id]?.verifier ?? null;
@@ -917,9 +1018,9 @@ function parse(text) {
 var RecoveryToken = class {
   #store;
   #now;
-  constructor(store, now = () => Date.now()) {
+  constructor(store, now2 = () => Date.now()) {
     this.#store = store;
-    this.#now = now;
+    this.#now = now2;
   }
   /** Keeps the token a recovery link brought, for 15 minutes. */
   async keep(token) {
@@ -928,11 +1029,11 @@ var RecoveryToken = class {
   }
   /** The token, while it lasts; an expired or unreadable one is cleared. */
   async current() {
-    const now = this.#now();
+    const now2 = this.#now();
     let token = null;
     await this.#store.update((text) => {
       const kept = parse(text);
-      if (kept === null || kept.expiresAt <= now) return null;
+      if (kept === null || kept.expiresAt <= now2) return null;
       token = kept.token;
       return text;
     });
@@ -994,6 +1095,8 @@ var TokenStore = class {
   #fallback = null;
   /** Settles when the last queued operation has finished. */
   #queue = Promise.resolve();
+  /** Called after each write; see `subscribe`. */
+  #listeners = /* @__PURE__ */ new Set();
   constructor(storage, key) {
     this.#storage = storage;
     this.#key = key;
@@ -1002,21 +1105,31 @@ var TokenStore = class {
     return this.#serial(() => this.#get());
   }
   set(token) {
-    return this.#serial(() => this.#set(token));
+    return this.#serial(async () => {
+      await this.#set(token);
+      this.#changed();
+    });
   }
   clear() {
-    return this.#serial(() => this.#clear());
+    return this.#serial(async () => {
+      await this.#clear();
+      this.#changed();
+    });
   }
   /**
-   * Clears only if the stored token is still the one that was rejected. A
-   * request that left with an old token can come back after the user signed
-   * in again; its INVALID_SESSION must not sign the new session out. The
-   * read and the removal are one operation: with an async storage, a sign-in
-   * that lands between them would otherwise be the token removed.
+   * Clears only if the stored token is still the one that was rejected, and
+   * says whether it did. A request that left with an old token can come back
+   * after the user signed in again; its INVALID_SESSION must not sign the
+   * new session out. The read and the removal are one operation: with an
+   * async storage, a sign-in that lands between them would otherwise be the
+   * token removed.
    */
   clearIf(token) {
     return this.#serial(async () => {
-      if (await this.#get() === token) await this.#clear();
+      if (await this.#get() !== token) return false;
+      await this.#clear();
+      this.#changed();
+      return true;
     });
   }
   /**
@@ -1029,17 +1142,42 @@ var TokenStore = class {
       const next = transform(await this.#get());
       if (next === null) await this.#clear();
       else await this.#set(next);
+      this.#changed();
     });
   }
   /** Stores `next` only if `expected` is still stored, as one operation. */
   replaceIf(expected, next) {
     return this.#serial(async () => {
-      if (await this.#get() === expected) await this.#set(next);
+      if (await this.#get() !== expected) return;
+      await this.#set(next);
+      this.#changed();
     });
   }
+  /**
+   * Calls `listener` after every write of the token — a sign-in, a
+   * sign-out, a renewed session, a cleared INVALID_SESSION — from inside the
+   * write's turn, so a `get()` it starts reads the value just written — or
+   * that of a write already queued behind it, which calls the listener
+   * again. The Realtime connection (Realtime 3-2d) uses it to tell the hub.
+   * What a listener throws is its own: the write has happened and stands.
+   */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  #changed() {
+    for (const listener of Array.from(this.#listeners)) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
   /**
    * Runs `operation` once every earlier one has finished. The operations
-   * below never reject, and none of them calls a public method (that would
+   * below never reject, and none of them awaits a public method (that would
    * wait on itself).
    */
   #serial(operation) {
@@ -1856,6 +1994,2073 @@ var TableBuilder = class {
   }
 };
 
+// src/realtime/close.ts
+var BACKOFF_STEPS_MS = [1e3, 2e3, 5e3, 1e4];
+var RATE_LIMITED_MIN_MS = 5e3;
+var IP_LIMIT_WAIT_MS = 6e4;
+var RESTART_JITTER_MS = 1e4;
+var UNOPENED_SLOWDOWN_AFTER = 6;
+var UNOPENED_DELAY_MS = 6e4;
+var STOP_CODES = /* @__PURE__ */ new Set([
+  1e3,
+  4e3,
+  4001,
+  4003,
+  4004,
+  4410
+]);
+function closeAction(code, reason) {
+  if (STOP_CODES.has(code)) return { kind: "stop" };
+  if (code === 4401) return { kind: "session" };
+  if (code === 4503) return { kind: "restart" };
+  if (code === 4029)
+    return reason === "IP_RATE_LIMITED" ? { kind: "wait", ms: IP_LIMIT_WAIT_MS } : { kind: "retry", minMs: RATE_LIMITED_MIN_MS };
+  return { kind: "retry", minMs: 0 };
+}
+function backoffMs(attempt2, random) {
+  const step = BACKOFF_STEPS_MS[Math.min(attempt2, BACKOFF_STEPS_MS.length - 1)] ?? 1e4;
+  return Math.round(step * (0.5 + random()));
+}
+function delayAfter(action, state, random) {
+  if (action.kind === "restart")
+    return Math.floor(random() * RESTART_JITTER_MS);
+  if (action.kind === "wait")
+    return action.ms + Math.floor(random() * RESTART_JITTER_MS);
+  const base = state.unopened >= UNOPENED_SLOWDOWN_AFTER ? Math.round(UNOPENED_DELAY_MS * (0.5 + random())) : backoffMs(state.attempt, random);
+  return Math.max(action.kind === "retry" ? action.minMs : 0, base);
+}
+
+// src/realtime/presence.ts
+function entryOf(meta) {
+  if (!isRecord(meta) || typeof meta.phx_ref !== "string") return null;
+  const { phx_ref: ref, naro_user_id: user, ...state } = meta;
+  return {
+    ...state,
+    presence_ref: ref,
+    naro_user_id: typeof user === "string" ? user : null
+  };
+}
+function entriesOf(value) {
+  const read = /* @__PURE__ */ new Map();
+  if (!isRecord(value)) return read;
+  for (const [key, item] of Object.entries(value)) {
+    if (!isRecord(item) || !Array.isArray(item.metas)) continue;
+    const entries = item.metas.map(entryOf).filter((entry) => entry !== null);
+    if (entries.length > 0) read.set(key, entries);
+  }
+  return read;
+}
+function without(entries, gone) {
+  return entries.filter(
+    (entry) => !gone.some((left) => left.presence_ref === entry.presence_ref)
+  );
+}
+function copies(entries) {
+  return entries.map((entry) => ({ ...entry }));
+}
+var Presence = class {
+  #state = /* @__PURE__ */ new Map();
+  /** A presence_state came for the current join: diffs apply only after it. */
+  #synced = false;
+  state() {
+    return Object.fromEntries(
+      [...this.#state].map(([key, entries]) => [key, copies(entries)])
+    );
+  }
+  /** A new join, or the connection dropped: what is here stays until its presence_state. */
+  unsync() {
+    this.#synced = false;
+  }
+  clear() {
+    this.#state = /* @__PURE__ */ new Map();
+    this.#synced = false;
+  }
+  /**
+   * No presence_state will say what is here any more (a join that may not
+   * read presence, one refused, the server's close, a stop — plan 정정
+   * (k)): each key leaves, then sync — said only when someone was here. A
+   * diff waits for the next presence_state.
+   */
+  leaveAll(emit) {
+    if (this.#state.size > 0) this.applyState({}, emit);
+    this.#synced = false;
+  }
+  applyState(payload, emit) {
+    const before = this.#state;
+    const next = entriesOf(payload);
+    this.#state = next;
+    this.#synced = true;
+    for (const [key, entries] of next) {
+      const held = before.get(key) ?? [];
+      const added = without(entries, held);
+      if (added.length > 0) emit.join(key, copies(added), copies(held));
+    }
+    for (const [key, entries] of before) {
+      const left = without(entries, next.get(key) ?? []);
+      if (left.length > 0)
+        emit.leave(key, copies(left), copies(next.get(key) ?? []));
+    }
+    emit.sync();
+  }
+  applyDiff(payload, emit) {
+    if (!this.#synced || !isRecord(payload)) return;
+    for (const [key, added] of entriesOf(payload.joins)) {
+      const held = this.#state.get(key) ?? [];
+      this.#state.set(key, [...without(held, added), ...added]);
+      emit.join(key, copies(added), copies(held));
+    }
+    for (const [key, left] of entriesOf(payload.leaves)) {
+      const current = without(this.#state.get(key) ?? [], left);
+      if (current.length > 0) this.#state.set(key, current);
+      else this.#state.delete(key);
+      emit.leave(key, copies(left), copies(current));
+    }
+    emit.sync();
+  }
+};
+
+// src/realtime/protocol.ts
+var REALTIME_PROTOCOL_VERSION = "1.0.0";
+var PHOENIX_TOPIC = "phoenix";
+var REALTIME_TOPIC_PREFIX = "realtime:";
+var HEARTBEAT_REQUEST = '{"topic":"phoenix","event":"heartbeat","payload":{},"ref":"hb"}';
+var HEARTBEAT_REF = "hb";
+var MAX_CHANNEL_NAME_LENGTH = 128;
+var CONNECTION_FRAMES_PER_SECOND = 10;
+var CONNECTION_FRAME_BURST = 120;
+var WARNED_CODES = /* @__PURE__ */ new Set([
+  "TOO_MANY_JOINS",
+  "TOO_MANY_MESSAGES",
+  "TOO_MANY_PRESENCE_MESSAGES"
+]);
+var FLOOD_WINDOW_MS = 6e4;
+var MAX_CHANGE_CHANNELS_PER_TABLE = 4;
+var CHANGE_CHANNELS_REASON = `would put more than ${String(MAX_CHANGE_CHANNELS_PER_TABLE)} channels of this connection on one table's changes (* counts for every table): add the subscription to a channel it already has`;
+function readServerFrame(data) {
+  if (typeof data !== "string") return null;
+  let value;
+  try {
+    value = JSON.parse(data);
+  } catch {
+    return null;
+  }
+  if (!isRecord(value)) return null;
+  const { topic, event, payload, ref } = value;
+  const joinRef = value.join_ref;
+  if (typeof topic !== "string" || typeof event !== "string") return null;
+  if (!isRecord(payload)) return null;
+  return {
+    topic,
+    event,
+    payload,
+    ref: typeof ref === "string" ? ref : null,
+    joinRef: typeof joinRef === "string" ? joinRef : null
+  };
+}
+function frameLimitOf(reason) {
+  if (typeof reason !== "string") return null;
+  const match = /^is larger than (\d+) bytes$/.exec(reason);
+  return match === null ? null : Number(match[1]);
+}
+function utf8Length(text) {
+  let bytes = 0;
+  for (let index = 0; index < text.length; index++) {
+    const unit = text.charCodeAt(index);
+    if (unit < 128) bytes += 1;
+    else if (unit < 2048) bytes += 2;
+    else if (unit >= 55296 && unit <= 56319 && index + 1 < text.length) {
+      const next = text.charCodeAt(index + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        index++;
+      } else bytes += 3;
+    } else bytes += 3;
+  }
+  return bytes;
+}
+function clientFrame(topic, event, payload, ref, joinRef) {
+  return JSON.stringify(
+    joinRef === void 0 ? { topic, event, payload, ref } : { topic, event, payload, ref, join_ref: joinRef }
+  );
+}
+function atMostCodePoints(text, max) {
+  if (text.length <= max) return true;
+  return text.length <= max * 2 && [...text].length <= max;
+}
+function hasControlCharacter(text) {
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code <= 31 || code >= 127 && code <= 159) return true;
+  }
+  return false;
+}
+function hasBidiControl(text) {
+  for (let i = 0; i < text.length; i += 1) {
+    const code = text.charCodeAt(i);
+    if (code === 1564 || code === 8206 || code === 8207 || code >= 8234 && code <= 8238 || code >= 8294 && code <= 8297)
+      return true;
+  }
+  return false;
+}
+function channelNameProblem(name) {
+  if (name === "") return "is empty";
+  if (!atMostCodePoints(name, MAX_CHANNEL_NAME_LENGTH))
+    return `is longer than ${String(MAX_CHANNEL_NAME_LENGTH)} characters`;
+  if (hasControlCharacter(name)) return "has a control character";
+  if (hasBidiControl(name)) return "has a bidirectional control character";
+  return void 0;
+}
+function socketUrl(baseUrl, apiKey) {
+  const url = new URL("/_naro/v1/realtime/websocket", baseUrl);
+  url.protocol = url.protocol === "http:" ? "ws:" : "wss:";
+  return `${url.href}?apikey=${encodeURIComponent(apiKey)}&vsn=${REALTIME_PROTOCOL_VERSION}`;
+}
+
+// src/realtime/socket.ts
+var HEARTBEAT_MS = 25e3;
+var TIMEOUT_MS = 1e4;
+var PACED_BURST = CONNECTION_FRAME_BURST - 20;
+var SDK_WARNING_ROOM = 6;
+var ignore = () => void 0;
+function now() {
+  return typeof performance === "undefined" ? Date.now() : performance.now();
+}
+function detach(ws) {
+  ws.onopen = null;
+  ws.onmessage = null;
+  ws.onclose = null;
+  ws.onerror = ignore;
+}
+function closeQuietly(ws, code) {
+  try {
+    ws.close(code);
+  } catch {
+  }
+}
+function safely(callback) {
+  try {
+    callback();
+  } catch (error) {
+    queueMicrotask(() => {
+      throw error;
+    });
+  }
+}
+function replyOf(payload) {
+  if (payload.status === "ok") {
+    const { response } = payload;
+    return {
+      ok: true,
+      response: typeof response === "object" && response !== null && !Array.isArray(response) ? response : {}
+    };
+  }
+  return {
+    ok: false,
+    error: asError(payload.response) ?? invalidResponse(101),
+    lost: false
+  };
+}
+var RealtimeSocket = class {
+  #config;
+  #heartbeatMs;
+  #timeoutMs;
+  #ws = null;
+  #state = "idle";
+  #generation = 0;
+  /** Drops since the hub last answered: the next wait's step (결정 7). */
+  #attempt = 0;
+  /** Tries in a row that never opened (결정 9). */
+  #unopened = 0;
+  /** When the wait the last close or stop set ends: no connect() opens before it. */
+  #resumeAt = 0;
+  /**
+   * The last close was 4008 (CLIENT_FLOODING), and no heartbeat was
+   * answered since: a channel's word that the hub answered does not start
+   * the backoff over — a connection that floods again must not come back
+   * every second (PR #328 review).
+   */
+  #flooded = false;
+  /**
+   * The frames waiting their turn on this connection, in the order they
+   * go: the first `#ahead` before the app's (`#enqueue`).
+   */
+  #queue = [];
+  /** How many at the front of `#queue` go before the app's frames: the SDK's own and the identity's, and the app's an identity frame must not pass. */
+  #ahead = 0;
+  /** The app's frames in `#queue`: not in flight yet, so no room is kept for them (`#hasRoom`). */
+  #appQueued = 0;
+  /** The budget this connection has left (`PACED_BURST` at the open), as of `#tokensAt`. */
+  #tokens = 0;
+  #tokensAt = 0;
+  #paceTimer;
+  /** When the hub refused a frame on this connection with a warning (`WARNED_CODES`), oldest first. */
+  #warnings = [];
+  /** The SDK's own frames waiting for room, by who sends them, in the order they asked (`whenRoom()`). */
+  #roomWaiters = /* @__PURE__ */ new Map();
+  /** Due when the oldest warning leaves the window, while a frame waits for room. */
+  #roomTimer;
+  #draining = false;
+  #ref = 0;
+  #retryTimer;
+  #openTimer;
+  #heartbeat;
+  #heartbeatPending = false;
+  /** The connection-level `system` frame since the open: why it is about to close. */
+  #said = null;
+  /**
+   * The size limit the hub named when it refused a frame on this
+   * connection (`#refusedOverLimit`): a frame over it is answered so without
+   * being sent. Forgotten with the connection — the next hub's plan may
+   * differ.
+   */
+  #frameLimit = null;
+  #replies = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.#config = config;
+    this.#heartbeatMs = config.options.heartbeatIntervalMs ?? HEARTBEAT_MS;
+    this.#timeoutMs = config.options.timeoutMs ?? TIMEOUT_MS;
+  }
+  get generation() {
+    return this.#generation;
+  }
+  get timeoutMs() {
+    return this.#timeoutMs;
+  }
+  isOpen() {
+    return this.#state === "open";
+  }
+  nextRef() {
+    this.#ref += 1;
+    return String(this.#ref);
+  }
+  /**
+   * Opens unless a connection is open, opening or due — once the wait the
+   * last close or stop set is over. After the app's own close the counts
+   * start over; after a stop they go on, as after a drop.
+   */
+  connect() {
+    if (this.#state !== "idle" && this.#state !== "stopped") return;
+    if (this.#state === "idle") {
+      this.#attempt = 0;
+      this.#unopened = 0;
+    }
+    const wait = this.#resumeAt - now();
+    if (wait <= 0) return this.#open();
+    this.#state = "waiting";
+    this.#retryTimer = setTimeout(() => {
+      this.#retryTimer = void 0;
+      if (this.#state === "waiting") this.#open();
+    }, wait);
+  }
+  /** The last channel went: close for good, with no event. */
+  disconnect() {
+    const ws = this.#ws;
+    this.#ws = null;
+    this.#clearTimers();
+    this.#state = "idle";
+    this.#said = null;
+    this.#failReplies(realtimeDisconnected());
+    if (ws !== null) {
+      detach(ws);
+      closeQuietly(ws, 1e3);
+    }
+  }
+  /**
+   * Lets go of the open connection and comes back as after a drop (1006),
+   * the channels told: for a connection that holds an identity the app no
+   * longer means and cannot change (identity.ts). Nothing unless open.
+   */
+  reconnect() {
+    const ws = this.#ws;
+    if (ws === null || this.#state !== "open") return;
+    detach(ws);
+    closeQuietly(ws, 1e3);
+    this.#closed(ws, 1006, "", null);
+  }
+  /**
+   * The hub answered this connection: the next drop waits from the first
+   * step — unless the last close was 4008 and no heartbeat was answered
+   * since (`#flooded`).
+   */
+  served() {
+    if (!this.#flooded) this.#attempt = 0;
+  }
+  /**
+   * A frame, in its `turn` (the app's unless said), and the `phx_reply`
+   * with its `ref` within `timeoutMs` of when it went — or, for one over the
+   * size limit the hub named on this connection, that refusal at once and
+   * nothing sent; for an app's frame but a leave that would not go within
+   * `timeoutMs`, CLIENT_FLOODING at once and nothing sent.
+   */
+  request(topic, event, payload, options = {}) {
+    const ref = options.ref ?? this.nextRef();
+    const turn = options.turn ?? "app";
+    return new Promise((resolve) => {
+      const lost = {
+        ok: false,
+        error: realtimeClosed(1006),
+        lost: true
+      };
+      if (!this.isOpen()) return resolve(lost);
+      let text;
+      try {
+        text = clientFrame(topic, event, payload, ref, options.joinRef);
+      } catch {
+        return resolve(lost);
+      }
+      const bytes = utf8Length(text);
+      const limit = this.#frameLimit;
+      if (limit !== null && bytes > limit)
+        return resolve({ ok: false, error: frameTooLarge(limit), lost: false });
+      if (turn === "app" && event !== "phx_leave" && !this.#goesInTime())
+        return resolve({
+          ok: false,
+          error: clientFlooding(CONNECTION_FRAMES_PER_SECOND),
+          lost: false
+        });
+      this.#replies.set(ref, { resolve, timer: void 0, bytes, turn });
+      this.#enqueue({ text, bytes, ref, turn, presence: event === "presence" });
+    });
+  }
+  /**
+   * Whether an app's frame behind every frame waiting would go within
+   * `timeoutMs`: past the budget left, the hub takes
+   * `CONNECTION_FRAMES_PER_SECOND` a second. The SDK's own frames that come
+   * later go before it, a few at most (`whenRoom()`).
+   */
+  #goesInTime() {
+    this.#refill();
+    const over = this.#queue.length + 1 - this.#tokens;
+    return over <= CONNECTION_FRAMES_PER_SECOND * this.#timeoutMs / 1e3;
+  }
+  /**
+   * Runs `go` once a frame the SDK sends of its own accord may go: at once
+   * when nothing waits before it and there is room — the warnings of the
+   * last minute and the requests in flight fewer than `SDK_WARNING_ROOM`
+   * (the app's frames still waiting their turn are not in flight yet, and
+   * go after the SDK's), or the warnings fewer and none of the SDK's own
+   * unanswered — or else when there is, in the order asked. The
+   * frame itself is sent with `turn: "sdk"`. `key` names the sender:
+   * asked again before it ran, it keeps its place and runs the newer `go`,
+   * which reads its own state again then. Nothing while the connection is
+   * not open, and forgotten with it: the sender tries again when it is live.
+   */
+  whenRoom(key, go) {
+    if (this.#state !== "open") return;
+    if (this.#roomWaiters.size === 0 && this.#hasRoom()) return go();
+    this.#roomWaiters.set(key, go);
+    this.#armRoom();
+  }
+  /**
+   * Room for one more frame of the SDK's own (`whenRoom()`): the requests
+   * that count are those sent and not answered, and the SDK's own still to
+   * go — not the app's waiting their turn, which the SDK's go before (PR
+   * #328 re-review). And while none of the SDK's own is unanswered, one
+   * goes whatever the app has in flight, if the warnings leave room (PR #328
+   * re-review 2): an app sending 10 a second over a link of 0.7 s or more
+   * always has six in flight, and a second channel's join would wait,
+   * untold, for as long as it sends. A refusal of the app's is a warning
+   * when it comes, so the SDK adds one at most.
+   */
+  #hasRoom() {
+    if (this.#state !== "open") return false;
+    const since = now() - FLOOD_WINDOW_MS;
+    this.#warnings = this.#warnings.filter((at) => at > since);
+    const warnings = this.#warnings.length;
+    if (warnings >= SDK_WARNING_ROOM) return false;
+    const inFlight2 = this.#replies.size - this.#appQueued;
+    return warnings + inFlight2 < SDK_WARNING_ROOM || !this.#sdkUnanswered();
+  }
+  /** Whether a request of the SDK's own or the identity's waits for its answer, sent or still to go. */
+  #sdkUnanswered() {
+    for (const waiter of this.#replies.values())
+      if (waiter.turn !== "app") return true;
+    return false;
+  }
+  /** The frames waiting for room go while there is: after an answer, a time-out, and when a warning leaves the window. */
+  #drainRoom() {
+    if (this.#draining) return;
+    this.#draining = true;
+    try {
+      for (const [key, go] of this.#roomWaiters) {
+        if (!this.#hasRoom()) break;
+        this.#roomWaiters.delete(key);
+        safely(go);
+      }
+    } finally {
+      this.#draining = false;
+    }
+    this.#armRoom();
+  }
+  /** While a frame waits for room the warnings hold, look again when the oldest leaves the window. */
+  #armRoom() {
+    clearTimeout(this.#roomTimer);
+    this.#roomTimer = void 0;
+    const oldest = this.#warnings[0];
+    if (this.#roomWaiters.size === 0 || oldest === void 0) return;
+    this.#roomTimer = setTimeout(
+      () => {
+        this.#roomTimer = void 0;
+        this.#drainRoom();
+      },
+      Math.max(1, oldest + FLOOD_WINDOW_MS - now() + 1)
+    );
+  }
+  /**
+   * Puts `frame` in its turn and sends what may go. The app's go last; the
+   * SDK's own and the identity's after the others before the app's. An
+   * identity frame goes after the app's presence frames still to go, with
+   * whatever waits before them: the hub reads a presence as the user it
+   * holds when the frame comes, and would hold the last user's state for the
+   * new one.
+   */
+  #enqueue(frame) {
+    if (frame.turn === "app") {
+      this.#queue.push(frame);
+      this.#appQueued += 1;
+    } else {
+      if (frame.turn === "identity") this.#ahead = this.#pastPresence();
+      this.#queue.splice(this.#ahead, 0, frame);
+      this.#ahead += 1;
+    }
+    this.#flush();
+  }
+  /** Just past the app's last presence frame still to go — `#ahead` when none is. */
+  #pastPresence() {
+    for (let index = this.#queue.length - 1; index >= this.#ahead; index -= 1)
+      if (this.#queue[index]?.presence === true) return index + 1;
+    return this.#ahead;
+  }
+  /** The next frame to go, out of `#queue`. */
+  #next() {
+    const frame = this.#queue.shift();
+    if (frame === void 0) return void 0;
+    if (this.#ahead > 0) this.#ahead -= 1;
+    if (frame.turn === "app") this.#appQueued -= 1;
+    return frame;
+  }
+  /** `ref`'s frame out of `#queue`, if it is still there: answered before it went. */
+  #unqueue(ref) {
+    const index = this.#queue.findIndex((frame2) => frame2.ref === ref);
+    if (index === -1) return;
+    const [frame] = this.#queue.splice(index, 1);
+    if (index < this.#ahead) this.#ahead -= 1;
+    if (frame?.turn === "app") this.#appQueued -= 1;
+  }
+  /**
+   * Sends the frames waiting their turn while the budget has room, in their
+   * turn, and comes back when the next one is due. One whose frame the
+   * socket cannot send is lost now — its close event follows.
+   */
+  #flush() {
+    const ws = this.#ws;
+    if (ws === null || this.#state !== "open") return;
+    this.#refill();
+    while (this.#queue.length > 0 && this.#tokens >= 1) {
+      const frame = this.#next();
+      const waiter = this.#replies.get(frame.ref);
+      if (waiter === void 0) continue;
+      const limit = this.#frameLimit;
+      if (limit !== null && frame.bytes > limit) {
+        this.#answer(frame.ref, {
+          ok: false,
+          error: frameTooLarge(limit),
+          lost: false
+        });
+        continue;
+      }
+      try {
+        ws.send(frame.text);
+      } catch {
+        this.#answer(frame.ref, {
+          ok: false,
+          error: realtimeClosed(1006),
+          lost: true
+        });
+        continue;
+      }
+      this.#tokens -= 1;
+      waiter.timer = this.#timeOut(frame.ref, waiter);
+    }
+    if (this.#queue.length === 0 || this.#paceTimer !== void 0) return;
+    const due = Math.ceil(
+      (1 - this.#tokens) * 1e3 / CONNECTION_FRAMES_PER_SECOND
+    );
+    this.#paceTimer = setTimeout(
+      () => {
+        this.#paceTimer = void 0;
+        this.#flush();
+      },
+      Math.max(1, due)
+    );
+  }
+  /** The budget refilled for the time since it was last looked at, as the hub's bucket refills. */
+  #refill() {
+    const at = now();
+    if (at <= this.#tokensAt) return;
+    this.#tokens = Math.min(
+      PACED_BURST,
+      this.#tokens + (at - this.#tokensAt) / 1e3 * CONNECTION_FRAMES_PER_SECOND
+    );
+    this.#tokensAt = at;
+  }
+  /**
+   * `ref`'s request hears `reply`, now: one fewer in flight — or, answered
+   * before its frame went (over a size limit the hub named), one fewer to
+   * go, and nothing sent.
+   */
+  #answer(ref, reply) {
+    const waiter = this.#replies.get(ref);
+    if (waiter === void 0) return;
+    this.#replies.delete(ref);
+    clearTimeout(waiter.timer);
+    if (waiter.timer === void 0) this.#unqueue(ref);
+    waiter.resolve(reply);
+    this.#drainRoom();
+  }
+  /** TIMED_OUT for `ref`'s request `timeoutMs` after its frame went. */
+  #timeOut(ref, waiter) {
+    return setTimeout(() => {
+      if (this.#replies.get(ref) !== waiter) return;
+      this.#answer(ref, {
+        ok: false,
+        error: realtimeTimedOut(this.#timeoutMs),
+        lost: false
+      });
+    }, this.#timeoutMs);
+  }
+  #open() {
+    const Impl = this.#config.options.WebSocket ?? globalThis.WebSocket;
+    if (typeof Impl !== "function")
+      return this.#stop(websocketUnavailable(), true);
+    if (this.#config.service && !isKnownServer())
+      return this.#stop(serviceKeyOffServer(), true);
+    let ws;
+    try {
+      ws = new Impl(
+        socketUrl(this.#config.baseUrl, this.#config.apiKey)
+      );
+    } catch (error) {
+      return this.#stop(socketRefused(error), true);
+    }
+    this.#generation += 1;
+    this.#ws = ws;
+    this.#state = "connecting";
+    this.#said = null;
+    this.#frameLimit = null;
+    ws.onopen = () => this.#opened(ws);
+    ws.onmessage = (event) => this.#message(ws, event.data);
+    ws.onclose = (event) => this.#closed(ws, event.code, event.reason ?? "", null);
+    ws.onerror = ignore;
+    this.#openTimer = setTimeout(
+      () => this.#closed(ws, 1006, "", this.#timeoutMs),
+      this.#timeoutMs
+    );
+  }
+  #opened(ws) {
+    if (this.#ws !== ws || this.#state !== "connecting") return;
+    clearTimeout(this.#openTimer);
+    this.#openTimer = void 0;
+    this.#state = "open";
+    this.#unopened = 0;
+    this.#heartbeatPending = false;
+    this.#queue = [];
+    this.#ahead = 0;
+    this.#appQueued = 0;
+    this.#tokens = PACED_BURST;
+    this.#tokensAt = now();
+    this.#warnings = [];
+    this.#heartbeat = setInterval(() => this.#beat(ws), this.#heartbeatMs);
+    safely(() => this.#config.events.opened());
+  }
+  #beat(ws) {
+    if (this.#ws !== ws) return;
+    if (this.#heartbeatPending)
+      return this.#closed(ws, 1e3, "", this.#heartbeatMs);
+    this.#heartbeatPending = true;
+    try {
+      ws.send(HEARTBEAT_REQUEST);
+    } catch {
+    }
+  }
+  #message(ws, data) {
+    if (this.#ws !== ws) return;
+    const frame = readServerFrame(data);
+    if (frame === null) return;
+    if (frame.event === "phx_reply" && frame.ref !== null) {
+      if (frame.ref === HEARTBEAT_REF) {
+        this.#heartbeatPending = false;
+        this.#flooded = false;
+        this.#attempt = 0;
+        return;
+      }
+      const reply = replyOf(frame.payload);
+      if (!reply.ok && WARNED_CODES.has(reply.error.code))
+        this.#warnings.push(now());
+      if (this.#replies.has(frame.ref)) {
+        this.#answer(frame.ref, reply);
+        return;
+      }
+    }
+    if (frame.topic === PHOENIX_TOPIC) {
+      if (frame.event === "system") this.#said = asError(frame.payload);
+      else if (frame.event === "phx_reply" && frame.ref === null)
+        this.#refusedOverLimit(frame.payload);
+      return;
+    }
+    safely(() => this.#config.events.frame(frame));
+  }
+  /**
+   * The hub refused a frame over its size limit before reading it (final
+   * review A M3, plan 정정 (m)): it names no `ref`, so no request waits for
+   * it by name — it waited `timeoutMs` and answered TIMED_OUT. But the hub
+   * refuses every frame over the limit, and only those, before anything
+   * else: each request waiting whose frame is over it is one refused so, and
+   * hears it now. The limit stays for the connection.
+   */
+  #refusedOverLimit(payload) {
+    if (payload.status !== "error") return;
+    const error = asError(payload.response);
+    if (error?.code !== "INVALID_MESSAGE" || !isRecord(error.details)) return;
+    const limit = frameLimitOf(error.details.reason);
+    if (limit === null) return;
+    this.#frameLimit = limit;
+    for (const [ref, waiter] of this.#replies)
+      if (waiter.bytes > limit)
+        this.#answer(ref, {
+          ok: false,
+          error: frameTooLarge(limit),
+          lost: false
+        });
+  }
+  /**
+   * `ws` ended: its close event (`waitedMs` null), or a heartbeat or an open
+   * that had no answer in `waitedMs` — then it is let go at once, its
+   * handlers first, since a dead TCP connection can take minutes to report
+   * its close (결정 11).
+   */
+  #closed(ws, code, reason, waitedMs) {
+    if (this.#ws !== ws) return;
+    const wasOpen = this.#state === "open";
+    const timedOut = waitedMs !== null;
+    detach(ws);
+    this.#ws = null;
+    this.#clearTimers();
+    if (timedOut) closeQuietly(ws, 1e3);
+    if (!wasOpen) this.#unopened += 1;
+    const said = this.#said;
+    this.#said = null;
+    if (!timedOut && code === 4008) this.#flooded = true;
+    const action = timedOut ? { kind: "retry", minMs: 0 } : closeAction(code, said?.code ?? reason);
+    if (action.kind === "stop")
+      return this.#stop(said ?? realtimeStopped(code, reason));
+    const error = timedOut ? realtimeTimedOut(waitedMs) : said ?? realtimeClosed(code);
+    this.#failReplies(error);
+    this.#state = "waiting";
+    const delay = delayAfter(
+      action,
+      { attempt: this.#attempt, unopened: this.#unopened },
+      Math.random
+    );
+    if (action.kind !== "restart" && action.kind !== "wait") this.#attempt += 1;
+    this.#wait(action.kind === "session", delay);
+    safely(
+      () => this.#config.events.dropped(
+        error,
+        timedOut ? "TIMED_OUT" : "CHANNEL_ERROR"
+      )
+    );
+  }
+  /**
+   * The next try, `delay` from now — after a 4401, from when its
+   * conditional delete is done, or from `timeoutMs` on if it is not: an
+   * app's `auth.storage` that never answers must not keep the connection
+   * away for good.
+   */
+  #wait(session, delay) {
+    const generation = this.#generation;
+    this.#resumeAt = now() + delay;
+    let due = false;
+    const schedule = () => {
+      if (due || this.#state !== "waiting" || this.#generation !== generation)
+        return;
+      due = true;
+      this.#resumeAt = now() + delay;
+      clearTimeout(this.#retryTimer);
+      this.#retryTimer = setTimeout(() => {
+        this.#retryTimer = void 0;
+        if (this.#state === "waiting") this.#open();
+      }, delay);
+    };
+    if (!session) return schedule();
+    this.#retryTimer = setTimeout(schedule, this.#timeoutMs);
+    safely(() => {
+      void this.#config.events.sessionRefused().then(schedule, schedule);
+    });
+  }
+  /**
+   * Stopped until a connect(), which waits as after a drop: the stop counts
+   * as one (`unopened` when no socket was made — the runtime cannot open).
+   */
+  #stop(error, unopened = false) {
+    this.#clearTimers();
+    this.#state = "stopped";
+    this.#failReplies(error);
+    if (unopened) this.#unopened += 1;
+    this.#resumeAt = now() + delayAfter(
+      { kind: "retry", minMs: 0 },
+      { attempt: this.#attempt, unopened: this.#unopened },
+      Math.random
+    );
+    this.#attempt += 1;
+    safely(() => this.#config.events.stopped(error));
+  }
+  /** Every request still waiting hears `error`, as lost with the connection. */
+  #failReplies(error) {
+    const waiting = [...this.#replies.values()];
+    this.#replies.clear();
+    for (const waiter of waiting) {
+      clearTimeout(waiter.timer);
+      waiter.resolve({ ok: false, error, lost: true });
+    }
+  }
+  /** Every timer of the connection, and the frames still to go with it. */
+  #clearTimers() {
+    clearTimeout(this.#retryTimer);
+    clearTimeout(this.#openTimer);
+    clearInterval(this.#heartbeat);
+    clearTimeout(this.#paceTimer);
+    clearTimeout(this.#roomTimer);
+    this.#retryTimer = void 0;
+    this.#openTimer = void 0;
+    this.#heartbeat = void 0;
+    this.#paceTimer = void 0;
+    this.#roomTimer = void 0;
+    this.#queue = [];
+    this.#ahead = 0;
+    this.#appQueued = 0;
+    this.#roomWaiters.clear();
+  }
+};
+
+// src/realtime/channel.ts
+function sent(reply) {
+  return reply.ok ? { data: null, error: null, lost: false } : { data: null, error: reply.error, lost: reply.lost };
+}
+function unsent(error) {
+  return { data: null, error, lost: false };
+}
+function jsonObject(value) {
+  try {
+    const copy = JSON.parse(JSON.stringify(value));
+    return isRecord(copy) ? copy : null;
+  } catch {
+    return null;
+  }
+}
+function presenceReadDenied(response) {
+  const { access } = response;
+  return isRecord(access) && isRecord(access.presence) && access.presence.read === false;
+}
+function tablesOf(changes) {
+  return changes.map((binding) => binding.filter.table ?? "*");
+}
+var JOIN_RETRY_CODES = /* @__PURE__ */ new Set([
+  "TOO_MANY_JOINS",
+  "INTERNAL_ERROR",
+  "TIMED_OUT"
+]);
+var RETRACK_RETRY_CODES = /* @__PURE__ */ new Set([
+  "TOO_MANY_PRESENCE_MESSAGES",
+  "TOO_MANY_MESSAGES",
+  "TOO_MANY_JOINS",
+  "INTERNAL_ERROR",
+  "TIMED_OUT"
+]);
+var RETRACK_WARNED_RESENDS = 3;
+var LATE_LISTENER = "naro-js: postgres_changes and presence listeners added after subscribe() count from the channel's next join; call unsubscribe() and subscribe() again to add them now.";
+function isDevelopment() {
+  const env = globalThis.process?.env;
+  return env?.NODE_ENV !== "production";
+}
+function warnInDevelopment(message) {
+  if (isDevelopment()) console.warn(message);
+}
+function isJson(value) {
+  try {
+    JSON.stringify(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function changeSpec(filter) {
+  const {
+    event,
+    schema,
+    table,
+    filter: text,
+    ...rest
+  } = filter;
+  return {
+    ...rest,
+    event,
+    ...schema === void 0 ? {} : { schema },
+    ...table === void 0 ? {} : { table },
+    ...text === void 0 || text === "" ? {} : { filter: text }
+  };
+}
+function changePayload(data) {
+  return {
+    schema: "public",
+    table: typeof data.table === "string" ? data.table : "",
+    commit_timestamp: typeof data.commit_timestamp === "string" ? data.commit_timestamp : "",
+    eventType: data.type,
+    new: isRecord(data.record) ? data.record : {},
+    old: isRecord(data.old_record) ? data.old_record : {},
+    errors: Array.isArray(data.errors) ? data.errors.filter((item) => typeof item === "string") : null
+  };
+}
+function systemMessage(payload) {
+  const { extension, code, message, channel } = payload;
+  return {
+    status: payload.status === "ok" ? "ok" : "error",
+    extension: typeof extension === "string" ? extension : "system",
+    code: typeof code === "string" ? code : "",
+    message: typeof message === "string" ? message : "",
+    channel: typeof channel === "string" ? channel : null
+  };
+}
+var RealtimeChannel = class {
+  name;
+  topic;
+  isPrivate;
+  options;
+  #context;
+  #bindings = [];
+  #presence = new Presence();
+  #state = "closed";
+  /** subscribe() was called and unsubscribe() was not: join it on every connection. */
+  #wanted = false;
+  /** The join sent and not left or replaced since — set when it is sent, before its answer. */
+  #joinRef = null;
+  /** The tables that join's row subscriptions are on (`*` for every table): its leave holds them. */
+  #joinTables = [];
+  /**
+   * The join was refused a cap a leave owed on the connection still holds
+   * a place under (`ChannelContext.owesLeaveOn`): it waits for that leave
+   * rather than knock again (PR #328 review). Null otherwise.
+   */
+  #capWait = null;
+  #onStatus = null;
+  /** The app already heard of this trouble; reset at SUBSCRIBED. */
+  #told = false;
+  #attempt = 0;
+  #retry;
+  /** The `system` error sent before a `phx_close` (protocol.ts `closeChannel`). */
+  #closeError = null;
+  /** The last state tracked, and the token the hub had then (결정 17). */
+  #tracked = null;
+  /** Bumped when what is tracked is let go of: a track answered after that does not bring it back. */
+  #letGo = 0;
+  /** Bumped by the app's track() and untrack(): one in the SUBSCRIBED callback says what the join holds. */
+  #presenceCalls = 0;
+  /** A track sent again and refused for now goes again when this is due (`#retrack`). */
+  #retrackTimer;
+  /**
+   * The app's presence calls and broadcasts waiting for the connection to
+   * be live, in the order it made them (`#inTurn`): each sends, or answers
+   * that its join went, when called.
+   */
+  #waiting = [];
+  /** Inside subscribe(): a stop is told a microtask later (`#toldStop`). */
+  #subscribing = false;
+  /** Who waits for room on the connection (`whenRoom()`): this channel's join, and its track sent again. */
+  #joinTurn = {};
+  #retrackTurn = {};
+  /**
+   * Frames of the join in flight that came before its answer was handled
+   * (final review A M1, plan 정정 (m)): Node's `ws` and undici hand over
+   * the frames of one read in one callback, while the answer's handler runs
+   * a microtask later — a change right behind the `ok` had no subscription
+   * id yet. They are heard once the `ok` is (after SUBSCRIBED, as in a
+   * browser, which runs a task per message), and dropped with a refusal.
+   */
+  #early = [];
+  /** @internal `naro.channel()` makes channels. */
+  constructor(name, options, context) {
+    this.name = name;
+    this.topic = `${REALTIME_TOPIC_PREFIX}${name}`;
+    this.isPrivate = options.config?.private === true;
+    this.options = options;
+    this.#context = context;
+  }
+  get state() {
+    return this.#state;
+  }
+  /** @internal The join sent and not left or replaced since (client.ts routes by it). */
+  get joinRef() {
+    return this.#joinRef;
+  }
+  on(type, filter, callback) {
+    const listener = callback;
+    const spec = isRecord(filter) ? filter : {};
+    if ((type === "postgres_changes" || type === "presence") && this.#wanted)
+      warnInDevelopment(LATE_LISTENER);
+    if (type === "postgres_changes")
+      this.#bindings.push({
+        type,
+        filter: spec,
+        callback: listener,
+        id: null
+      });
+    else if (type === "broadcast" || type === "presence")
+      this.#bindings.push({
+        type,
+        event: String(spec.event),
+        callback: listener
+      });
+    else if (type === "system")
+      this.#bindings.push({ type, callback: listener });
+    return this;
+  }
+  subscribe(callback) {
+    if (callback !== void 0) this.#onStatus = callback;
+    if (this.#wanted) return this;
+    const problem = this.#nameError();
+    if (problem !== null) {
+      this.#state = "errored";
+      queueMicrotask(() => this.#status("CHANNEL_ERROR", problem));
+      return this;
+    }
+    this.#wanted = true;
+    this.#state = "joining";
+    this.#attempt = 0;
+    this.#told = false;
+    this.#capWait = null;
+    this.#clearRetry();
+    this.#subscribing = true;
+    try {
+      this.#context.connect();
+      this.#joinIfDue();
+    } finally {
+      this.#subscribing = false;
+    }
+    return this;
+  }
+  async unsubscribe() {
+    const ref = this.#joinRef;
+    const held = this.#state === "joined" || this.#state === "joining";
+    this.#wanted = false;
+    this.#clearRetry();
+    this.#letGoOfTrack();
+    this.#joinRef = null;
+    this.#state = "leaving";
+    this.#releaseWaiting();
+    let error = null;
+    if (held && ref !== null) {
+      const reply = await this.#context.leave(this, ref, this.#joinTables);
+      if (!reply.ok && !reply.lost && reply.error.code !== "NOT_JOINED")
+        error = reply.error;
+    }
+    if (this.#state === "leaving") {
+      this.#state = "closed";
+      this.#presence.clear();
+      this.#status("CLOSED");
+    }
+    return { data: null, error };
+  }
+  /**
+   * Broadcasts `message` on the join, or over HTTP before it: the server's
+   * answer, `lost` when the connection went before it (RealtimeSendResult).
+   */
+  async send(message) {
+    if (!isRecord(message) || message.type !== "broadcast")
+      return unsent(invalidBroadcast());
+    const problem = this.#nameError();
+    if (problem !== null) return unsent(problem);
+    const { event, payload } = message;
+    if (!isJson({ event, payload }))
+      return unsent(invalidQuery("", "is not JSON"));
+    const joinRef = this.#joinRef;
+    if (this.#state === "joined" && joinRef !== null) {
+      const reply = await this.#inTurn(
+        joinRef,
+        !this.#context.live(),
+        () => this.#context.socket.request(
+          this.topic,
+          "broadcast",
+          { type: "broadcast", event, payload },
+          { joinRef }
+        )
+      );
+      if (reply !== null) return sent(reply);
+    }
+    await this.#context.auth.ready();
+    const result = await call(this.#context.http, {
+      method: "POST",
+      path: "/realtime/broadcast",
+      body: {
+        messages: [
+          { topic: this.topic, event, payload, private: this.isPrivate }
+        ]
+      },
+      withToken: true
+    });
+    return unsent(result.error);
+  }
+  /**
+   * Tracks `state` as this connection's presence here (original spec
+   * §11.1): the hub's answer. Only on a join — before it, NOT_JOINED, and
+   * nothing is kept for later (결정 18). It goes as its JSON reads back, and
+   * that copy, not the app's object, is what a later join sends again.
+   * While who the connection is is not settled (a new token in flight, a
+   * retry), it waits until it is (정정 (k)): the hub may yet refuse the new
+   * token for now and keep the last user, whose presence it would be.
+   */
+  async track(state) {
+    const problem = this.#nameError();
+    if (problem !== null) return unsent(problem);
+    const joinRef = this.#joinRef;
+    if (this.#state !== "joined" || joinRef === null)
+      return unsent(notJoined(this.name));
+    const payload = jsonObject(state);
+    if (payload === null) return unsent(invalidPresence());
+    this.#presenceCalls += 1;
+    this.#clearRetrack();
+    const letGo = this.#letGo;
+    const reply = await this.#inTurn(
+      joinRef,
+      !this.#context.live(),
+      () => this.#sendTrack(payload, joinRef, letGo, true)
+    );
+    if (reply === null) {
+      if (letGo === this.#letGo) this.#letGoOfTrack();
+      return unsent(notJoined(this.name));
+    }
+    return sent(reply);
+  }
+  /**
+   * Takes this connection's presence off the channel: the hub's answer, or
+   * none when not joined. After the app's tracks that wait, if any.
+   */
+  async untrack() {
+    this.#presenceCalls += 1;
+    this.#letGoOfTrack();
+    const joinRef = this.#joinRef;
+    if (this.#state !== "joined" || joinRef === null) return unsent(null);
+    const reply = await this.#inTurn(
+      joinRef,
+      false,
+      () => this.#context.socket.request(
+        this.topic,
+        "presence",
+        { type: "presence", event: "untrack" },
+        { joinRef }
+      )
+    );
+    return reply === null ? unsent(null) : sent(reply);
+  }
+  /** The presences of the channel, by key (결정 16): a copy. */
+  presenceState() {
+    return this.#presence.state();
+  }
+  /**
+   * @internal
+   * The connection is live, or a leave owed is done (client.ts): join if
+   * the app wants it and the channel holds no join and waits for no retry.
+   * Called whenever either happens, for every channel, so a channel joined
+   * or joining stays as it is.
+   */
+  rejoin() {
+    if (this.#context.live()) this.#releaseWaiting();
+    this.#joinIfDue();
+  }
+  /**
+   * @internal
+   * A leave of this name and privacy owed on the connection was refused, or
+   * not answered in time, and goes again (client.ts): a join waiting on it
+   * tells the app once a wait, as a refused join tried again does (결정 14,
+   * 정정 (j)), and waits on.
+   */
+  leaveRefused(error) {
+    if (this.#wanted && this.#joinRef === null)
+      this.#tell(
+        error.code === "TIMED_OUT" ? "TIMED_OUT" : "CHANNEL_ERROR",
+        error
+      );
+  }
+  /** @internal The connection dropped and comes back: tell the app once, rejoin when live. */
+  dropped(error, status) {
+    if (!this.#wanted) return;
+    this.#clearRetry();
+    this.#capWait = null;
+    this.#joinRef = null;
+    this.#state = "joining";
+    this.#releaseWaiting();
+    this.#presence.unsync();
+    this.#tell(status, error);
+  }
+  /** @internal The connection stopped for good: the app must subscribe() again. */
+  stopped(error) {
+    if (this.#wanted) this.#stop(error);
+  }
+  /** @internal A frame of this channel's join (client.ts routes by join_ref). */
+  receive(frame) {
+    if (this.#state === "joining") {
+      this.#early.push(frame);
+      return;
+    }
+    switch (frame.event) {
+      case "postgres_changes":
+        return this.#change(frame.payload);
+      case "broadcast":
+        return this.#broadcast(frame.payload);
+      case "presence_state":
+        return this.#presence.applyState(frame.payload, this.#presenceEmit);
+      case "presence_diff":
+        return this.#presence.applyDiff(frame.payload, this.#presenceEmit);
+      case "system":
+        return this.#system(frame.payload);
+      case "phx_close":
+        return this.#serverClosed();
+      default:
+        return;
+    }
+  }
+  /**
+   * INVALID_CHANNEL for a name the hub would refuse, before anything is
+   * sent — and before any error of ours quotes the name.
+   */
+  #nameError() {
+    const problem = channelNameProblem(this.name);
+    return problem === void 0 ? null : invalidChannel(problem);
+  }
+  #config(changes) {
+    const config = this.options.config ?? {};
+    const presence = config.presence ?? {};
+    const key = presence.key ?? "";
+    const listens = this.#bindings.some(
+      (binding) => binding.type === "presence"
+    );
+    return {
+      ...config,
+      // ack is always on the wire, so send() always ends in the hub's answer (결정 6).
+      broadcast: {
+        ...config.broadcast,
+        self: config.broadcast?.self ?? false,
+        ack: true
+      },
+      presence: {
+        ...presence,
+        key,
+        enabled: listens || presence.enabled === true || key !== ""
+      },
+      postgres_changes: changes.map((binding) => changeSpec(binding.filter)),
+      private: this.isPrivate
+    };
+  }
+  /**
+   * Joins when due — once there is room on the connection for a frame the
+   * SDK sends of its own accord (`whenRoom()`, PR #328 review), and still
+   * due then.
+   */
+  #joinIfDue() {
+    if (!this.#dueToJoin()) return;
+    this.#context.socket.whenRoom(this.#joinTurn, () => {
+      if (this.#dueToJoin()) this.#join();
+    });
+  }
+  #dueToJoin() {
+    return this.#wanted && this.#joinRef === null && this.#retry === void 0 && this.#context.live() && !this.#context.owesLeave(this) && !this.#heldByCap();
+  }
+  /** A cap refused the last join, and a leave owed still holds the place it needs. */
+  #heldByCap() {
+    const wait = this.#capWait;
+    if (wait === null) return false;
+    if (this.#context.owesLeaveOn(wait.table)) return true;
+    this.#capWait = null;
+    return false;
+  }
+  /**
+   * The cap `error` names, when a leave owed on the connection holds a place
+   * under it (PR #328 review): the hub still counts that join — 100
+   * channels a connection (TOO_MANY_CHANNELS), or 4 on one table's changes
+   * (INVALID_CHANNEL_CONFIG with the hub's `changeChannels` reason at
+   * `config.postgres_changes[<i>].table`, the table of `changes[i]`) — and
+   * lets go of it once the leave goes through. Null for any other refusal.
+   */
+  #capHeld(error, changes) {
+    if (error.code === "TOO_MANY_CHANNELS")
+      return this.#context.owesLeaveOn(null) ? { table: null } : null;
+    if (error.code !== "INVALID_CHANNEL_CONFIG" || !isRecord(error.details))
+      return null;
+    const { path, reason } = error.details;
+    if (reason !== CHANGE_CHANNELS_REASON || typeof path !== "string")
+      return null;
+    const index = /^config\.postgres_changes\[(\d+)\]\.table$/.exec(path)?.[1];
+    const binding = index === void 0 ? void 0 : changes[Number(index)];
+    if (binding === void 0) return null;
+    const table = binding.filter.table ?? "*";
+    return this.#context.owesLeaveOn(table) ? { table } : null;
+  }
+  #join() {
+    const changes = this.#bindings.filter(
+      (b) => b.type === "postgres_changes"
+    );
+    const config = this.#config(changes);
+    if (!isJson(config))
+      return this.#stop(invalidChannelConfig("config", "is not JSON"));
+    const socket = this.#context.socket;
+    const ref = socket.nextRef();
+    this.#joinRef = ref;
+    this.#joinTables = tablesOf(changes);
+    this.#capWait = null;
+    this.#state = "joining";
+    this.#closeError = null;
+    this.#early = [];
+    this.#presence.unsync();
+    for (const binding of changes) binding.id = null;
+    void socket.request(
+      this.topic,
+      "phx_join",
+      { config },
+      { joinRef: ref, ref, turn: "sdk" }
+    ).then((reply) => this.#joined(ref, changes, reply));
+  }
+  #joined(ref, changes, reply) {
+    if (this.#joinRef !== ref) return;
+    const early = this.#early;
+    this.#early = [];
+    if (reply.ok) {
+      const ids = Array.isArray(reply.response.postgres_changes) ? reply.response.postgres_changes : [];
+      changes.forEach((binding, index) => {
+        const entry = ids[index];
+        binding.id = isRecord(entry) && typeof entry.id === "number" ? entry.id : null;
+      });
+      this.#state = "joined";
+      this.#attempt = 0;
+      this.#told = false;
+      this.#context.socket.served();
+      const calls = this.#presenceCalls;
+      this.#status("SUBSCRIBED");
+      if (this.#presenceCalls === calls) this.#retrack(ref);
+      if (this.#joinRef === ref && presenceReadDenied(reply.response))
+        this.#presence.leaveAll(this.#presenceEmit);
+      for (const frame of early) {
+        if (this.#joinRef !== ref || this.#state !== "joined") break;
+        this.receive(frame);
+      }
+      return;
+    }
+    if (reply.lost) {
+      this.#joinRef = null;
+      return;
+    }
+    const { error } = reply;
+    this.#joinRef = null;
+    const capHeld = this.#capHeld(error, changes);
+    if (capHeld !== null) {
+      this.#capWait = capHeld;
+      this.#state = "joining";
+      this.#tell("CHANNEL_ERROR", error);
+      return;
+    }
+    const meetsOld = error.code === "ALREADY_JOINED" && this.#context.owesLeave(this);
+    if (!JOIN_RETRY_CODES.has(error.code) && !meetsOld) {
+      this.#wanted = false;
+      this.#state = "errored";
+      this.#presence.leaveAll(this.#presenceEmit);
+      this.#status("CHANNEL_ERROR", error);
+      return;
+    }
+    if (error.code === "TIMED_OUT")
+      void this.#context.leave(this, ref, tablesOf(changes));
+    this.#tell(
+      error.code === "TIMED_OUT" ? "TIMED_OUT" : "CHANNEL_ERROR",
+      error
+    );
+    this.#state = "joining";
+    const delay = backoffMs(this.#attempt, Math.random);
+    this.#attempt += 1;
+    this.#retry = setTimeout(() => {
+      this.#retry = void 0;
+      this.#joinIfDue();
+    }, delay);
+  }
+  #change(payload) {
+    const ids = Array.isArray(payload.ids) ? payload.ids : [];
+    if (!isRecord(payload.data)) return;
+    const change = changePayload(payload.data);
+    for (const binding of this.#bindings)
+      if (binding.type === "postgres_changes" && binding.id !== null && ids.includes(binding.id))
+        safely(() => binding.callback(change));
+  }
+  #broadcast(payload) {
+    const { event } = payload;
+    if (typeof event !== "string") return;
+    const message = {
+      type: "broadcast",
+      event,
+      payload: isRecord(payload.payload) ? payload.payload : {}
+    };
+    for (const binding of this.#bindings)
+      if (binding.type === "broadcast" && binding.event === event)
+        safely(() => binding.callback(message));
+  }
+  #system(payload) {
+    const message = systemMessage(payload);
+    if (message.status === "error" && message.extension === "system")
+      this.#closeError = asError(payload);
+    for (const binding of this.#bindings)
+      if (binding.type === "system") safely(() => binding.callback(message));
+  }
+  /** The hub closed this join (lost access, its state full): stop until subscribe(). */
+  #serverClosed() {
+    this.#clearRetry();
+    this.#joinRef = null;
+    this.#wanted = false;
+    this.#state = "errored";
+    this.#letGoOfTrack();
+    this.#releaseWaiting();
+    this.#presence.leaveAll(this.#presenceEmit);
+    this.#status("CHANNEL_ERROR", this.#closeError ?? channelClosed());
+  }
+  /** The listeners' payloads, as supabase-js's: each says which event it is (정정 (k)). */
+  #presenceEmit = {
+    join: (key, newPresences, currentPresences) => {
+      const payload = {
+        event: "join",
+        key,
+        newPresences,
+        currentPresences
+      };
+      this.#presenceCall("join", payload);
+    },
+    leave: (key, leftPresences, currentPresences) => {
+      const payload = {
+        event: "leave",
+        key,
+        leftPresences,
+        currentPresences
+      };
+      this.#presenceCall("leave", payload);
+    },
+    sync: () => this.#presenceCall("sync", void 0)
+  };
+  #presenceCall(event, value) {
+    for (const binding of this.#bindings)
+      if (binding.type === "presence" && binding.event === event)
+        safely(() => binding.callback(value));
+  }
+  /**
+   * One track frame on the join `joinRef`. Its `ok` makes `state` the one
+   * tracked, with the token the hub judged it for — the one it holds once
+   * the identity frames sent before it are handled (`heldToken()`, 정정 (j))
+   * — unless what was tracked was let go of since `letGo` (the app's call,
+   * or now): the hub had that untrack or leave after it. The app's own call
+   * (`app`) is kept as well when no answer came — the connection went with
+   * it, or none in time: the hub may hold it, and it is the state the app
+   * last asked for, so the next join sends it rather than the one before
+   * (PR #328 review). The app's call waits its turn behind the app's frames,
+   * and may be refused for it (CLIENT_FLOODING, nothing kept); one sent
+   * again goes in the SDK's (PR #328 re-review).
+   */
+  #sendTrack(state, joinRef, letGo = this.#letGo, app = false) {
+    const token = this.#context.identity.heldToken();
+    return this.#context.socket.request(
+      this.topic,
+      "presence",
+      { type: "presence", event: "track", payload: state },
+      { joinRef, turn: app ? "app" : "sdk" }
+    ).then((reply) => {
+      const kept = reply.ok || app && (reply.lost || reply.error.code === "TIMED_OUT");
+      if (kept && letGo === this.#letGo) this.#tracked = { state, token };
+      return reply;
+    });
+  }
+  /**
+   * After a join comes back, the last state goes again (original spec §11.1)
+   * — only as the same session: the hub drops a presence when its user
+   * changes (3-2a P10), and a new token here may be someone else (결정 17).
+   * Who the hub reads it as is the token it will hold when the frame comes
+   * (`heldToken()`): a sign-in whose token went after the join would make
+   * the last user's state the new one's. And while who the connection is
+   * is not settled (a store read, a retry), it is let go of (정정 (j)).
+   * A refusal for now (`RETRACK_RETRY_CODES`) sends it again on this join
+   * after the channel backoff, checked as above each time, until the app
+   * tracks or untracks, the channel leaves, or the join goes — after one
+   * the hub warned the connection for, three times at most, and then it
+   * waits for the next join (`WARNED_CODES`); any other refusal lets go of
+   * it; a connection lost before the answer keeps it for the next join.
+   * Each send, the first too, waits its turn for room in the connection's
+   * warnings (`whenRoom()`, PR #328 review).
+   */
+  #retrack(joinRef) {
+    const tracked = this.#tracked;
+    if (tracked === null) return;
+    const calls = this.#presenceCalls;
+    const current = () => this.#tracked === tracked && this.#joinRef === joinRef && this.#presenceCalls === calls;
+    const go = (attempt2, warned) => {
+      if (!current()) return;
+      this.#context.socket.whenRoom(this.#retrackTurn, () => {
+        send2(attempt2, warned);
+      });
+    };
+    const send2 = (attempt2, warned) => {
+      if (!current()) return;
+      if (!this.#context.live() || tracked.token !== this.#context.identity.heldToken())
+        return this.#letGoOfTrack();
+      void this.#sendTrack(tracked.state, joinRef).then((reply) => {
+        if (reply.ok || reply.lost || this.#tracked !== tracked) return;
+        const { code } = reply.error;
+        if (!RETRACK_RETRY_CODES.has(code)) {
+          this.#tracked = null;
+          return;
+        }
+        if (!current()) return;
+        const warning = WARNED_CODES.has(code) ? 1 : 0;
+        if (warned + warning > RETRACK_WARNED_RESENDS) return;
+        const delay = backoffMs(attempt2, Math.random);
+        this.#retrackTimer = setTimeout(() => {
+          this.#retrackTimer = void 0;
+          go(attempt2 + 1, warned + warning);
+        }, delay);
+      });
+    };
+    go(0, 0);
+  }
+  /**
+   * `send` now — or, when `wait` (a track or a broadcast while the
+   * connection is not live) or an earlier call of the app's waits, at
+   * `#releaseWaiting()`, in the order the app made them: the hub must have
+   * them in that order. Null when the join went before its turn: nothing
+   * was sent.
+   */
+  #inTurn(joinRef, wait, send2) {
+    if (!wait && this.#waiting.length === 0) return send2();
+    return new Promise((resolve) => {
+      this.#waiting.push(
+        () => resolve(this.#joinRef === joinRef ? send2() : null)
+      );
+    });
+  }
+  /**
+   * The calls that waited go now, in order and all in this turn — a call
+   * made after them must not go first. Called when the connection is live
+   * again, and when the join goes (they answer that it went).
+   */
+  #releaseWaiting() {
+    const waiting = this.#waiting;
+    this.#waiting = [];
+    for (const go of waiting) go();
+  }
+  /** Nothing is tracked from now on, whatever answer comes for a track sent before. */
+  #letGoOfTrack() {
+    this.#tracked = null;
+    this.#letGo += 1;
+    this.#clearRetrack();
+  }
+  #clearRetrack() {
+    clearTimeout(this.#retrackTimer);
+    this.#retrackTimer = void 0;
+  }
+  /**
+   * Stops until subscribe(): no join, no retry, and the app hears `error`.
+   * No presence_state comes until then, so what the app saw goes, as for a
+   * join refused or the server's close (정정 (k)); what was tracked stays,
+   * for a join of the same session after subscribe().
+   */
+  #stop(error) {
+    this.#clearRetry();
+    this.#joinRef = null;
+    this.#wanted = false;
+    this.#state = "errored";
+    this.#releaseWaiting();
+    this.#presence.leaveAll(this.#presenceEmit);
+    this.#toldStop(error);
+  }
+  /**
+   * CHANNEL_ERROR for a stop. Inside subscribe() it comes a microtask later,
+   * as for an invalid name: in `const ch = naro.channel(…).subscribe(cb)`,
+   * `cb` may read `ch`, which is not set until subscribe() returns.
+   */
+  #toldStop(error) {
+    if (this.#subscribing)
+      queueMicrotask(() => this.#status("CHANNEL_ERROR", error));
+    else this.#status("CHANNEL_ERROR", error);
+  }
+  #tell(status, error) {
+    if (this.#told) return;
+    this.#told = true;
+    this.#status(status, error);
+  }
+  #status(status, error) {
+    const callback = this.#onStatus;
+    if (callback !== null) safely(() => callback(status, error));
+  }
+  /** No join retry waits — nor a track sent again on a join that is going. */
+  #clearRetry() {
+    clearTimeout(this.#retry);
+    this.#retry = void 0;
+    this.#clearRetrack();
+  }
+};
+
+// src/realtime/identity.ts
+var RETRY_CODES = /* @__PURE__ */ new Set([
+  "TOO_MANY_JOINS",
+  "TIMED_OUT",
+  "INTERNAL_ERROR"
+]);
+function rejudgeWaitMs(privateChannels) {
+  return Math.max(1, Math.ceil(privateChannels / 2)) * 1e3;
+}
+var Identity = class {
+  #config;
+  /** The token the hub answered `ok` for on this connection; null is anon. */
+  #confirmed = null;
+  /**
+   * The last frame sent, until its own reply; null when none is in flight.
+   * Matched by the object, not the token: an older frame of the same token
+   * answered meanwhile is not this one.
+   */
+  #inFlight = null;
+  /**
+   * The frame the hub answered INVALID_SESSION: the 4401 that follows is
+   * about its token. An object, since that token is null when the frame was
+   * a sign-out — a refusal still, and not "nothing refused".
+   */
+  #refused = null;
+  /**
+   * A frame got no answer in time (TIMED_OUT), and no `ok` came since: the
+   * hub may have taken it late, so what it holds is not known, and a read
+   * with no frame in flight tells the stored token even when it is
+   * `heldToken()` (정정 (k)). An `ok` says what it holds — replies come in
+   * the order the frames went, so it is about a later frame.
+   */
+  #unsure = false;
+  /** Bumped when a connection ends: a reply about an earlier one changes nothing. */
+  #epoch = 0;
+  #attempt = 0;
+  #retry;
+  /** The socket's generation opened() was called for; null once it ended. */
+  #connection = null;
+  /** changed() calls of this connection still reading the store. */
+  #reading = 0;
+  /** onLive was called, and the connection has been live since. */
+  #announced = false;
+  constructor(config) {
+    this.#config = config;
+  }
+  /** The token the hub took on this connection; null for anon or before its answer. */
+  confirmed() {
+    return this.#confirmed;
+  }
+  /**
+   * The token the hub will hold once what was sent is handled — the last
+   * frame in flight, or else the one it took: the hub handles the
+   * connection's frames in order, so a frame sent now is judged for it.
+   * A frame in flight may yet be refused; the hub then keeps `confirmed()`.
+   */
+  heldToken() {
+    return this.#inFlight === null ? this.#confirmed : this.#inFlight.token;
+  }
+  /**
+   * Nothing about who the connection is is pending — no read, no frame in
+   * flight, no retry, no refusal: a join sent now is judged for the identity
+   * the hub settled on, the stored one unless it refused that for good on
+   * this connection (결정 24).
+   */
+  isLive() {
+    const socket = this.#config.socket();
+    return this.#connection === socket.generation && socket.isOpen() && this.#reading === 0 && this.#inFlight === null && this.#retry === void 0 && this.#refused === null;
+  }
+  /**
+   * A new connection: anon until told. Resolves once the stored token is
+   * sent, or found to need no frame; `onLive` says when the hub took it.
+   */
+  async opened() {
+    this.closed();
+    this.#connection = this.#config.socket().generation;
+    await this.changed();
+  }
+  /** The stored token may have changed: tell the open connection what is new. */
+  async changed() {
+    if (this.#config.service) return this.#settle();
+    const epoch = this.#epoch;
+    this.#reading += 1;
+    this.#announced = false;
+    try {
+      await this.#config.ready();
+    } catch {
+    }
+    const token = await this.#config.tokens.get();
+    if (epoch === this.#epoch) this.#reading -= 1;
+    if (this.#config.socket().isOpen()) {
+      const unknown = this.#unsure && this.#inFlight === null;
+      if (unknown || token !== this.heldToken()) this.#send(token);
+    }
+    this.#settle();
+  }
+  /**
+   * A 4401: forget the stored session only if the hub answered
+   * INVALID_SESSION to it by name, and it is still stored — a sign-in since
+   * then keeps its new token (결정 3). A 4401 with no such answer clears
+   * nothing (plan 2026-10-28 정정): the hub keeps the expiry it read when it
+   * took the token (known-issues #183) while the backend's sign-in slides
+   * the session's under the same token, so a tab open for days is closed
+   * with a session that is still good. The next connection tells the token
+   * again, and hears INVALID_SESSION — and clears it — if it really is
+   * dead. The access JWT goes with the session it was minted for, so only
+   * when that session went.
+   */
+  async refused() {
+    const epoch = this.#epoch;
+    const early = this.#refused;
+    await Promise.resolve();
+    const refusal = this.#epoch === epoch ? this.#refused : early;
+    this.closed();
+    if (refusal === null || refusal.token === null) return;
+    if (await this.#config.tokens.clearIf(refusal.token))
+      await this.#config.accessJwt?.clear();
+  }
+  /** The connection is gone: what it was told is forgotten. */
+  closed() {
+    clearTimeout(this.#retry);
+    this.#retry = void 0;
+    this.#epoch += 1;
+    this.#confirmed = null;
+    this.#inFlight = null;
+    this.#refused = null;
+    this.#unsure = false;
+    this.#attempt = 0;
+    this.#connection = null;
+    this.#reading = 0;
+    this.#announced = false;
+  }
+  /** Live, and not said yet since it last was not: say it. */
+  #settle() {
+    if (this.#announced || !this.isLive()) return;
+    this.#announced = true;
+    safely(() => this.#config.onLive());
+  }
+  #send(token) {
+    clearTimeout(this.#retry);
+    this.#retry = void 0;
+    const sent2 = { token };
+    this.#inFlight = sent2;
+    const epoch = this.#epoch;
+    void this.#config.socket().request(
+      PHOENIX_TOPIC,
+      "access_token",
+      { access_token: token },
+      { turn: "identity" }
+    ).then((reply) => {
+      if (epoch === this.#epoch) this.#heard(sent2, reply);
+    });
+  }
+  #heard(sent2, reply) {
+    if (this.#inFlight === sent2) this.#inFlight = null;
+    if (reply.ok) {
+      this.#confirmed = sent2.token;
+      this.#unsure = false;
+      this.#attempt = 0;
+      return this.#settle();
+    }
+    if (reply.lost) return;
+    if (reply.error.code === "TIMED_OUT") this.#unsure = true;
+    if (reply.error.code === "INVALID_SESSION") {
+      this.#refused = sent2;
+      return;
+    }
+    if (this.#inFlight !== null) return;
+    if (!RETRY_CODES.has(reply.error.code)) {
+      if (this.#confirmed !== null && sent2.token !== this.#confirmed) {
+        this.closed();
+        this.#config.socket().reconnect();
+        return;
+      }
+      return this.#settle();
+    }
+    this.#later(
+      reply.error.code === "TOO_MANY_JOINS" ? rejudgeWaitMs(this.#config.privateChannels()) : 0
+    );
+  }
+  /**
+   * Reads the store again after the backoff (at least `minMs`), once there
+   * is room on the connection for a frame the SDK sends of its own accord
+   * (`whenRoom()`, PR #328 review). `#retry` stays set until then: the
+   * connection is not live while it waits.
+   */
+  #later(minMs) {
+    clearTimeout(this.#retry);
+    const delay = Math.max(minMs, backoffMs(this.#attempt, Math.random));
+    this.#attempt += 1;
+    const epoch = this.#epoch;
+    this.#retry = setTimeout(() => {
+      this.#config.socket().whenRoom(this, () => {
+        if (epoch !== this.#epoch) return;
+        this.#retry = void 0;
+        void this.changed();
+      });
+    }, delay);
+  }
+};
+
+// src/realtime/client.ts
+var LEAVE_RETRY_CODES = /* @__PURE__ */ new Set([
+  "TOO_MANY_JOINS",
+  "INTERNAL_ERROR",
+  "CONNECTION_STATE_TOO_LARGE",
+  "TIMED_OUT"
+]);
+function sameSettings(a, b) {
+  if (a === b) return true;
+  try {
+    return JSON.stringify(a) === JSON.stringify(b);
+  } catch {
+    return false;
+  }
+}
+function sameJoin(a, b) {
+  return a.name === b.name && a.isPrivate === b.isPrivate;
+}
+function foldTable(table) {
+  return table.replaceAll(/[A-Z]/g, (letter) => letter.toLowerCase());
+}
+var RealtimeClient = class {
+  #http;
+  #socket;
+  #identity;
+  #context;
+  #channels = [];
+  /** The leaves owed on the open connection (정정 (i)); forgotten with it. */
+  #owed = /* @__PURE__ */ new Set();
+  #onStorage = null;
+  constructor(input) {
+    const { http, auth, service, options } = input;
+    this.#http = http;
+    this.#socket = new RealtimeSocket({
+      baseUrl: http.baseUrl,
+      apiKey: http.apiKey,
+      service,
+      options,
+      events: {
+        // Not awaited, and not live yet: onLive says when the hub took it.
+        opened: () => {
+          this.#watchStorage();
+          void this.#identity.opened();
+        },
+        frame: (frame) => this.#route(frame),
+        // Only the leaves and the channels: the identity is closed by the
+        // next opened() (the 4401's refused() reads it after this turn —
+        // 정정 (f)).
+        dropped: (error, status) => {
+          this.#forgetLeaves();
+          this.#each((channel) => channel.dropped(error, status));
+        },
+        stopped: (error) => this.#stopped(error),
+        sessionRefused: () => this.#identity.refused()
+      }
+    });
+    this.#identity = new Identity({
+      tokens: http.tokens,
+      accessJwt: http.accessJwt,
+      service,
+      socket: () => this.#socket,
+      privateChannels: () => this.#channels.filter(
+        (channel) => channel.isPrivate && channel.state === "joined"
+      ).length,
+      onLive: () => this.#each((channel) => channel.rejoin()),
+      // A sign-in the page URL carries goes before any join (final review A I1).
+      ready: () => auth.ready()
+    });
+    this.#context = {
+      socket: this.#socket,
+      identity: this.#identity,
+      http,
+      auth,
+      connect: () => this.#socket.connect(),
+      live: () => this.#identity.isLive(),
+      leave: (channel, joinRef, tables) => this.#leave(channel, joinRef, tables),
+      owesLeave: (channel) => this.#owesLeave(channel),
+      owesLeaveOn: (table) => this.#owesLeaveOn(table)
+    };
+    http.tokens.subscribe(() => void this.#identity.changed());
+  }
+  channel(name, options = {}) {
+    const settings = isRecord(options) ? options : {};
+    const isPrivate = settings.config?.private === true;
+    const found = this.#channels.find(
+      (c) => c.name === name && c.isPrivate === isPrivate
+    );
+    if (found !== void 0) {
+      if (!sameSettings(found.options, settings))
+        warnInDevelopment(
+          `naro-js: channel(${JSON.stringify(name)}) already exists with other settings; it keeps the first ones until removeChannel().`
+        );
+      return found;
+    }
+    const channel = new RealtimeChannel(
+      name,
+      settings,
+      this.#context
+    );
+    this.#channels.push(channel);
+    return channel;
+  }
+  getChannels() {
+    return [...this.#channels];
+  }
+  async removeChannel(channel) {
+    this.#channels = this.#channels.filter((c) => c !== channel);
+    return this.#closeIfLast(await channel.unsubscribe());
+  }
+  async removeAllChannels() {
+    const channels = this.#channels;
+    this.#channels = [];
+    const results = await Promise.all(
+      channels.map((channel) => channel.unsubscribe())
+    );
+    return this.#closeIfLast({
+      data: null,
+      error: results.find((result) => result.error !== null)?.error ?? null
+    });
+  }
+  /**
+   * No channel left (the app may have added one meanwhile): the connection
+   * closes. That is the strongest leave — the hub forgets every join with
+   * its connection — so a leave's refusal no longer stands (정정 (j)).
+   */
+  #closeIfLast(result) {
+    if (this.#channels.length > 0) return result;
+    this.#disconnect();
+    return { data: null, error: null };
+  }
+  /**
+   * Each channel in turn, over a copy (a callback may add or remove one);
+   * what one throws does not keep the next from hearing (결정 22).
+   */
+  #each(action) {
+    for (const channel of Array.from(this.#channels))
+      safely(() => action(channel));
+  }
+  #route(frame) {
+    if (frame.topic === PHOENIX_TOPIC || frame.joinRef === null) return;
+    const channel = this.#channels.find(
+      (c) => c.joinRef === frame.joinRef && c.topic === frame.topic
+    );
+    channel?.receive(frame);
+  }
+  #stopped(error) {
+    this.#identity.closed();
+    this.#forgetLeaves();
+    this.#unwatchStorage();
+    this.#each((channel) => channel.stopped(error));
+  }
+  #disconnect() {
+    this.#socket.disconnect();
+    this.#identity.closed();
+    this.#forgetLeaves();
+    this.#unwatchStorage();
+  }
+  #leave(channel, joinRef, tables) {
+    const owed = {
+      channel,
+      joinRef,
+      tables,
+      attempt: 0,
+      timer: void 0
+    };
+    this.#owed.add(owed);
+    return this.#sendLeave(owed, "app");
+  }
+  /**
+   * One `phx_leave` of `owed`; its answer decides whether it is done,
+   * whoever else awaits it. The first goes in the app's turn, after the
+   * frames the app sent on the join before it (and is never refused for
+   * it); one tried again, in the SDK's (PR #328 re-review).
+   */
+  #sendLeave(owed, turn) {
+    const { channel, joinRef } = owed;
+    const reply = this.#socket.request(
+      channel.topic,
+      "phx_leave",
+      {},
+      { joinRef, turn }
+    );
+    void reply.then((answer) => this.#leaveAnswered(owed, answer));
+    return reply;
+  }
+  #leaveAnswered(owed, reply) {
+    if (!this.#owed.has(owed)) return;
+    if (!reply.ok && !reply.lost && LEAVE_RETRY_CODES.has(reply.error.code)) {
+      const delay = backoffMs(owed.attempt, Math.random);
+      owed.attempt += 1;
+      owed.timer = setTimeout(() => {
+        owed.timer = void 0;
+        this.#socket.whenRoom(owed, () => {
+          if (this.#owed.has(owed)) void this.#sendLeave(owed, "sdk");
+        });
+      }, delay);
+      const { error } = reply;
+      this.#each((channel) => {
+        if (sameJoin(channel, owed.channel)) channel.leaveRefused(error);
+      });
+      return;
+    }
+    this.#owed.delete(owed);
+    this.#each((channel) => channel.rejoin());
+  }
+  #owesLeave(channel) {
+    for (const owed of this.#owed)
+      if (sameJoin(owed.channel, channel)) return true;
+    return false;
+  }
+  /** `ChannelContext.owesLeaveOn`: the hub's caps count the joins whose leaves are owed. */
+  #owesLeaveOn(table) {
+    for (const owed of this.#owed) {
+      if (table === null) return true;
+      const key = foldTable(table);
+      if (owed.tables.some(
+        (held) => held === "*" || key === "*" || foldTable(held) === key
+      ))
+        return true;
+    }
+    return false;
+  }
+  #forgetLeaves() {
+    for (const owed of this.#owed) clearTimeout(owed.timer);
+    this.#owed.clear();
+  }
+  /**
+   * Another tab signing in or out writes the same localStorage key: read the
+   * store again while the connection lives (결정 5) — from its first open to
+   * a stop or the last channel's removal, drops included. Reading again
+   * sends nothing unless the stored token is not what the hub has, so a
+   * storage of the app's own (`auth.storage`), whose writes this event
+   * never reports, costs a read at most.
+   */
+  #watchStorage() {
+    const target = globalThis;
+    if (this.#onStorage !== null || !isBrowser() || typeof target.addEventListener !== "function")
+      return;
+    const key = storageKey(this.#http.baseUrl);
+    this.#onStorage = (event) => {
+      if (event.key === key || event.key === null)
+        void this.#identity.changed();
+    };
+    target.addEventListener("storage", this.#onStorage);
+  }
+  #unwatchStorage() {
+    const target = globalThis;
+    if (this.#onStorage === null) return;
+    target.removeEventListener?.("storage", this.#onStorage);
+    this.#onStorage = null;
+  }
+};
+
 // src/storage/answer.ts
 function fail(error) {
   return { data: null, error };
@@ -1968,7 +4173,7 @@ async function uploadInParts(a) {
     failure.error ??= uploadAborted();
   };
   const tryPart = async (n, bytes) => {
-    const sent = await send(a.http, {
+    const sent2 = await send(a.http, {
       method: "PUT",
       path: `${base}/${String(n)}`,
       headers: { "content-type": "application/octet-stream", ...signed },
@@ -1976,10 +4181,10 @@ async function uploadInParts(a) {
       withToken,
       signal
     });
-    if (sent.error !== null) return sent;
-    const read = await readJson(sent.response, partAnswer(n));
+    if (sent2.error !== null) return sent2;
+    const read = await readJson(sent2.response, partAnswer(n));
     if (read.error !== null)
-      return { error: read.error, status: sent.response.status };
+      return { error: read.error, status: sent2.response.status };
     return { etag: read.data.etag };
   };
   const sendPart = async (n) => {
@@ -2208,6 +4413,7 @@ var isEntry2 = (value) => isRecord(value) && typeof value.name === "string" && (
 var isSigned = (value) => isRecord(value) && typeof value.signedUrl === "string" && value.signedUrl.startsWith(SIGNED_PREFIX);
 var isSignedEntry = (value) => isRecord(value) && typeof value.path === "string" && (value.signedUrl === null || typeof value.signedUrl === "string" && value.signedUrl.startsWith(SIGNED_PREFIX)) && (value.error === null || typeof value.error === "string");
 var isSignedUpload = (value) => isRecord(value) && typeof value.signedUrl === "string" && value.signedUrl.startsWith(SIGNED_UPLOAD_PREFIX) && typeof value.token === "string" && value.token !== "" && typeof value.path === "string";
+var isMoved = (value) => isRecord(value) && typeof value.message === "string";
 var partsBody = (body) => isArrayBuffer(body) ? new Uint8Array(body) : body;
 function listOf(guard) {
   return (value) => Array.isArray(value) && value.every(guard);
@@ -2269,7 +4475,7 @@ var StorageFileApi = class {
       "cache-control": cache
     };
     if (upsert) headers["x-upsert"] = "true";
-    const sent = await send(this.#http, {
+    const sent2 = await send(this.#http, {
       method,
       path: target.path,
       headers,
@@ -2278,8 +4484,8 @@ var StorageFileApi = class {
       // The fetch stops with the body: the worker undoes its claim at once.
       signal
     });
-    if (sent.error !== null) return fail(sent.error);
-    return readJson(sent.response, isUploadResult);
+    if (sent2.error !== null) return fail(sent2.error);
+    return readJson(sent2.response, isUploadResult);
   }
   /**
    * A new object; with `upsert: true`, one of the same name is replaced.
@@ -2304,14 +4510,14 @@ var StorageFileApi = class {
     const target = this.#objectPath("", path);
     if (!target.ok) return fail(target.error);
     await this.#auth.ready();
-    const sent = await send(this.#http, {
+    const sent2 = await send(this.#http, {
       method: "GET",
       path: target.path,
       withToken: true
     });
-    if (sent.error !== null) return fail(sent.error);
+    if (sent2.error !== null) return fail(sent2.error);
     try {
-      return { data: await sent.response.blob(), error: null };
+      return { data: await sent2.response.blob(), error: null };
     } catch (error) {
       return fail(networkError(error));
     }
@@ -2363,9 +4569,76 @@ var StorageFileApi = class {
       listOf(isFileObject)
     );
   }
+  /**
+   * The body a move and a copy send (Storage 3-1i): the bucket and both
+   * names, as supabase-js sends them. The names are not checked here — they
+   * are in the body, and the backend answers a bad one `INVALID_REQUEST`
+   * (`details.path` "sourceKey" or "destinationKey"), as `remove` does.
+   */
+  #transferBody(fromPath, toPath, options) {
+    const { destinationBucket, upsert } = options;
+    return {
+      bucketId: this.#bucket,
+      sourceKey: fromPath,
+      destinationKey: toPath,
+      ...destinationBucket === void 0 ? {} : { destinationBucket },
+      ...upsert === true ? { upsert: true } : {}
+    };
+  }
+  /**
+   * Renames an object inside its bucket (Storage 3-1i): the same object — its
+   * id and owner — under `toPath`, its old name gone. It never replaces an
+   * object that is there (`OBJECT_EXISTS`), takes files up to 5 GiB − 5 MiB
+   * (`OBJECT_TOO_LARGE`), and needs room in the project for a second copy
+   * until it is done (`STORAGE_QUOTA_EXCEEDED`). Its signed links stop
+   * working at the old name: a link is bound to the name, the object's id
+   * and its bytes, so moving it back can open them again. A backend whose
+   * Storage was turned on before this method came answers `NOT_FOUND`:
+   * update it with `naro backend enable`.
+   */
+  async move(fromPath, toPath, options = {}) {
+    const bucket = encodeBucket(this.#bucket);
+    if (!bucket.ok) return fail(bucket.error);
+    const { destinationBucket } = options ?? {};
+    return this.#json(
+      {
+        method: "POST",
+        path: "/storage/object/move",
+        body: this.#transferBody(
+          fromPath,
+          toPath,
+          destinationBucket === void 0 ? {} : { destinationBucket }
+        )
+      },
+      isMoved
+    );
+  }
+  /**
+   * Copies an object inside its bucket (Storage 3-1i): the source's bytes,
+   * type and cache-control under `toPath` — a new object of the caller's,
+   * or with `upsert: true` the one that is there, which keeps its owner.
+   * Files up to 5 GiB − 5 MiB, within the bucket's limits as they are now.
+   * It answers `{ id, path, fullPath }` — `path` is the name inside the
+   * bucket; supabase-js's copy puts the bucket in front of it. A backend
+   * whose Storage was turned on before this method came answers
+   * `NOT_FOUND`: update it with `naro backend enable`.
+   */
+  async copy(fromPath, toPath, options = {}) {
+    const bucket = encodeBucket(this.#bucket);
+    if (!bucket.ok) return fail(bucket.error);
+    return this.#json(
+      {
+        method: "POST",
+        path: "/storage/object/copy",
+        body: this.#transferBody(fromPath, toPath, options ?? {})
+      },
+      isUploadResult
+    );
+  }
   /**
    * A link to the object for `expiresIn` seconds (1–604,800). It stops
-   * working once the object is replaced or removed.
+   * working once the object is replaced or removed, and while the object is
+   * moved away from `path` (moved back, it can open it again).
    */
   async createSignedUrl(path, expiresIn, options = {}) {
     const target = this.#objectPath("sign/", path);
@@ -2509,7 +4782,7 @@ var StorageFileApi = class {
    * is the permission. A failure's cause never carries the token.
    */
   async #putSigned(path, token, payload, cache, signal) {
-    const sent = await send(this.#http, {
+    const sent2 = await send(this.#http, {
       method: "PUT",
       path: `${path}?token=${encodeURIComponent(token)}`,
       headers: { "content-type": payload.type, "cache-control": cache },
@@ -2517,8 +4790,8 @@ var StorageFileApi = class {
       withToken: false,
       signal
     });
-    if (sent.error !== null) return fail(withoutToken(sent.error, token));
-    const read = await readJson(sent.response, isUploadResult);
+    if (sent2.error !== null) return fail(withoutToken(sent2.error, token));
+    const read = await readJson(sent2.response, isUploadResult);
     return read.error === null ? read : fail(withoutToken(read.error, token));
   }
   /**
@@ -2560,10 +4833,36 @@ var CONFIG_MESSAGES = {
   urlNotOrigin: "createClient needs the project url alone, like https://my-app.naro.sh: no path, no ? or #, no user:password@. Naro serves its API at /_naro/v1 on that origin.",
   key: "createClient needs an anonKey (or, on a server, a serviceKey).",
   bothKeys: "Pass createClient an anonKey or a serviceKey, not both.",
-  serviceKeyOffServer: "A Naro service key (naro_sk_\u2026) skips every policy, so createClient accepts it only on a server (Node, Deno, Bun, Cloudflare Workers, an edge runtime), never in a browser, a web worker or a React Native app. Use the anon key (naro_pk_\u2026) here and keep the service key on your server.",
-  fetch: "This runtime has no fetch. Pass one to createClient({ fetch })."
+  serviceKeyOffServer: SERVICE_KEY_OFF_SERVER_MESSAGE,
+  fetch: "This runtime has no fetch. Pass one to createClient({ fetch }).",
+  realtime: "createClient's realtime options take a WebSocket class, and heartbeatIntervalMs and timeoutMs in whole milliseconds from 1 to 2147483647."
 };
 var SERVICE_KEY_PREFIX = "naro_sk_";
+var MAX_TIMER_MS = 2147483647;
+function isMilliseconds(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 && value <= MAX_TIMER_MS;
+}
+function realtimeOptionsOf(value) {
+  if (value === void 0) return {};
+  if (!isRecord(value)) throw new Error(CONFIG_MESSAGES.realtime);
+  const { WebSocket, heartbeatIntervalMs, timeoutMs } = value;
+  const options = {};
+  if (WebSocket !== void 0) {
+    if (typeof WebSocket !== "function")
+      throw new Error(CONFIG_MESSAGES.realtime);
+    options.WebSocket = WebSocket;
+  }
+  if (heartbeatIntervalMs !== void 0) {
+    if (!isMilliseconds(heartbeatIntervalMs))
+      throw new Error(CONFIG_MESSAGES.realtime);
+    options.heartbeatIntervalMs = heartbeatIntervalMs;
+  }
+  if (timeoutMs !== void 0) {
+    if (!isMilliseconds(timeoutMs)) throw new Error(CONFIG_MESSAGES.realtime);
+    options.timeoutMs = timeoutMs;
+  }
+  return options;
+}
 function baseUrlOf(url) {
   if (typeof url !== "string") throw new Error(CONFIG_MESSAGES.url);
   const trimmed = url.trim();
@@ -2620,11 +4919,19 @@ var NaroClient = class {
    */
   storage;
   #run;
+  #newRealtime;
+  /**
+   * Made by the first channel(), not by the constructor: it listens to every
+   * write of the session token (to tell an open connection who signed in),
+   * which an app that never uses Realtime should not pay for.
+   */
+  #realtime;
   constructor(options) {
     const baseUrl = baseUrlOf(options.url);
     const { key: apiKey, service } = apiKeyOf(options);
     if (options.fetch === void 0 && typeof globalThis.fetch !== "function")
       throw new Error(CONFIG_MESSAGES.fetch);
+    const realtime = realtimeOptionsOf(options.realtime);
     const storage = options.auth?.storage ?? defaultStorage();
     const http = {
       baseUrl,
@@ -2646,11 +4953,46 @@ var NaroClient = class {
     });
     this.#run = queryRunner(http, this.auth);
     this.storage = new StorageClient(http, this.auth);
+    this.#newRealtime = () => new RealtimeClient({
+      http,
+      auth: this.auth,
+      service,
+      options: realtime
+    });
   }
   /** Start a query on `table`: `.select()`, `.insert()`, `.update()` or `.delete()`. */
   from(table) {
     return new TableBuilder(this.#run, table);
   }
+  /**
+   * A Realtime channel (original spec §15): `.on()` listeners, then
+   * `.subscribe()`. The same name and privacy give the same channel until
+   * `removeChannel`. Nothing connects until the first `subscribe()`.
+   */
+  channel(name, options) {
+    return this.#client().channel(name, options);
+  }
+  /** The channels made with `channel()` and not yet removed. */
+  getChannels() {
+    return this.#realtime?.getChannels() ?? [];
+  }
+  /**
+   * Leaves the channel and forgets it, so `channel()` of its name makes a new
+   * one; the connection closes with the last channel.
+   */
+  removeChannel(channel) {
+    return this.#client().removeChannel(channel);
+  }
+  /** `removeChannel()` for every channel; the connection closes. */
+  removeAllChannels() {
+    if (this.#realtime === void 0)
+      return Promise.resolve({ data: null, error: null });
+    return this.#realtime.removeAllChannels();
+  }
+  #client() {
+    this.#realtime ??= this.#newRealtime();
+    return this.#realtime;
+  }
 };
 function createClient(options) {
   return new NaroClient(options);