@palbase/web 1.0.1 → 1.1.0

package/dist/index.cjs

@@ -23,10 +23,13 @@ __export(index_exports, {
   BackendError: () => BackendError,
   PalbeAnalytics: () => PalbeAnalytics,
   PalbeAuth: () => PalbeAuth,
+  PalbeCalls: () => PalbeCalls,
   PalbeFlags: () => PalbeFlags,
+  PalbeMessaging: () => PalbeMessaging,
   PalbeRealtime: () => PalbeRealtime,
   RealtimeChannel: () => RealtimeChannel,
   VERSION: () => VERSION,
+  initMls: () => initMls,
   isBackendError: () => isBackendError,
   localStorageSessionStorage: () => localStorageSessionStorage,
   memorySessionStorage: () => memorySessionStorage,
@@ -35,9 +38,10 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/api-key.ts
+var API_KEY_RE = /^pb_([^_]+)_[cs][A-Za-z0-9]{20}$/;
 function endpointRefFromApiKey(apiKey) {
-  const parts = apiKey.split("_");
-  return parts.length >= 3 && parts[0] === "pb" ? parts[1] ?? "" : "";
+  const m = API_KEY_RE.exec(apiKey);
+  return m ? m[1] ?? "" : "";
 }
 
 // ../core/dist/index.js
@@ -696,6 +700,220 @@ var PalbeAuth = class {
   }
 };
 
+// src/calls/facade.ts
+var import_livekit_client = require("livekit-client");
+var Call = class {
+  id;
+  _state = "connecting";
+  _participants = /* @__PURE__ */ new Map();
+  _listeners = /* @__PURE__ */ new Set();
+  _room;
+  _keyProvider;
+  /** @internal — obtain via PalbeCalls.start() / .accept() */
+  constructor(callId, room, keyProvider) {
+    this.id = callId;
+    this._room = room;
+    this._keyProvider = keyProvider;
+    this._wireRoomEvents();
+  }
+  // ─── State ──────────────────────────────────────────────────────────────
+  get state() {
+    return this._state;
+  }
+  /** Snapshot of current remote participants (does NOT include the local participant). */
+  get participants() {
+    return Array.from(this._participants.values());
+  }
+  get localParticipant() {
+    return this._room.localParticipant;
+  }
+  // ─── Subscribe ──────────────────────────────────────────────────────────
+  /**
+   * Subscribe to call changes (state + participant updates).
+   * Returns an `Unsubscribe` function — matches the SDK's flags/auth pattern.
+   */
+  subscribe(callback) {
+    this._listeners.add(callback);
+    return () => {
+      this._listeners.delete(callback);
+    };
+  }
+  // ─── Controls ───────────────────────────────────────────────────────────
+  /** Mute / unmute the local microphone. */
+  async mute(on) {
+    await this._room.localParticipant.setMicrophoneEnabled(!on);
+  }
+  /** Enable / disable the local camera. */
+  async setCamera(on) {
+    await this._room.localParticipant.setCameraEnabled(on);
+  }
+  /**
+   * Set a raw frame encryption key (ArrayBuffer) for this call.
+   * Design seam for SP-1.x web-MLS: call this with the MLS exporter secret
+   * to enable frame-level E2EE via ExternalE2EEKeyProvider.
+   *
+   * NOTE: The room must have been opened with `e2ee` options for this to take
+   * effect. Currently calls connect WITHOUT e2ee — see module docstring.
+   *
+   * TODO(SP-1-web): wire this to MLS-derived key on session join.
+   */
+  async setMediaKey(key) {
+    await this._keyProvider.setKey(key);
+  }
+  /** Leave the call and disconnect from the LiveKit room. */
+  async leave() {
+    await this._room.disconnect();
+    this._setState("ended");
+  }
+  // ─── Internal ───────────────────────────────────────────────────────────
+  _setState(next) {
+    if (this._state === next) return;
+    this._state = next;
+    this._emit();
+  }
+  _emit() {
+    for (const cb of this._listeners) cb(this);
+  }
+  _upsertParticipant(p) {
+    const existing = this._participants.get(p.identity);
+    const entry = {
+      identity: p.identity,
+      isSpeaking: p.isSpeaking,
+      audioMuted: !p.isMicrophoneEnabled,
+      videoEnabled: p.isCameraEnabled,
+      videoElement: existing?.videoElement ?? null,
+      audioElement: existing?.audioElement ?? null
+    };
+    this._participants.set(p.identity, entry);
+  }
+  _attachTrack(track, participant) {
+    const element = track.attach();
+    const entry = this._participants.get(participant.identity);
+    if (track.kind === import_livekit_client.Track.Kind.Video) {
+      if (entry) {
+        entry.videoElement = element;
+      }
+    } else if (track.kind === import_livekit_client.Track.Kind.Audio) {
+      if (entry) {
+        entry.audioElement = element;
+        element.play().catch(() => {
+        });
+      }
+    }
+    this._emit();
+  }
+  _wireRoomEvents() {
+    this._room.on(import_livekit_client.RoomEvent.Connected, () => {
+      this._setState("active");
+    }).on(
+      import_livekit_client.RoomEvent.TrackSubscribed,
+      (track, _pub, participant) => {
+        this._upsertParticipant(participant);
+        this._attachTrack(track, participant);
+      }
+    ).on(
+      import_livekit_client.RoomEvent.TrackUnsubscribed,
+      (_track, _pub, participant) => {
+        this._upsertParticipant(participant);
+        this._emit();
+      }
+    ).on(import_livekit_client.RoomEvent.ParticipantConnected, (participant) => {
+      this._upsertParticipant(participant);
+      this._emit();
+    }).on(import_livekit_client.RoomEvent.ParticipantDisconnected, (participant) => {
+      this._participants.delete(participant.identity);
+      this._emit();
+    }).on(import_livekit_client.RoomEvent.ActiveSpeakersChanged, (speakers) => {
+      for (const [id, entry] of this._participants) {
+        entry.isSpeaking = speakers.some((s) => s.identity === id);
+      }
+      this._emit();
+    }).on(import_livekit_client.RoomEvent.Disconnected, () => {
+      this._setState("ended");
+    });
+  }
+};
+var PalbeCalls = class {
+  rt;
+  constructor(rt) {
+    this.rt = rt;
+  }
+  /**
+   * Start a new call in a messaging group.
+   *
+   * @param groupId  - Messaging group display-id (`grp_<uuidv7>`)
+   * @param media    - Which media tracks to publish (default: audio + video)
+   * @returns        A `Call` in `connecting` state; transitions to `active` once LiveKit connects.
+   *
+   * @throws BackendError('network', { code: 'call_service_unavailable' })  if LiveKit SFU is down (503)
+   * @throws BackendError('forbidden', { code: 'not_group_member' })       if the caller is not a member (403)
+   * @throws BackendError('conflict', { code: 'call_room_full' })          if the room is full (409)
+   */
+  async start(groupId, { media = ["audio", "video"] } = {}) {
+    if (!groupId) {
+      throw new BackendError("validation", {
+        code: "invalid_group_id",
+        message: "groupId must be a non-empty string"
+      });
+    }
+    const res = await palbeRequest(
+      this.rt,
+      "POST",
+      `/v1/messaging/groups/${encodeURIComponent(groupId)}/calls`,
+      { body: { media } }
+    );
+    return this._connect(res.call_id, res.token, res.edge_url, media);
+  }
+  /**
+   * Accept an incoming call in a messaging group.
+   *
+   * @param groupId  - Messaging group display-id
+   * @param callId   - Call identifier (from the push notification payload)
+   * @param media    - Which media tracks to publish (default: audio + video)
+   */
+  async accept(groupId, callId, { media = ["audio", "video"] } = {}) {
+    const res = await palbeRequest(
+      this.rt,
+      "POST",
+      `/v1/messaging/groups/${encodeURIComponent(groupId)}/calls/${encodeURIComponent(callId)}/accept`,
+      { body: {} }
+    );
+    return this._connect(callId, res.token, res.edge_url, media);
+  }
+  /**
+   * Decline an incoming call.
+   *
+   * @param groupId  - Messaging group display-id
+   * @param callId   - Call identifier
+   * @param reason   - Optional decline reason string
+   */
+  async decline(groupId, callId, reason) {
+    await palbeRequest(
+      this.rt,
+      "POST",
+      `/v1/messaging/groups/${encodeURIComponent(groupId)}/calls/${encodeURIComponent(callId)}/decline`,
+      { body: { reason: reason ?? "" } }
+    );
+  }
+  // ─── Internal ─────────────────────────────────────────────────────────
+  async _connect(callId, token, edgeUrl, media) {
+    const keyProvider = new import_livekit_client.ExternalE2EEKeyProvider();
+    const room = new import_livekit_client.Room({
+      adaptiveStream: true,
+      dynacast: true
+    });
+    const call = new Call(callId, room, keyProvider);
+    await room.connect(edgeUrl, token);
+    if (media.includes("audio")) {
+      await room.localParticipant.setMicrophoneEnabled(true);
+    }
+    if (media.includes("video")) {
+      await room.localParticipant.setCameraEnabled(true);
+    }
+    return call;
+  }
+};
+
 // ../modules/flags/dist/index.js
 var FLAG_NAME_RE = /^[a-zA-Z0-9_-]+$/;
 var FlagsClient = class {
@@ -1174,218 +1392,3421 @@ function parsePersisted(raw) {
     syncVersion: rec.syncVersion
   };
 }
-function defaultEnv() {
-  const storage = resolveStorage();
-  const visibility = resolveVisibility();
-  return {
-    now: () => Date.now(),
-    setInterval: (handler, ms) => setInterval(handler, ms),
-    clearInterval: (handle) => clearInterval(handle),
-    storage,
-    visibility
-  };
+function defaultEnv() {
+  const storage = resolveStorage();
+  const visibility = resolveVisibility();
+  return {
+    now: () => Date.now(),
+    setInterval: (handler, ms) => setInterval(handler, ms),
+    clearInterval: (handle) => clearInterval(handle),
+    storage,
+    visibility
+  };
+}
+function resolveStorage() {
+  try {
+    if (typeof localStorage === "undefined") {
+      return null;
+    }
+    const probe = "__palbase_flags_probe__";
+    localStorage.setItem(probe, "1");
+    localStorage.removeItem(probe);
+    return localStorage;
+  } catch {
+    return null;
+  }
+}
+function resolveVisibility() {
+  if (typeof document === "undefined") {
+    return null;
+  }
+  const doc = document;
+  return {
+    isHidden: () => doc.visibilityState === "hidden",
+    onVisibilityChange: (cb) => {
+      doc.addEventListener("visibilitychange", cb);
+      return () => doc.removeEventListener("visibilitychange", cb);
+    }
+  };
+}
+
+// src/flags-facade.ts
+function palbeAuthAdapter(auth) {
+  return {
+    onAuthStateChange(callback) {
+      const unsubscribe = auth.onAuthStateChange(() => {
+        const signedIn = auth.isSignedIn;
+        callback(signedIn ? "SIGNED_IN" : "SIGNED_OUT", signedIn ? { signedIn } : null);
+      });
+      return { data: { subscription: { unsubscribe } } };
+    }
+  };
+}
+function serverPoolEnv() {
+  return {
+    now: () => Date.now(),
+    setInterval: () => {
+      throw new Error("palbe flags: polling is disabled server-side");
+    },
+    clearInterval: () => {
+    },
+    storage: null,
+    visibility: null
+  };
+}
+function sameFlagValue(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+  return false;
+}
+var PalbeFlags = class {
+  transport;
+  pool;
+  constructor(rt) {
+    this.transport = new FlagsClient(rt.http);
+    const browser = typeof document !== "undefined";
+    const ref = endpointRefFromApiKey(rt.config.apiKey);
+    const options = {
+      auth: palbeAuthAdapter(rt.auth),
+      ...ref ? { storageKey: `palbe.flags.${ref}` } : {},
+      ...browser ? {} : { pollIntervalMs: 0, env: serverPoolEnv() }
+    };
+    this.pool = new FlagsPool(this.transport, options);
+    if (browser) this.pool.start();
+  }
+  /** Resolves once the first snapshot (or persisted hydrate) is available. Auto-starts the pool. */
+  ready() {
+    return this.pool.ready();
+  }
+  /** Force an immediate re-snapshot. */
+  refresh() {
+    return this.pool.refresh();
+  }
+  /** Frozen snapshot of all cached values (identity-stable until a change). */
+  all() {
+    return this.pool.all();
+  }
+  /** Raw cached value for `key`, or `undefined` when not in the cache. */
+  get(key) {
+    return this.pool.all()[key];
+  }
+  /** `true` only when the cached value is strictly `true`; `fallback` when the key is absent. */
+  isEnabled(key, fallback = false) {
+    return this.pool.isEnabled(key, fallback);
+  }
+  /** Alias of {@link isEnabled} (iOS parity). */
+  bool(key, fallback = false) {
+    return this.isEnabled(key, fallback);
+  }
+  /** Cached value when it is a string, else `fallback`. */
+  getString(key, fallback) {
+    const value = this.pool.all()[key];
+    return typeof value === "string" ? value : fallback;
+  }
+  /** Cached value when it is an integer number, else `fallback`. */
+  getInt(key, fallback) {
+    const value = this.pool.all()[key];
+    return typeof value === "number" && Number.isInteger(value) ? value : fallback;
+  }
+  /** Cached value when it is a number (integers included), else `fallback`. */
+  getDouble(key, fallback) {
+    const value = this.pool.all()[key];
+    return typeof value === "number" ? value : fallback;
+  }
+  /**
+   * Resolve the multivariate variant for `key` — the variant name, or `null`
+   * when the flag has no variant (or the read fails).
+   *
+   * Wire failures (network errors, 404, etc.) resolve to `null`.
+   * Invalid flag names throw `BackendError('validation', { code: 'invalid_flag_name' })`.
+   *
+   * DEVIATION from iOS sync-cache parity: the platform does not propagate
+   * variant metadata into the user-flags snapshot/delta cache, so this is an
+   * ASYNC transport read (`GET /v1/flags/{key}/variant`), not a cache lookup.
+   */
+  async getVariant(key) {
+    let res;
+    try {
+      res = await this.transport.getVariant(key);
+    } catch (err) {
+      throw new BackendError("validation", {
+        code: "invalid_flag_name",
+        message: err instanceof Error ? err.message : String(err)
+      });
+    }
+    return res.data?.name ?? null;
+  }
+  /** Subscribe to any change in the cached flag set. */
+  onChange(callback) {
+    return this.pool.onChange(callback);
+  }
+  /**
+   * Observe ONE key: fires only when that key's value actually changes
+   * (per {@link sameFlagValue} — structural compare for objects), with the
+   * new value (`undefined` = deleted). P5 React-hook substrate.
+   */
+  subscribeKey(key, callback) {
+    let last = this.pool.all()[key];
+    return this.pool.onChange(() => {
+      const next = this.pool.all()[key];
+      if (sameFlagValue(last, next)) return;
+      last = next;
+      callback(next);
+    });
+  }
+  /**
+   * Async iteration over flag changes: yields the new {@link all} view on
+   * every pool change notification. The listener is detached when the
+   * consumer `break`s/`return`s/`throw`s — including while a `next()` is
+   * still pending (it resolves `{ done: true }` instead of hanging, which a
+   * plain async-generator `finally` would not guarantee).
+   */
+  changes() {
+    const queue = [];
+    const pending = [];
+    let finished = false;
+    const unsubscribe = this.pool.onChange(() => {
+      const snapshot = this.pool.all();
+      const resolve = pending.shift();
+      if (resolve) resolve({ value: snapshot, done: false });
+      else queue.push(snapshot);
+    });
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      unsubscribe();
+      while (pending.length > 0) pending.shift()?.({ value: void 0, done: true });
+    };
+    return {
+      next: () => {
+        if (finished) return Promise.resolve({ value: void 0, done: true });
+        const head = queue.shift();
+        if (head !== void 0) return Promise.resolve({ value: head, done: false });
+        return new Promise((resolve) => {
+          pending.push(resolve);
+        });
+      },
+      return: () => {
+        finish();
+        return Promise.resolve({ value: void 0, done: true });
+      },
+      throw: (error) => {
+        finish();
+        return Promise.reject(error);
+      },
+      [Symbol.asyncIterator]() {
+        return this;
+      }
+    };
+  }
+  /** Stop polling and detach all listeners (auth + visibility + subscribers). */
+  destroy() {
+    this.pool.destroy();
+  }
+};
+
+// src/messaging/util.ts
+function toBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  const chunk = 32768;
+  for (let i = 0; i < bytes.length; i += chunk) {
+    binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+  }
+  return btoa(binary);
+}
+function fromBase64(b64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function bytesToHex(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) {
+    s += (bytes[i] ?? 0).toString(16).padStart(2, "0");
+  }
+  return s;
+}
+var utf8Encoder = new TextEncoder();
+var utf8Decoder = new TextDecoder();
+var encodeUtf8 = (s) => utf8Encoder.encode(s);
+var decodeUtf8 = (b) => utf8Decoder.decode(b);
+var deviceIdBytes = (deviceId) => encodeUtf8(deviceId);
+function randomId() {
+  return crypto.randomUUID();
+}
+function mintDeviceId() {
+  return `mdv_${uuidV7()}`;
+}
+function uuidV7() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  const ts = Date.now();
+  const view = new DataView(bytes.buffer);
+  view.setUint32(0, Math.floor(ts / 2 ** 16));
+  view.setUint16(4, ts & 65535);
+  view.setUint8(6, view.getUint8(6) & 15 | 112);
+  view.setUint8(8, view.getUint8(8) & 63 | 128);
+  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function directKey(userA, userB) {
+  const [a, b] = [userA, userB].sort();
+  return `dm:${a}|${b}`;
+}
+function mintClientMsgId() {
+  const b = new Uint8Array(16);
+  crypto.getRandomValues(b);
+  return `msg_${Array.from(b, (x) => x.toString(16).padStart(2, "0")).join("")}`;
+}
+function truncateQuote(s) {
+  const scalars = [...s];
+  if (scalars.length <= 240) return [s, false];
+  return [scalars.slice(0, 240).join(""), true];
+}
+
+// src/messaging/wire.ts
+var GROUPS = "/v1/messaging/groups";
+var DEVICES = "/v1/messaging/devices";
+var KEYDIR = "/v1/messaging/keydir";
+var seg = (s) => encodeURIComponent(s);
+var MessagingPaths = {
+  groups: GROUPS,
+  groupsDirect: `${GROUPS}/direct`,
+  group: (displayId) => `${GROUPS}/${seg(displayId)}`,
+  groupMetadata: (displayId) => `${GROUPS}/${seg(displayId)}/metadata`,
+  groupMembers: (displayId) => `${GROUPS}/${seg(displayId)}/members`,
+  groupMemberDevice: (displayId, deviceId) => `${GROUPS}/${seg(displayId)}/members/${seg(deviceId)}`,
+  groupMessages: (displayId) => `${GROUPS}/${seg(displayId)}/messages`,
+  groupCommits: (displayId) => `${GROUPS}/${seg(displayId)}/commits`,
+  groupRead: (displayId) => `${GROUPS}/${seg(displayId)}/read`,
+  deviceWelcomes: (deviceId) => `${DEVICES}/${seg(deviceId)}/welcomes`,
+  deviceQueue: (deviceId) => `${DEVICES}/${seg(deviceId)}/queue`,
+  deviceQueueAck: (deviceId) => `${DEVICES}/${seg(deviceId)}/queue/ack`,
+  keydirDevices: `${KEYDIR}/devices`,
+  keydirDeviceKeyPackages: (deviceId) => `${KEYDIR}/devices/${seg(deviceId)}/keypackages`,
+  keydirUserDevices: (userId) => `${KEYDIR}/users/${seg(userId)}/devices`,
+  keydirUserClaim: (userId) => `${KEYDIR}/users/${seg(userId)}/keypackages/claim`,
+  keydirPinsVerify: `${KEYDIR}/pins/verify`,
+  prefs: "/v1/messaging/prefs"
+};
+var ContentType = {
+  application: 1,
+  proposal: 2,
+  commit: 3
+};
+
+// src/messaging/keydir.ts
+async function enrollDevice(rt, engine, deviceStore, opts = {}) {
+  const keyPackageCount = opts.keyPackageCount ?? 10;
+  const deviceId = engine.deviceId;
+  const alreadyEnrolled = await deviceStore.load(engine.userId) === deviceId;
+  if (!alreadyEnrolled) {
+    const material = await engine.enrollmentMaterial();
+    const body = {
+      device_id: deviceId,
+      platform: "web",
+      device_name: opts.deviceName,
+      cipher_suite: 1,
+      signature_key: toBase64(material.signatureKey),
+      credential: toBase64(material.credential),
+      capabilities: toBase64(material.capabilities)
+    };
+    await palbeRequest(rt, "POST", MessagingPaths.keydirDevices, { body });
+    await deviceStore.save(engine.userId, deviceId);
+  }
+  if (keyPackageCount > 0) {
+    const raws = [];
+    for (let i = 0; i < keyPackageCount; i++) {
+      raws.push(toBase64(await engine.generateKeyPackage()));
+    }
+    await replenish(rt, deviceId, raws);
+  }
+  return deviceId;
+}
+async function replenish(rt, deviceId, rawKeyPackagesB64) {
+  const body = { key_packages: rawKeyPackagesB64 };
+  await palbeRequest(rt, "POST", MessagingPaths.keydirDeviceKeyPackages(deviceId), { body });
+}
+async function claimKeyPackages(rt, userId) {
+  return palbeRequest(rt, "POST", MessagingPaths.keydirUserClaim(userId), {
+    body: {}
+  });
+}
+async function listDevices(rt, userId) {
+  return palbeRequest(rt, "GET", MessagingPaths.keydirUserDevices(userId));
+}
+
+// src/messaging/group-messaging.ts
+function encodeEnvelope(args) {
+  const env = {
+    v: 1,
+    type: "text",
+    client_msg_id: args.clientMsgId,
+    text: args.text,
+    ...args.replyTo ? { reply_to: args.replyTo } : {}
+  };
+  return encodeUtf8(JSON.stringify(env));
+}
+function decodeEnvelope(bytes) {
+  const s = decodeUtf8(bytes);
+  try {
+    const o = JSON.parse(s);
+    if (typeof o === "object" && o !== null && o.type === "text" && typeof o.v === "number") {
+      return {
+        text: o.text ?? null,
+        clientMsgId: o.client_msg_id ?? "",
+        replyTo: o.reply_to ?? null
+      };
+    }
+    if (typeof o === "object" && o !== null && o.type === "text") {
+      return { text: o.text ?? null, clientMsgId: "", replyTo: null };
+    }
+    if (typeof o === "object" && o !== null && o.type === "media")
+      return { text: null, clientMsgId: "", replyTo: null };
+  } catch {
+  }
+  return { text: s, clientMsgId: "", replyTo: null };
+}
+function resolveReply(ref, lookup) {
+  const parent = lookup(ref.client_msg_id);
+  if (parent !== null) {
+    return {
+      parentClientMsgId: ref.client_msg_id,
+      state: "resolved",
+      quoteSenderUserId: parent.senderUserId,
+      quoteText: parent.text,
+      quoteKind: ref.preview?.kind ?? "text"
+    };
+  }
+  return {
+    parentClientMsgId: ref.client_msg_id,
+    state: "unavailable",
+    quoteSenderUserId: ref.preview?.author_user_id ?? "",
+    quoteText: ref.preview?.body ?? null,
+    quoteKind: ref.preview?.kind ?? "text"
+  };
+}
+var DEFAULT_REBASE = { maxAttempts: 6, baseDelayMs: 80, jitterMs: 120 };
+var RebaseExhausted = class extends Error {
+  constructor(attempts, lastKnownEpoch) {
+    super(`commit rebase exhausted after ${attempts} attempts`);
+    this.attempts = attempts;
+    this.lastKnownEpoch = lastKnownEpoch;
+    this.name = "RebaseExhausted";
+  }
+  attempts;
+  lastKnownEpoch;
+};
+var GroupMessaging = class {
+  constructor(rt, engine, selfUserId, selfDeviceId, messageStore, rebase = DEFAULT_REBASE) {
+    this.rt = rt;
+    this.engine = engine;
+    this.selfUserId = selfUserId;
+    this.selfDeviceId = selfDeviceId;
+    this.messageStore = messageStore;
+    this.rebase = rebase;
+  }
+  rt;
+  engine;
+  selfUserId;
+  selfDeviceId;
+  messageStore;
+  rebase;
+  // ── Create ──
+  /** Create a group: mint the rfc_group_id, POST create, return the server group.
+   * No name sealing on web (metadata omitted — server-blind, label fallback). */
+  async createGroup(cipherSuite = 1) {
+    const rfcGroupId = await this.engine.createGroup();
+    const body = {
+      rfc_group_id: toBase64(rfcGroupId),
+      cipher_suite: cipherSuite,
+      creator_device_id: this.selfDeviceId,
+      creator_leaf_index: 0
+    };
+    const res = await palbeRequest(this.rt, "POST", MessagingPaths.groups, {
+      body
+    });
+    return {
+      displayId: res.display_id,
+      rfcGroupId: res.rfc_group_id,
+      currentEpoch: res.current_epoch,
+      ownerUserId: this.selfUserId,
+      directKey: null,
+      name: null
+    };
+  }
+  // ── Direct (1:1) get-or-create ──
+  /** Materialize a DIRECT chat keyed by the stable direct_key (sorted user pair).
+   * EXISTS → adopt (the Welcome drains via the pump); ABSENT → create + add peer. */
+  async getOrCreateDirect(peerUserId) {
+    const dk = directKey(this.selfUserId, peerUserId);
+    const rfcGroupId = await this.engine.createGroup();
+    const body = {
+      direct_key: dk,
+      peer_user_id: peerUserId,
+      rfc_group_id: toBase64(rfcGroupId),
+      cipher_suite: 1,
+      creator_device_id: this.selfDeviceId,
+      creator_leaf_index: 0
+    };
+    const res = await palbeRequest(
+      this.rt,
+      "POST",
+      MessagingPaths.groupsDirect,
+      { body }
+    );
+    if (res.exists === true) {
+      await this.engine.clearPendingCommit(rfcGroupId);
+      return {
+        displayId: res.display_id,
+        rfcGroupId: res.rfc_group_id,
+        currentEpoch: res.current_epoch,
+        ownerUserId: res.owner_user_id ?? null,
+        directKey: dk,
+        name: null
+      };
+    }
+    const group = {
+      displayId: res.display_id,
+      rfcGroupId: res.rfc_group_id,
+      currentEpoch: res.current_epoch,
+      ownerUserId: this.selfUserId,
+      directKey: dk,
+      name: null
+    };
+    const claimed = await claimKeyPackages(this.rt, peerUserId);
+    await this.addMember(group, peerUserId, claimed);
+    return group;
+  }
+  // ── Members ──
+  /** The group roster (device leaves). The coordinator dedups to users. */
+  async listMembers(displayId) {
+    const res = await palbeRequest(
+      this.rt,
+      "GET",
+      MessagingPaths.groupMembers(displayId)
+    );
+    return res.members;
+  }
+  /** Add a member: claim → stage the add commit → run the rebase loop. SP-1.6:
+   * EVERY device of the user joins in ONE atomic commit (one shared Welcome). */
+  async addMember(group, userId, claimed) {
+    const claim = claimed ?? await claimKeyPackages(this.rt, userId);
+    const adds = claim.key_packages.map((kp) => {
+      try {
+        return { deviceId: kp.device_id, kp: fromBase64(kp.key_package) };
+      } catch {
+        return null;
+      }
+    }).filter((x) => x !== null);
+    if (adds.length === 0) {
+      throw new BackendError("validation", {
+        code: "no_keypackage",
+        message: "no claimable key package for user",
+        status: 422
+      });
+    }
+    const userIds = adds.map(() => userId);
+    await this.commitWithRebase(group.rfcGroupId, async () => {
+      const out = await this.engine.commitChanges(
+        fromBase64(group.rfcGroupId),
+        adds.map((a) => a.kp),
+        []
+      );
+      const welcomeB64 = out.welcome ? toBase64(out.welcome) : "";
+      const welcomes = adds.map((a) => ({
+        recipient_device_id: a.deviceId,
+        recipient_user_id: userId,
+        welcome_b64: welcomeB64
+      }));
+      const memberBody = {
+        op: "add",
+        commit_b64: toBase64(out.commit),
+        target_device_ids: adds.map((a) => a.deviceId),
+        leaf_indexes: out.addedLeafIndices,
+        user_ids: userIds,
+        key_package_refs: [],
+        welcomes
+      };
+      return {
+        method: "POST",
+        path: MessagingPaths.groupMembers(group.displayId),
+        body: memberBody
+      };
+    });
+  }
+  /** Remove a user = evict ALL their device leaves in ONE commit (SP-1.6 D4). */
+  async removeMember(group, userId) {
+    const members = await this.listMembers(group.displayId);
+    const deviceIds = members.filter((m) => m.user_id === userId).map((m) => m.device_id);
+    if (deviceIds.length === 0) {
+      throw new BackendError("validation", {
+        code: "not_a_member",
+        message: "user has no device in this group",
+        status: 404
+      });
+    }
+    await this.stageMultiRemove(group, deviceIds, [userId]);
+  }
+  /** Leave = remove the CALLING device's leaf only (per-device self-leave). */
+  async leaveGroup(group) {
+    await this.stageMultiRemove(group, [this.selfDeviceId], [this.selfUserId]);
+  }
+  async stageMultiRemove(group, deviceIds, removedUserIds) {
+    const pathDeviceId = deviceIds[0];
+    if (!pathDeviceId) throw new Error("no device to remove");
+    await this.commitWithRebase(group.rfcGroupId, async () => {
+      const out = await this.engine.commitChanges(
+        fromBase64(group.rfcGroupId),
+        [],
+        deviceIds.map(deviceIdBytes)
+      );
+      const body = {
+        op: "remove",
+        commit_b64: toBase64(out.commit),
+        target_device_ids: deviceIds,
+        user_ids: removedUserIds
+      };
+      return {
+        method: "DELETE",
+        path: MessagingPaths.groupMemberDevice(group.displayId, pathDeviceId),
+        body
+      };
+    });
+  }
+  // ── Send ──
+  /** Send a text message. Encrypt at the current epoch, POST, return the receipt +
+   * the client-minted `clientMsgId` (needed by the Chat layer for reply indexing).
+   * NEVER rebases (a 422 stale_application surfaces to the caller). */
+  async sendText(group, text, replyTo) {
+    const clientMsgId = mintClientMsgId();
+    const plaintext = encodeEnvelope({ text, clientMsgId, replyTo });
+    const ct = await this.engine.encryptApplication(fromBase64(group.rfcGroupId), plaintext);
+    const body = {
+      ciphertext_b64: toBase64(ct),
+      client_idem_key: randomId()
+    };
+    const wire = await palbeRequest(
+      this.rt,
+      "POST",
+      MessagingPaths.groupMessages(group.displayId),
+      { body }
+    );
+    const stored = {
+      id: `${group.rfcGroupId}#${wire.server_seq}`,
+      direction: "outgoing",
+      text,
+      senderDeviceId: this.selfDeviceId,
+      epoch: wire.epoch,
+      serverSeq: wire.server_seq,
+      at: Date.now(),
+      clientMsgId,
+      replyTo: replyTo ? {
+        clientMsgId: replyTo.client_msg_id,
+        previewBody: replyTo.preview?.body ?? null,
+        previewAuthorUserId: replyTo.preview?.author_user_id ?? null,
+        previewKind: replyTo.preview?.kind ?? "text"
+      } : null
+    };
+    try {
+      await this.messageStore.append(group.rfcGroupId, stored);
+    } catch {
+    }
+    return { receipt: { serverSeq: wire.server_seq, epoch: wire.epoch }, clientMsgId };
+  }
+  // ── The rebase loop ──
+  async commitWithRebase(rfcGroupId, build) {
+    const gidBytes = fromBase64(rfcGroupId);
+    let lastEpoch = null;
+    for (let attempt = 1; attempt <= this.rebase.maxAttempts; attempt++) {
+      const pending = await build();
+      try {
+        await palbeRequest(this.rt, pending.method, pending.path, {
+          body: pending.body
+        });
+        await this.engine.applyPendingCommit(gidBytes);
+        return;
+      } catch (e) {
+        if (isBackendError(e) && e.code === "epoch_conflict") {
+          await this.engine.clearPendingCommit(gidBytes);
+          const ce = e.data?.current_epoch;
+          if (typeof ce === "number") lastEpoch = ce;
+          if (attempt === this.rebase.maxAttempts) break;
+          await this.drain(rfcGroupId);
+          await this.backoff(attempt);
+          continue;
+        }
+        throw e;
+      }
+    }
+    await this.engine.clearPendingCommit(gidBytes);
+    throw new RebaseExhausted(this.rebase.maxAttempts, lastEpoch);
+  }
+  /** Pull the device queue, process the winning commit(s) so the engine advances
+   * to the new epoch, ack the commits (the delivery source owns app messages). */
+  async drain(rfcGroupId) {
+    const page = await palbeRequest(
+      this.rt,
+      "GET",
+      MessagingPaths.deviceQueue(this.selfDeviceId)
+    );
+    const gidBytes = fromBase64(rfcGroupId);
+    const ackIds = [];
+    for (const row of page.messages) {
+      if (row.content_type !== ContentType.commit) continue;
+      try {
+        await this.engine.processIncoming(gidBytes, fromBase64(row.ciphertext_b64));
+      } catch {
+      }
+      ackIds.push(row.id);
+    }
+    if (ackIds.length > 0) {
+      await palbeRequest(this.rt, "POST", MessagingPaths.deviceQueueAck(this.selfDeviceId), {
+        body: { message_ids: ackIds }
+      });
+    }
+  }
+  async backoff(attempt) {
+    const base = this.rebase.baseDelayMs * attempt;
+    const jitter = this.rebase.jitterMs === 0 ? 0 : Math.random() * this.rebase.jitterMs;
+    const total = base + jitter;
+    if (total <= 0) return;
+    await new Promise((r) => setTimeout(r, total));
+  }
+};
+
+// src/messaging/chat.ts
+var Chat = class {
+  /** Stable, URL/log-safe id (the grp_ display id once active; a reserved local id while draft). */
+  id;
+  kind;
+  _state;
+  _group;
+  _draft;
+  backend;
+  messageList = [];
+  memberCache = [];
+  typingList = [];
+  presenceStates = /* @__PURE__ */ new Map();
+  readWatermark = -1;
+  titleOverride = null;
+  seenKeys = /* @__PURE__ */ new Set();
+  /** Index: clientMsgId → { text, senderUserId } for resolveReply lookups. */
+  byClientMsgId = /* @__PURE__ */ new Map();
+  loadedEarliestSeq = null;
+  historyLoaded = false;
+  wired = false;
+  liveUnsub = null;
+  listeners = /* @__PURE__ */ new Set();
+  /** @internal — obtain via pb.messaging.directChat / groupChat / chat(id). */
+  constructor(args) {
+    this.backend = args.backend;
+    if ("group" in args) {
+      this.id = args.group.displayId;
+      this.kind = args.kind;
+      this._state = "active";
+      this._group = args.group;
+      this._draft = null;
+      this.seedMembersFromGroup(args.group);
+    } else {
+      this.id = args.draft.reservedId;
+      this.kind = args.kind;
+      this._state = "draft";
+      this._group = null;
+      this._draft = args.draft;
+      this.seedDraftMembers(args.draft);
+    }
+  }
+  // ── Observability ──
+  /** Subscribe to any change in this chat (messages/members/typing/state). */
+  onChange(cb) {
+    this.listeners.add(cb);
+    this.ensureWired();
+    return () => this.listeners.delete(cb);
+  }
+  emit() {
+    for (const cb of this.listeners) cb();
+  }
+  // ── Snapshot getters ──
+  get state() {
+    return this._state;
+  }
+  get isDirect() {
+    return this.kind === "direct";
+  }
+  get messages() {
+    return this.messageList;
+  }
+  get members() {
+    return this.memberCache;
+  }
+  get typing() {
+    return this.typingList;
+  }
+  get lastMessage() {
+    return this.messageList.at(-1) ?? null;
+  }
+  get unreadCount() {
+    return this.messageList.filter(
+      (m) => m.direction === "incoming" && m.serverSeq > this.readWatermark
+    ).length;
+  }
+  get title() {
+    if (this.titleOverride) return this.titleOverride;
+    if (this._group?.name) return this._group.name;
+    if (this._draft) {
+      const mode = this._draft.mode;
+      if (mode.kind === "direct") {
+        const peer = this.memberCache.find((m) => m.userId === mode.peerUserId);
+        return peer?.displayName ?? "Chat";
+      }
+      return "Group";
+    }
+    const tail = this.id.startsWith("grp_") ? this.id.slice(4) : this.id;
+    const short = tail.slice(-4);
+    return short ? `Group ${short}` : "Group";
+  }
+  presence(userId) {
+    return this.presenceStates.get(userId) ?? null;
+  }
+  // ── Wiring (live + history) ──
+  ensureWired() {
+    if (this.wired || this._state !== "active" || !this._group) return;
+    this.wired = true;
+    this.liveUnsub = this.backend.subscribeLive(this._group, this);
+    void this.hydrateHistory();
+    void this.refreshMembers();
+  }
+  async hydrateHistory() {
+    if (this.historyLoaded || !this._group) return;
+    this.historyLoaded = true;
+    const entries = await this.backend.history(this._group, 50);
+    this.mergeHistory(entries);
+  }
+  mergeHistory(incoming) {
+    let changed = false;
+    for (const m of incoming) {
+      if (m.serverSeq <= 0) continue;
+      if (m.clientMsgId && m.text !== null) {
+        this.byClientMsgId.set(m.clientMsgId, {
+          text: m.text,
+          senderUserId: m.senderUserId ?? ""
+        });
+      }
+    }
+    for (const m of incoming) {
+      if (m.serverSeq <= 0) continue;
+      const key = this.internalKey(m.serverSeq);
+      if (this.seenKeys.has(key)) continue;
+      this.seenKeys.add(key);
+      this.messageList.push(m);
+      changed = true;
+      this.loadedEarliestSeq = Math.min(this.loadedEarliestSeq ?? m.serverSeq, m.serverSeq);
+    }
+    if (changed) {
+      this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
+      this.emit();
+    }
+  }
+  /** @internal — called by the backend's live subscription. */
+  async ingestLive(incoming) {
+    if (!this._group) return;
+    if (incoming.kind === "commit") {
+      await this.refreshMembers();
+      return;
+    }
+    if (incoming.serverSeq <= 0) return;
+    const key = this.internalKey(incoming.serverSeq);
+    if (this.seenKeys.has(key)) return;
+    this.seenKeys.add(key);
+    let senderUser = null;
+    if (incoming.senderDeviceId) {
+      senderUser = await this.backend.userIdForDevice(this._group, incoming.senderDeviceId);
+    }
+    const direction = senderUser !== null && senderUser === this.backend.selfUserId ? "outgoing" : "incoming";
+    const incomingClientMsgId = incoming.clientMsgId;
+    const incomingReplyRef = incoming.replyRef;
+    let resolvedReplyTo = null;
+    if (incomingReplyRef) {
+      resolvedReplyTo = resolveReply(incomingReplyRef, (id) => this.byClientMsgId.get(id) ?? null);
+    }
+    const msg = {
+      id: this.publicId(incoming.serverSeq),
+      kind: this.kindOf(incoming),
+      direction,
+      senderUserId: senderUser,
+      text: incoming.text,
+      serverSeq: incoming.serverSeq,
+      sentAt: incoming.receivedAt,
+      clientMsgId: incomingClientMsgId,
+      replyTo: resolvedReplyTo
+    };
+    if (incomingClientMsgId && incoming.text !== null) {
+      this.byClientMsgId.set(incomingClientMsgId, {
+        text: incoming.text,
+        senderUserId: senderUser ?? ""
+      });
+    }
+    this.messageList.push(msg);
+    this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
+    this.loadedEarliestSeq = Math.min(
+      this.loadedEarliestSeq ?? incoming.serverSeq,
+      incoming.serverSeq
+    );
+    this.emit();
+  }
+  /** @internal — called by the backend's conv subscription. */
+  applyConv(event, payload) {
+    const userId = typeof payload.user_id === "string" ? payload.user_id : null;
+    if (!userId || userId === this.backend.selfUserId) return;
+    if (event === "typing") {
+      const isTyping = payload.typing === true;
+      const member = this.memberCache.find((m) => m.userId === userId) ?? {
+        id: userId,
+        userId,
+        displayName: null,
+        role: "member",
+        isSelf: false
+      };
+      this.typingList = isTyping ? [...this.typingList.filter((m) => m.userId !== userId), member] : this.typingList.filter((m) => m.userId !== userId);
+      this.emit();
+    } else if (event === "presence") {
+      const online = payload.online === true;
+      const ts = typeof payload.ts === "number" ? payload.ts : null;
+      this.presenceStates.set(userId, {
+        userId,
+        isOnline: online,
+        lastSeenAt: ts ? new Date(ts * 1e3) : null
+      });
+      this.emit();
+    }
+  }
+  kindOf(incoming) {
+    if (incoming.kind === "commit" || incoming.kind === "proposal" || incoming.kind === "welcome")
+      return "system";
+    return "text";
+  }
+  internalKey(serverSeq) {
+    return this._group ? `${this._group.rfcGroupId}#${serverSeq}` : `draft#${serverSeq}`;
+  }
+  publicId(serverSeq) {
+    return `${this.id}#${serverSeq}`;
+  }
+  /** Page older messages in. Returns how many were prepended. */
+  async loadEarlier(limit = 50) {
+    if (!this._group) return 0;
+    const before = this.loadedEarliestSeq ?? void 0;
+    const older = await this.backend.history(this._group, limit, before);
+    const before0 = this.messageList.length;
+    this.mergeHistory(older);
+    return this.messageList.length - before0;
+  }
+  // ── Members ──
+  async refreshMembers() {
+    if (!this._group) return;
+    const m = await this.backend.members(this._group);
+    if (m.length > 0) {
+      this.memberCache = m;
+      this.emit();
+    }
+  }
+  seedMembersFromGroup(group) {
+    const seed = [
+      {
+        id: this.backend.selfUserId,
+        userId: this.backend.selfUserId,
+        displayName: null,
+        role: "owner",
+        isSelf: true
+      }
+    ];
+    if (group.ownerUserId && group.ownerUserId !== this.backend.selfUserId) {
+      seed.push({
+        id: group.ownerUserId,
+        userId: group.ownerUserId,
+        displayName: null,
+        role: "owner",
+        isSelf: false
+      });
+    }
+    this.memberCache = seed;
+  }
+  seedDraftMembers(draft) {
+    const seed = [
+      {
+        id: this.backend.selfUserId,
+        userId: this.backend.selfUserId,
+        displayName: null,
+        role: draft.mode.kind === "group" ? "owner" : "member",
+        isSelf: true
+      }
+    ];
+    if (draft.mode.kind === "direct") {
+      seed.push({
+        id: draft.mode.peerUserId,
+        userId: draft.mode.peerUserId,
+        displayName: null,
+        role: "member",
+        isSelf: false
+      });
+    } else {
+      for (const uid of draft.mode.members) {
+        seed.push({ id: uid, userId: uid, displayName: null, role: "member", isSelf: false });
+      }
+    }
+    this.memberCache = seed;
+  }
+  // ── Send (with WhatsApp lazy materialize) ──
+  async send(text, opts) {
+    const group = await this.materializeIfNeeded();
+    let replyRef = null;
+    let resolvedReplyTo = null;
+    const parent = opts?.replyTo;
+    if (parent?.clientMsgId && parent.kind !== "system") {
+      const [previewBody, wasTruncated] = parent.text ? truncateQuote(parent.text) : ["", false];
+      replyRef = {
+        v: 1,
+        client_msg_id: parent.clientMsgId,
+        preview: {
+          kind: "text",
+          author_user_id: parent.senderUserId ?? "",
+          body: previewBody || void 0,
+          body_truncated: wasTruncated
+        }
+      };
+      resolvedReplyTo = resolveReply(replyRef, (id) => this.byClientMsgId.get(id) ?? null);
+    }
+    const { receipt, clientMsgId } = await this.backend.sendText(group, text, replyRef);
+    this.appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo);
+    return receipt;
+  }
+  appendOwnSend(text, receipt, clientMsgId, resolvedReplyTo) {
+    if (receipt.serverSeq <= 0) return;
+    const key = this.internalKey(receipt.serverSeq);
+    if (this.seenKeys.has(key)) return;
+    this.seenKeys.add(key);
+    if (clientMsgId) {
+      this.byClientMsgId.set(clientMsgId, { text, senderUserId: this.backend.selfUserId });
+    }
+    this.messageList.push({
+      id: this.publicId(receipt.serverSeq),
+      kind: "text",
+      direction: "outgoing",
+      senderUserId: this.backend.selfUserId,
+      text,
+      serverSeq: receipt.serverSeq,
+      sentAt: /* @__PURE__ */ new Date(),
+      clientMsgId,
+      replyTo: resolvedReplyTo
+    });
+    this.messageList.sort((a, b) => a.serverSeq - b.serverSeq);
+    this.emit();
+  }
+  async materializeIfNeeded() {
+    if (this._group) return this._group;
+    if (!this._draft) throw new Error("messaging_not_configured");
+    const group = await this.backend.materialize(this._draft);
+    this._group = group;
+    this.id = group.displayId;
+    this._state = "active";
+    this._draft = null;
+    this.backend.registerActive(group);
+    this.ensureWired();
+    this.emit();
+    return group;
+  }
+  // ── Membership (groups only) ──
+  async addMemberUser(userId) {
+    if (this.kind !== "group") throw new Error("chat_is_direct");
+    const group = await this.materializeIfNeeded();
+    await this.backend.addMember(group, userId);
+    await this.refreshMembers();
+  }
+  async removeMemberUser(userId) {
+    if (this.kind !== "group") throw new Error("chat_is_direct");
+    if (!this._group) throw new Error("messaging_not_configured");
+    await this.backend.removeMember(this._group, userId);
+    await this.refreshMembers();
+  }
+  async leave() {
+    if (!this._group) return;
+    await this.backend.leave(this._group);
+    this.liveUnsub?.();
+    this.liveUnsub = null;
+  }
+  // ── Imperative ──
+  setTyping(isTyping) {
+    if (this._group) this.backend.setTyping(this._group, isTyping);
+  }
+  async markRead(message) {
+    if (!this._group) return;
+    await this.backend.markRead(this._group, message.serverSeq);
+    this.readWatermark = Math.max(this.readWatermark, message.serverSeq);
+    this.emit();
+  }
+};
+
+// src/messaging/delivery-source.ts
+var MessageHub = class {
+  messageListeners = /* @__PURE__ */ new Map();
+  convListeners = /* @__PURE__ */ new Map();
+  onMessage(displayId, fn) {
+    return this.add(this.messageListeners, displayId, fn);
+  }
+  emitMessage(displayId, m) {
+    for (const fn of this.messageListeners.get(displayId) ?? []) fn(m);
+  }
+  onConv(displayId, fn) {
+    return this.add(this.convListeners, displayId, fn);
+  }
+  emitConv(displayId, e) {
+    for (const fn of this.convListeners.get(displayId) ?? []) fn(e);
+  }
+  add(map, key, fn) {
+    let set = map.get(key);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      map.set(key, set);
+    }
+    set.add(fn);
+    return () => {
+      set?.delete(fn);
+    };
+  }
+};
+var MessageDeliverySource = class {
+  constructor(rt, engine, hub, registry, messageStore, deviceId, selfUserId) {
+    this.rt = rt;
+    this.engine = engine;
+    this.hub = hub;
+    this.registry = registry;
+    this.messageStore = messageStore;
+    this.deviceId = deviceId;
+    this.selfUserId = selfUserId;
+  }
+  rt;
+  engine;
+  hub;
+  registry;
+  messageStore;
+  deviceId;
+  selfUserId;
+  started = false;
+  wakeUnsub = null;
+  // Per-observed-group conv subscription + heartbeat (presence/typing/read).
+  observed = /* @__PURE__ */ new Map();
+  /** Subscribe the device wake topic + run an initial drain. Idempotent. */
+  async start() {
+    if (this.started) return;
+    this.started = true;
+    try {
+      const channel = this.rt.realtime.channel(`messaging:device:${this.deviceId}`);
+      const sub = channel.on("new_message", () => {
+        void this.pumpOnce();
+      });
+      const offConn = this.rt.realtime.status.onChange((s) => {
+        if (s.state === "connected") void this.pumpOnce();
+      });
+      this.wakeUnsub = () => {
+        sub.cancel();
+        offConn();
+      };
+    } catch {
+    }
+    await this.pumpOnce();
+  }
+  stop() {
+    this.wakeUnsub?.();
+    this.wakeUnsub = null;
+    for (const [, o] of this.observed) {
+      o.unsub();
+      if (o.heartbeat) clearInterval(o.heartbeat);
+    }
+    this.observed.clear();
+    this.started = false;
+  }
+  /** One full drain: welcomes → queue (decrypt + emit) → ack. Never throws. */
+  async pumpOnce() {
+    try {
+      await this.pullWelcomes();
+    } catch {
+    }
+    try {
+      await this.pullQueue();
+    } catch {
+    }
+  }
+  // ── Welcomes ──
+  async pullWelcomes() {
+    const page = await palbeRequest(
+      this.rt,
+      "GET",
+      MessagingPaths.deviceWelcomes(this.deviceId)
+    );
+    for (const w of page.welcomes) {
+      try {
+        const gidBytes = await this.engine.joinFromWelcome(fromBase64(w.welcome_b64));
+        const group = {
+          displayId: w.display_id,
+          rfcGroupId: toBase64(gidBytes),
+          currentEpoch: w.added_at_epoch,
+          ownerUserId: null,
+          directKey: null,
+          name: null
+        };
+        this.registry.register(group);
+        this.hub.emitMessage(group.displayId, {
+          kind: "welcome",
+          group,
+          text: null,
+          senderDeviceId: null,
+          epoch: w.added_at_epoch,
+          serverSeq: 0,
+          receivedAt: /* @__PURE__ */ new Date(),
+          clientMsgId: "",
+          replyRef: null
+        });
+      } catch {
+        const known = this.registry.all().some((g) => g.displayId === w.display_id);
+        if (!known) {
+        }
+      }
+    }
+  }
+  // ── Queue ──
+  async pullQueue() {
+    const page = await palbeRequest(
+      this.rt,
+      "GET",
+      MessagingPaths.deviceQueue(this.deviceId)
+    );
+    const ackIds = [];
+    for (const row of page.messages) {
+      if (await this.process(row)) ackIds.push(row.id);
+    }
+    if (ackIds.length > 0) {
+      await palbeRequest(this.rt, "POST", MessagingPaths.deviceQueueAck(this.deviceId), {
+        body: { message_ids: ackIds }
+      });
+    }
+  }
+  /** Process one queue row; returns true if consumed (should ack). */
+  async process(row) {
+    let blob;
+    try {
+      blob = fromBase64(row.ciphertext_b64);
+    } catch {
+      return true;
+    }
+    const group = (row.rfc_group_id_b64 ? this.registry.group(row.rfc_group_id_b64) : void 0) ?? this.registry.soleGroup();
+    if (!group) return false;
+    try {
+      const received = await this.engine.processIncoming(fromBase64(group.rfcGroupId), blob);
+      if (received.type === "application") {
+        const { text, clientMsgId, replyTo } = decodeEnvelope(received.data);
+        const stored = {
+          id: `${group.rfcGroupId}#${row.server_seq}`,
+          direction: "incoming",
+          text,
+          senderDeviceId: row.sender_device_id ?? null,
+          epoch: row.epoch,
+          serverSeq: row.server_seq,
+          at: Date.now(),
+          clientMsgId: clientMsgId || void 0,
+          replyTo: replyTo ? {
+            clientMsgId: replyTo.client_msg_id,
+            previewBody: replyTo.preview?.body ?? null,
+            previewAuthorUserId: replyTo.preview?.author_user_id ?? null,
+            previewKind: replyTo.preview?.kind ?? "text"
+          } : null
+        };
+        try {
+          await this.messageStore.append(group.rfcGroupId, stored);
+        } catch {
+          return false;
+        }
+        this.hub.emitMessage(group.displayId, {
+          kind: "application",
+          group,
+          text,
+          senderDeviceId: row.sender_device_id ?? null,
+          epoch: row.epoch,
+          serverSeq: row.server_seq,
+          receivedAt: /* @__PURE__ */ new Date(),
+          clientMsgId,
+          replyRef: replyTo
+        });
+        return true;
+      }
+      if (received.type === "commitApplied") {
+        const newEpoch = Math.max(row.epoch, group.currentEpoch + 1);
+        this.registry.bumpEpoch(group.rfcGroupId, newEpoch);
+        const fresh = this.registry.group(group.rfcGroupId) ?? group;
+        this.hub.emitMessage(group.displayId, {
+          kind: "commit",
+          group: fresh,
+          text: null,
+          senderDeviceId: row.sender_device_id ?? null,
+          epoch: newEpoch,
+          serverSeq: 0,
+          receivedAt: /* @__PURE__ */ new Date(),
+          clientMsgId: "",
+          replyRef: null
+        });
+        return true;
+      }
+      return true;
+    } catch (e) {
+      if (isOwnEchoOrConsumed(e)) return true;
+      return false;
+    }
+  }
+  // ── Conv topic (presence / typing / read) ──
+  /** Begin observing a group's conv topic; fans events into the hub. Idempotent. */
+  observeConversation(group) {
+    if (this.observed.has(group.displayId)) return;
+    try {
+      const channel = this.rt.realtime.channel(`messaging:conv:${group.rfcGroupId}`);
+      const subs = ["presence", "typing", "read"].map(
+        (ev) => channel.on(ev, (payload) => {
+          this.hub.emitConv(group.displayId, { event: ev, payload });
+        })
+      );
+      const emitPresence = (online) => channel.send("presence", {
+        user_id: this.selfUserId,
+        device_id: this.deviceId,
+        online,
+        ts: Date.now() / 1e3
+      });
+      emitPresence(true);
+      const heartbeat = setInterval(() => emitPresence(true), 25e3);
+      this.observed.set(group.displayId, {
+        unsub: () => {
+          for (const s of subs) s.cancel();
+        },
+        heartbeat
+      });
+    } catch {
+    }
+  }
+  /** Announce typing on a group's conv topic (the app calls per keystroke). */
+  setTyping(group, isTyping) {
+    this.observeConversation(group);
+    try {
+      this.rt.realtime.channel(`messaging:conv:${group.rfcGroupId}`).send("typing", {
+        user_id: this.selfUserId,
+        device_id: this.deviceId,
+        typing: isTyping
+      });
+    } catch {
+    }
+  }
+  /** Advance this device's read cursor (idempotent; the server clamps). */
+  async markRead(group, upToServerSeq) {
+    await palbeRequest(this.rt, "POST", MessagingPaths.groupRead(group.displayId), {
+      body: { read_seq: upToServerSeq, read_epoch: group.currentEpoch, is_private: false }
+    });
+  }
+};
+function isOwnEchoOrConsumed(e) {
+  const msg = e instanceof Error ? e.message : String(e);
+  return msg.includes("message from self") || msg.includes("key not available, invalid generation");
+}
+
+// src/messaging/history.ts
+var MessageStore = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  key(rfcGroupId) {
+    return `msgs:${rfcGroupId}`;
+  }
+  /** Append (idempotent on id) and persist the group's transcript. */
+  async append(rfcGroupId, msg) {
+    const list = await this.load(rfcGroupId);
+    if (list.some((m) => m.id === msg.id)) return;
+    list.push(msg);
+    list.sort((a, b) => a.serverSeq - b.serverSeq);
+    await this.save(rfcGroupId, list);
+  }
+  /** True if a message id is already durable (the consumed-key recovery check). */
+  async contains(rfcGroupId, id) {
+    const list = await this.load(rfcGroupId);
+    return list.some((m) => m.id === id);
+  }
+  /**
+   * Read history for a group, newest-last. `before` pages older: returns up to
+   * `limit` rows with serverSeq < before. nil `before` returns the newest page.
+   */
+  async history(rfcGroupId, limit, before) {
+    const list = await this.load(rfcGroupId);
+    const filtered = before == null ? list : list.filter((m) => m.serverSeq < before);
+    return filtered.slice(Math.max(0, filtered.length - limit));
+  }
+  async load(rfcGroupId) {
+    const raw = await this.kv.get(this.key(rfcGroupId));
+    if (!raw) return [];
+    try {
+      return JSON.parse(decodeUtf8(raw));
+    } catch {
+      return [];
+    }
+  }
+  async save(rfcGroupId, list) {
+    await this.kv.set(this.key(rfcGroupId), encodeUtf8(JSON.stringify(list)));
+  }
+  async wipe() {
+    for (const k of await this.kv.keys("msgs:")) await this.kv.delete(k);
+  }
+};
+var GroupCatalog = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  async upsert(g) {
+    await this.kv.set(`cat:${g.rfcGroupId}`, encodeUtf8(JSON.stringify(g)));
+  }
+  async remove(rfcGroupId) {
+    await this.kv.delete(`cat:${rfcGroupId}`);
+  }
+  async all() {
+    const keys = await this.kv.keys("cat:");
+    const out = [];
+    for (const k of keys) {
+      const raw = await this.kv.get(k);
+      if (!raw) continue;
+      try {
+        out.push(JSON.parse(decodeUtf8(raw)));
+      } catch {
+      }
+    }
+    return out;
+  }
+  async wipe() {
+    for (const k of await this.kv.keys("cat:")) await this.kv.delete(k);
+  }
+};
+
+// src/messaging/wasm/pkg/palbe_mls_bg.js
+var palbe_mls_bg_exports = {};
+__export(palbe_mls_bg_exports, {
+  MlsClient: () => MlsClient,
+  MlsGroup: () => MlsGroup,
+  __wbg_BigInt_231999d28f899902: () => __wbg_BigInt_231999d28f899902,
+  __wbg_Error_fdd633d4bb5dd76a: () => __wbg_Error_fdd633d4bb5dd76a,
+  __wbg_String_8564e559799eccda: () => __wbg_String_8564e559799eccda,
+  __wbg___wbindgen_bigint_get_as_i64_d9e915702856f831: () => __wbg___wbindgen_bigint_get_as_i64_d9e915702856f831,
+  __wbg___wbindgen_debug_string_8a447059637473e2: () => __wbg___wbindgen_debug_string_8a447059637473e2,
+  __wbg___wbindgen_is_function_acc5528be2b923f2: () => __wbg___wbindgen_is_function_acc5528be2b923f2,
+  __wbg___wbindgen_is_null_6d937fbfb6478470: () => __wbg___wbindgen_is_null_6d937fbfb6478470,
+  __wbg___wbindgen_is_object_0beba4a1980d3eea: () => __wbg___wbindgen_is_object_0beba4a1980d3eea,
+  __wbg___wbindgen_is_string_1fca8072260dd261: () => __wbg___wbindgen_is_string_1fca8072260dd261,
+  __wbg___wbindgen_is_undefined_721f8decd50c87a3: () => __wbg___wbindgen_is_undefined_721f8decd50c87a3,
+  __wbg___wbindgen_jsval_eq_4e8c38722cb8ff51: () => __wbg___wbindgen_jsval_eq_4e8c38722cb8ff51,
+  __wbg___wbindgen_memory_9751d9a3017e7c25: () => __wbg___wbindgen_memory_9751d9a3017e7c25,
+  __wbg___wbindgen_number_get_1cc01dd708740256: () => __wbg___wbindgen_number_get_1cc01dd708740256,
+  __wbg___wbindgen_string_get_71bb4348194e31f0: () => __wbg___wbindgen_string_get_71bb4348194e31f0,
+  __wbg___wbindgen_throw_ea4887a5f8f9a9db: () => __wbg___wbindgen_throw_ea4887a5f8f9a9db,
+  __wbg_buffer_7447b9cc2267a9e5: () => __wbg_buffer_7447b9cc2267a9e5,
+  __wbg_call_67f43c91d09298f2: () => __wbg_call_67f43c91d09298f2,
+  __wbg_call_b51415974987aa44: () => __wbg_call_b51415974987aa44,
+  __wbg_crypto_38df2bab126b63dc: () => __wbg_crypto_38df2bab126b63dc,
+  __wbg_delete_21fafcbc7bb82c85: () => __wbg_delete_21fafcbc7bb82c85,
+  __wbg_epoch_15c000ffe3004541: () => __wbg_epoch_15c000ffe3004541,
+  __wbg_error_a6fa202b58aa1cd3: () => __wbg_error_a6fa202b58aa1cd3,
+  __wbg_getRandomValues_c44a50d8cfdaebeb: () => __wbg_getRandomValues_c44a50d8cfdaebeb,
+  __wbg_get_615446055a48103f: () => __wbg_get_615446055a48103f,
+  __wbg_globalThis_6d268067835e6709: () => __wbg_globalThis_6d268067835e6709,
+  __wbg_global_3fe6c6c8ad6e6fb2: () => __wbg_global_3fe6c6c8ad6e6fb2,
+  __wbg_insert_2d611f2bf9b60fee: () => __wbg_insert_2d611f2bf9b60fee,
+  __wbg_instanceof_Error_38f854307ecab4ce: () => __wbg_instanceof_Error_38f854307ecab4ce,
+  __wbg_length_c552db98817b9523: () => __wbg_length_c552db98817b9523,
+  __wbg_maxEpochId_0b176768b2f352fb: () => __wbg_maxEpochId_0b176768b2f352fb,
+  __wbg_message_a05fcf872473ffc5: () => __wbg_message_a05fcf872473ffc5,
+  __wbg_msCrypto_bd5a034af96bcba6: () => __wbg_msCrypto_bd5a034af96bcba6,
+  __wbg_new_227d7c05414eb861: () => __wbg_new_227d7c05414eb861,
+  __wbg_new_32de5cbf49ca7dcb: () => __wbg_new_32de5cbf49ca7dcb,
+  __wbg_new_364c96143b8f3496: () => __wbg_new_364c96143b8f3496,
+  __wbg_new_b8b71ca8104fc178: () => __wbg_new_b8b71ca8104fc178,
+  __wbg_new_d9762fd75876aafe: () => __wbg_new_d9762fd75876aafe,
+  __wbg_new_no_args_4010ad257320fa4f: () => __wbg_new_no_args_4010ad257320fa4f,
+  __wbg_new_with_byte_offset_and_length_8b21e3b1308deb48: () => __wbg_new_with_byte_offset_and_length_8b21e3b1308deb48,
+  __wbg_new_with_length_5fdafe029be917a5: () => __wbg_new_with_length_5fdafe029be917a5,
+  __wbg_node_84ea875411254db1: () => __wbg_node_84ea875411254db1,
+  __wbg_process_44c7a14e11e9f69e: () => __wbg_process_44c7a14e11e9f69e,
+  __wbg_push_1303ce035391aed3: () => __wbg_push_1303ce035391aed3,
+  __wbg_randomFillSync_6c25eac9869eb53c: () => __wbg_randomFillSync_6c25eac9869eb53c,
+  __wbg_require_b4edbdcf3e2a1ef0: () => __wbg_require_b4edbdcf3e2a1ef0,
+  __wbg_self_1035a7cbd1b0d959: () => __wbg_self_1035a7cbd1b0d959,
+  __wbg_set_047d1ea37bb67c19: () => __wbg_set_047d1ea37bb67c19,
+  __wbg_set_1ddc4b8cd44d0da4: () => __wbg_set_1ddc4b8cd44d0da4,
+  __wbg_set_28cba565792ec75f: () => __wbg_set_28cba565792ec75f,
+  __wbg_set_6be42768c690e380: () => __wbg_set_6be42768c690e380,
+  __wbg_set_name_b4c29a3a72ebbddc: () => __wbg_set_name_b4c29a3a72ebbddc,
+  __wbg_set_wasm: () => __wbg_set_wasm,
+  __wbg_stack_3b0d974bbf31e44f: () => __wbg_stack_3b0d974bbf31e44f,
+  __wbg_state_bd20456c0f3efbc9: () => __wbg_state_bd20456c0f3efbc9,
+  __wbg_subarray_e0162dcdea48eb3a: () => __wbg_subarray_e0162dcdea48eb3a,
+  __wbg_versions_276b2795b1c6a219: () => __wbg_versions_276b2795b1c6a219,
+  __wbg_window_9c17850b5e99c0ab: () => __wbg_window_9c17850b5e99c0ab,
+  __wbg_write_56b1cf5bb0e780d6: () => __wbg_write_56b1cf5bb0e780d6,
+  __wbindgen_cast_0000000000000001: () => __wbindgen_cast_0000000000000001,
+  __wbindgen_cast_0000000000000002: () => __wbindgen_cast_0000000000000002,
+  __wbindgen_cast_0000000000000003: () => __wbindgen_cast_0000000000000003,
+  __wbindgen_init_externref_table: () => __wbindgen_init_externref_table,
+  generateClient: () => generateClient,
+  setPanicHook: () => setPanicHook
+});
+var MlsClient = class _MlsClient {
+  static __wrap(ptr) {
+    const obj = Object.create(_MlsClient.prototype);
+    obj.__wbg_ptr = ptr;
+    MlsClientFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MlsClientFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_mlsclient_free(ptr, 0);
+  }
+  /**
+   * The MLS Capabilities wire bytes (the keydir's `capabilities`).
+   * @returns {Uint8Array}
+   */
+  capabilities() {
+    const ret = wasm.mlsclient_capabilities(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Create a new group at epoch 0. `groupId` `undefined`/`null` lets mls-rs
+   * mint a globally-unique id (the rfc_group_id routing key).
+   * @param {Uint8Array | null} [group_id]
+   * @returns {MlsGroup}
+   */
+  createGroup(group_id) {
+    var ptr0 = isLikeNone(group_id) ? 0 : passArray8ToWasm0(group_id, wasm.__wbindgen_malloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsclient_createGroup(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return MlsGroup.__wrap(ret[0]);
+  }
+  /**
+   * The MLS Credential wire bytes (the keydir's `credential`).
+   * @returns {Uint8Array}
+   */
+  credential() {
+    const ret = wasm.mlsclient_credential(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * The MLS-encoded enrollment material `{ signatureKey, credential,
+   * capabilities }` (byte fields as arrays-of-numbers — wrap in Uint8Array as
+   * needed). Base64 these into the SP-0 keydir enroll body.
+   * @returns {any}
+   */
+  enrollmentMaterial() {
+    const ret = wasm.mlsclient_enrollmentMaterial(this.__wbg_ptr);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Mint a one-use KeyPackage (RAW RFC 9420 §10 bytes) — uploaded to the
+   * keydir, consumed by an adder's `addMember`.
+   * @returns {Uint8Array}
+   */
+  generateKeyPackage() {
+    const ret = wasm.mlsclient_generateKeyPackage(this.__wbg_ptr);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * Join a group from a Welcome (opaque MLSMessage bytes).
+   * @param {Uint8Array} welcome
+   * @returns {MlsGroup}
+   */
+  joinGroup(welcome) {
+    const ptr0 = passArray8ToWasm0(welcome, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsclient_joinGroup(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return MlsGroup.__wrap(ret[0]);
+  }
+  /**
+   * Re-hydrate a previously-persisted group by its `groupId` (restart-safe
+   * reload of an already-joined group).
+   * @param {Uint8Array} group_id
+   * @returns {MlsGroup}
+   */
+  loadGroup(group_id) {
+    const ptr0 = passArray8ToWasm0(group_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsclient_loadGroup(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return MlsGroup.__wrap(ret[0]);
+  }
+  /**
+   * The serialized STABLE signature keypair (secret-bearing). Persist sealed
+   * and pass back as `signatureKeypair` on restart so the device keeps the
+   * SAME MLS signing identity.
+   * @returns {Uint8Array}
+   */
+  signatureKeypair() {
+    const ret = wasm.mlsclient_signatureKeypair(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * The device's STABLE signature PUBLIC key bytes (the keydir's
+   * `signature_key`).
+   * @returns {Uint8Array}
+   */
+  signaturePublicKey() {
+    const ret = wasm.mlsclient_signaturePublicKey(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+};
+if (Symbol.dispose) MlsClient.prototype[Symbol.dispose] = MlsClient.prototype.free;
+var MlsGroup = class _MlsGroup {
+  static __wrap(ptr) {
+    const obj = Object.create(_MlsGroup.prototype);
+    obj.__wbg_ptr = ptr;
+    MlsGroupFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    MlsGroupFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_mlsgroup_free(ptr, 0);
+  }
+  /**
+   * Stage a member add. Returns `{ commit, welcome?, addedLeafIndices }`
+   * (byte fields as arrays-of-numbers). The group is PENDING after this.
+   * @param {Uint8Array} key_package_msg
+   * @returns {any}
+   */
+  addMember(key_package_msg) {
+    const ptr0 = passArray8ToWasm0(key_package_msg, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_addMember(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Apply the staged commit (advances the local epoch). Call ONLY after the
+   * server accepted the commit.
+   */
+  applyPendingCommit() {
+    const ret = wasm.mlsgroup_applyPendingCommit(this.__wbg_ptr);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Discard the staged commit without advancing (the 409-rebase path).
+   */
+  clearPendingCommit() {
+    wasm.mlsgroup_clearPendingCommit(this.__wbg_ptr);
+  }
+  /**
+   * Stage a SINGLE atomic add+remove commit. `addKeyPackages` is an
+   * `Array<Uint8Array>` of one-use key packages; `removeMemberIds` an
+   * `Array<Uint8Array>` of member identity bytes. Returns the same
+   * `AddResult` shape as `addMember`. PENDING after this.
+   * @param {Uint8Array[]} add_key_packages
+   * @param {Uint8Array[]} remove_member_ids
+   * @returns {any}
+   */
+  commitChanges(add_key_packages, remove_member_ids) {
+    const ptr0 = passArrayJsValueToWasm0(add_key_packages, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayJsValueToWasm0(remove_member_ids, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_commitChanges(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * The current (applied) epoch as a JS BigInt (u64 exceeds safe-integer).
+   * @returns {bigint}
+   */
+  currentEpoch() {
+    const ret = wasm.mlsgroup_currentEpoch(this.__wbg_ptr);
+    return BigInt.asUintN(64, ret);
+  }
+  /**
+   * Inspect an incoming Commit and return the membership delta it WOULD
+   * effect WITHOUT applying it (the reconciliation gate's crypto-truth).
+   * Returns `{ kind, addedIdentities, removedIdentities }`.
+   * @param {Uint8Array} commit_msg
+   * @returns {any}
+   */
+  describeIncomingCommit(commit_msg) {
+    const ptr0 = passArray8ToWasm0(commit_msg, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_describeIncomingCommit(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Encrypt an application message at the current epoch. Returns the opaque
+   * MLSMessage bytes (PrivateMessage).
+   * @param {Uint8Array} plaintext
+   * @returns {Uint8Array}
+   */
+  encryptApplicationMessage(plaintext) {
+    const ptr0 = passArray8ToWasm0(plaintext, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_encryptApplicationMessage(this.__wbg_ptr, ptr0, len0);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+  }
+  /**
+   * Derive the group's current-epoch exporter secret (RFC 9420 §8.5) — the SAME
+   * engine call iOS uses (uniffi `exportSecret`), so a cross-platform call/group
+   * derives a byte-identical key. The SP-4 web call sets this as the LiveKit
+   * frame key (server + SFU stay blind); also group-name/media sealing.
+   * @param {Uint8Array} label
+   * @param {Uint8Array} context
+   * @param {bigint} len
+   * @returns {Uint8Array}
+   */
+  exportSecret(label, context, len) {
+    const ptr0 = passArray8ToWasm0(label, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArray8ToWasm0(context, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_exportSecret(this.__wbg_ptr, ptr0, len0, ptr1, len1, len);
+    if (ret[3]) {
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    var v3 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v3;
+  }
+  /**
+   * The MLS group id (the rfc_group_id routing key / storage key).
+   * @returns {Uint8Array}
+   */
+  groupId() {
+    const ret = wasm.mlsgroup_groupId(this.__wbg_ptr);
+    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v1;
+  }
+  /**
+   * True while a staged (unapplied) commit exists.
+   * @returns {boolean}
+   */
+  hasPendingCommit() {
+    const ret = wasm.mlsgroup_hasPendingCommit(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * Process an incoming MLSMessage and apply its effect. Returns a
+   * `ReceivedMessage` plain object (serde-tagged enum): e.g.
+   * `{ Application: { sender, data } }`, `{ CommitApplied: { epoch,
+   * removedSelf } }`, `"Proposal"`, or `"Other"`.
+   * @param {Uint8Array} message
+   * @returns {any}
+   */
+  processIncomingMessage(message) {
+    const ptr0 = passArray8ToWasm0(message, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_processIncomingMessage(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Stage a member remove (by the member's identity bytes). Returns
+   * `{ commit }`. PENDING after this.
+   * @param {Uint8Array} member_id
+   * @returns {any}
+   */
+  removeMember(member_id) {
+    const ptr0 = passArray8ToWasm0(member_id, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.mlsgroup_removeMember(this.__wbg_ptr, ptr0, len0);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+  }
+  /**
+   * Persist the current group state through the JS group storage callback.
+   */
+  writeToStorage() {
+    const ret = wasm.mlsgroup_writeToStorage(this.__wbg_ptr);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+};
+if (Symbol.dispose) MlsGroup.prototype[Symbol.dispose] = MlsGroup.prototype.free;
+function generateClient(id, group_storage, key_package_storage, signature_keypair) {
+  const ptr0 = passArray8ToWasm0(id, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  var ptr1 = isLikeNone(signature_keypair) ? 0 : passArray8ToWasm0(signature_keypair, wasm.__wbindgen_malloc);
+  var len1 = WASM_VECTOR_LEN;
+  const ret = wasm.generateClient(ptr0, len0, group_storage, key_package_storage, ptr1, len1);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return MlsClient.__wrap(ret[0]);
+}
+function setPanicHook() {
+  wasm.setPanicHook();
+}
+function __wbg_BigInt_231999d28f899902() {
+  return handleError(function(arg0) {
+    const ret = BigInt(arg0);
+    return ret;
+  }, arguments);
+}
+function __wbg_Error_fdd633d4bb5dd76a(arg0, arg1) {
+  const ret = Error(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+function __wbg_String_8564e559799eccda(arg0, arg1) {
+  const ret = String(arg1);
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+function __wbg___wbindgen_bigint_get_as_i64_d9e915702856f831(arg0, arg1) {
+  const v = arg1;
+  const ret = typeof v === "bigint" ? v : void 0;
+  getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+function __wbg___wbindgen_debug_string_8a447059637473e2(arg0, arg1) {
+  const ret = debugString(arg1);
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+function __wbg___wbindgen_is_function_acc5528be2b923f2(arg0) {
+  const ret = typeof arg0 === "function";
+  return ret;
+}
+function __wbg___wbindgen_is_null_6d937fbfb6478470(arg0) {
+  const ret = arg0 === null;
+  return ret;
+}
+function __wbg___wbindgen_is_object_0beba4a1980d3eea(arg0) {
+  const val = arg0;
+  const ret = typeof val === "object" && val !== null;
+  return ret;
+}
+function __wbg___wbindgen_is_string_1fca8072260dd261(arg0) {
+  const ret = typeof arg0 === "string";
+  return ret;
+}
+function __wbg___wbindgen_is_undefined_721f8decd50c87a3(arg0) {
+  const ret = arg0 === void 0;
+  return ret;
+}
+function __wbg___wbindgen_jsval_eq_4e8c38722cb8ff51(arg0, arg1) {
+  const ret = arg0 === arg1;
+  return ret;
+}
+function __wbg___wbindgen_memory_9751d9a3017e7c25() {
+  const ret = wasm.memory;
+  return ret;
+}
+function __wbg___wbindgen_number_get_1cc01dd708740256(arg0, arg1) {
+  const obj = arg1;
+  const ret = typeof obj === "number" ? obj : void 0;
+  getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+}
+function __wbg___wbindgen_string_get_71bb4348194e31f0(arg0, arg1) {
+  const obj = arg1;
+  const ret = typeof obj === "string" ? obj : void 0;
+  var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  var len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+function __wbg___wbindgen_throw_ea4887a5f8f9a9db(arg0, arg1) {
+  throw new Error(getStringFromWasm0(arg0, arg1));
+}
+function __wbg_buffer_7447b9cc2267a9e5(arg0) {
+  const ret = arg0.buffer;
+  return ret;
+}
+function __wbg_call_67f43c91d09298f2() {
+  return handleError(function(arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+  }, arguments);
+}
+function __wbg_call_b51415974987aa44() {
+  return handleError(function(arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+  }, arguments);
+}
+function __wbg_crypto_38df2bab126b63dc(arg0) {
+  const ret = arg0.crypto;
+  return ret;
+}
+function __wbg_delete_21fafcbc7bb82c85() {
+  return handleError(function(arg0, arg1) {
+    arg0.delete(arg1);
+  }, arguments);
+}
+function __wbg_epoch_15c000ffe3004541() {
+  return handleError(function(arg0, arg1, arg2) {
+    const ret = arg0.epoch(arg1, BigInt.asUintN(64, arg2));
+    return ret;
+  }, arguments);
+}
+function __wbg_error_a6fa202b58aa1cd3(arg0, arg1) {
+  let deferred0_0;
+  let deferred0_1;
+  try {
+    deferred0_0 = arg0;
+    deferred0_1 = arg1;
+    console.error(getStringFromWasm0(arg0, arg1));
+  } finally {
+    wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+  }
+}
+function __wbg_getRandomValues_c44a50d8cfdaebeb() {
+  return handleError(function(arg0, arg1) {
+    arg0.getRandomValues(arg1);
+  }, arguments);
+}
+function __wbg_get_615446055a48103f() {
+  return handleError(function(arg0, arg1) {
+    const ret = arg0.get(arg1);
+    return ret;
+  }, arguments);
+}
+function __wbg_globalThis_6d268067835e6709() {
+  return handleError(function() {
+    const ret = globalThis.globalThis;
+    return ret;
+  }, arguments);
+}
+function __wbg_global_3fe6c6c8ad6e6fb2() {
+  return handleError(function() {
+    const ret = global.global;
+    return ret;
+  }, arguments);
+}
+function __wbg_insert_2d611f2bf9b60fee() {
+  return handleError(function(arg0, arg1, arg2) {
+    arg0.insert(arg1, arg2);
+  }, arguments);
+}
+function __wbg_instanceof_Error_38f854307ecab4ce(arg0) {
+  let result;
+  try {
+    result = arg0 instanceof Error;
+  } catch (_) {
+    result = false;
+  }
+  const ret = result;
+  return ret;
+}
+function __wbg_length_c552db98817b9523(arg0) {
+  const ret = arg0.length;
+  return ret;
+}
+function __wbg_maxEpochId_0b176768b2f352fb() {
+  return handleError(function(arg0, arg1) {
+    const ret = arg0.maxEpochId(arg1);
+    return ret;
+  }, arguments);
+}
+function __wbg_message_a05fcf872473ffc5(arg0) {
+  const ret = arg0.message;
+  return ret;
+}
+function __wbg_msCrypto_bd5a034af96bcba6(arg0) {
+  const ret = arg0.msCrypto;
+  return ret;
+}
+function __wbg_new_227d7c05414eb861() {
+  const ret = new Error();
+  return ret;
+}
+function __wbg_new_32de5cbf49ca7dcb(arg0) {
+  const ret = new Uint8Array(arg0);
+  return ret;
+}
+function __wbg_new_364c96143b8f3496() {
+  const ret = new Object();
+  return ret;
+}
+function __wbg_new_b8b71ca8104fc178(arg0, arg1) {
+  const ret = new Error(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+function __wbg_new_d9762fd75876aafe() {
+  const ret = new Array();
+  return ret;
+}
+function __wbg_new_no_args_4010ad257320fa4f(arg0, arg1) {
+  const ret = new Function(getStringFromWasm0(arg0, arg1));
+  return ret;
+}
+function __wbg_new_with_byte_offset_and_length_8b21e3b1308deb48(arg0, arg1, arg2) {
+  const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+  return ret;
+}
+function __wbg_new_with_length_5fdafe029be917a5(arg0) {
+  const ret = new Uint8Array(arg0 >>> 0);
+  return ret;
+}
+function __wbg_node_84ea875411254db1(arg0) {
+  const ret = arg0.node;
+  return ret;
+}
+function __wbg_process_44c7a14e11e9f69e(arg0) {
+  const ret = arg0.process;
+  return ret;
+}
+function __wbg_push_1303ce035391aed3(arg0, arg1) {
+  const ret = arg0.push(arg1);
+  return ret;
+}
+function __wbg_randomFillSync_6c25eac9869eb53c() {
+  return handleError(function(arg0, arg1) {
+    arg0.randomFillSync(arg1);
+  }, arguments);
+}
+function __wbg_require_b4edbdcf3e2a1ef0() {
+  return handleError(function() {
+    const ret = module.require;
+    return ret;
+  }, arguments);
+}
+function __wbg_self_1035a7cbd1b0d959() {
+  return handleError(function() {
+    const ret = self.self;
+    return ret;
+  }, arguments);
+}
+function __wbg_set_047d1ea37bb67c19(arg0, arg1, arg2) {
+  arg0.set(arg1, arg2 >>> 0);
+}
+function __wbg_set_1ddc4b8cd44d0da4() {
+  return handleError(function(arg0, arg1, arg2) {
+    const ret = Reflect.set(arg0, arg1, arg2);
+    return ret;
+  }, arguments);
+}
+function __wbg_set_28cba565792ec75f(arg0, arg1, arg2) {
+  arg0[arg1 >>> 0] = arg2;
+}
+function __wbg_set_6be42768c690e380(arg0, arg1, arg2) {
+  arg0[arg1] = arg2;
+}
+function __wbg_set_name_b4c29a3a72ebbddc(arg0, arg1, arg2) {
+  arg0.name = getStringFromWasm0(arg1, arg2);
+}
+function __wbg_stack_3b0d974bbf31e44f(arg0, arg1) {
+  const ret = arg1.stack;
+  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+  getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+}
+function __wbg_state_bd20456c0f3efbc9() {
+  return handleError(function(arg0, arg1) {
+    const ret = arg0.state(arg1);
+    return ret;
+  }, arguments);
+}
+function __wbg_subarray_e0162dcdea48eb3a(arg0, arg1, arg2) {
+  const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+  return ret;
+}
+function __wbg_versions_276b2795b1c6a219(arg0) {
+  const ret = arg0.versions;
+  return ret;
+}
+function __wbg_window_9c17850b5e99c0ab() {
+  return handleError(function() {
+    const ret = window.window;
+    return ret;
+  }, arguments);
+}
+function __wbg_write_56b1cf5bb0e780d6() {
+  return handleError(function(arg0, arg1, arg2, arg3, arg4) {
+    arg0.write(arg1, arg2, arg3, arg4);
+  }, arguments);
+}
+function __wbindgen_cast_0000000000000001(arg0) {
+  const ret = arg0;
+  return ret;
+}
+function __wbindgen_cast_0000000000000002(arg0, arg1) {
+  const ret = getStringFromWasm0(arg0, arg1);
+  return ret;
+}
+function __wbindgen_cast_0000000000000003(arg0) {
+  const ret = BigInt.asUintN(64, arg0);
+  return ret;
+}
+function __wbindgen_init_externref_table() {
+  const table = wasm.__wbindgen_externrefs;
+  const offset = table.grow(4);
+  table.set(0, void 0);
+  table.set(offset + 0, void 0);
+  table.set(offset + 1, null);
+  table.set(offset + 2, true);
+  table.set(offset + 3, false);
+}
+var MlsClientFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_mlsclient_free(ptr, 1));
+var MlsGroupFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_mlsgroup_free(ptr, 1));
+function addToExternrefTable0(obj) {
+  const idx = wasm.__externref_table_alloc();
+  wasm.__wbindgen_externrefs.set(idx, obj);
+  return idx;
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  return decodeText(ptr >>> 0, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    const idx = addToExternrefTable0(e);
+    wasm.__wbindgen_exn_store(idx);
+  }
+}
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passArrayJsValueToWasm0(array, malloc) {
+  const ptr = malloc(array.length * 4, 4) >>> 0;
+  for (let i = 0; i < array.length; i++) {
+    const add = addToExternrefTable0(array[i]);
+    getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+  }
+  WASM_VECTOR_LEN = array.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_externrefs.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var wasm;
+function __wbg_set_wasm(val) {
+  wasm = val;
+}
+
+// src/messaging/wasm/pkg/snippets/mls-rs-core-f99cdecbb456b09c/inline0.js
+var inline0_exports = {};
+__export(inline0_exports, {
+  date_now: () => date_now
+});
+function date_now() {
+  return Date.now();
+}
+
+// src/messaging/wasm/loader.ts
+var import_meta = {};
+var GLUE_MODULE = "./palbe_mls_bg.js";
+var SNIPPET_MODULE = "./snippets/mls-rs-core-f99cdecbb456b09c/inline0.js";
+var inflight = null;
+var ready = null;
+async function loadWasmModule() {
+  const wasmUrl = new URL("./pkg/palbe_mls_bg.wasm", import_meta.url);
+  if (wasmUrl.protocol === "file:") {
+    const fsSpecifier = ["node", "fs/promises"].join(":");
+    const { readFile } = await import(
+      /* webpackIgnore: true */
+      fsSpecifier
+    );
+    const bytes = await readFile(wasmUrl);
+    return WebAssembly.compile(bytes);
+  }
+  const response = await fetch(wasmUrl);
+  if (typeof WebAssembly.compileStreaming === "function") {
+    try {
+      return await WebAssembly.compileStreaming(Promise.resolve(response));
+    } catch {
+    }
+  }
+  const buffer = await response.arrayBuffer();
+  return WebAssembly.compile(buffer);
+}
+function buildImports() {
+  return {
+    [GLUE_MODULE]: palbe_mls_bg_exports,
+    [SNIPPET_MODULE]: inline0_exports
+  };
+}
+function initMls() {
+  if (ready) return Promise.resolve(ready);
+  if (inflight) return inflight;
+  inflight = (async () => {
+    const module2 = await loadWasmModule();
+    const instance = await WebAssembly.instantiate(module2, buildImports());
+    const setWasm = __wbg_set_wasm;
+    setWasm(instance.exports);
+    instance.exports.__wbindgen_start?.();
+    const g = {
+      generateClient,
+      setPanicHook,
+      MlsClient,
+      MlsGroup
+    };
+    try {
+      g.setPanicHook();
+    } catch {
+    }
+    ready = g;
+    return g;
+  })();
+  return inflight;
+}
+function requireMls() {
+  if (!ready) {
+    throw new Error("palbe-mls WASM not initialized \u2014 await initMls() first");
+  }
+  return ready;
+}
+
+// src/messaging/wasm/bridge.ts
+function toBytes(v) {
+  if (v instanceof Uint8Array) return v;
+  if (Array.isArray(v)) return Uint8Array.from(v);
+  if (v == null) return new Uint8Array(0);
+  if (ArrayBuffer.isView(v)) return new Uint8Array(v.buffer);
+  throw new Error("expected byte field (Uint8Array | number[])");
+}
+function optBytes(v) {
+  if (v == null) return void 0;
+  return toBytes(v);
+}
+var MlsGroupHandle = class {
+  /** @internal */
+  constructor(raw) {
+    this.raw = raw;
+  }
+  raw;
+  /** The MLS rfc_group_id (routing key / storage key) bytes. */
+  groupId() {
+    return this.raw.groupId();
+  }
+  /** Current applied epoch (BigInt → number; epochs stay well under 2^53). */
+  currentEpoch() {
+    return Number(this.raw.currentEpoch());
+  }
+  /** Stage a member add (PENDING after). */
+  addMember(keyPackageMsg) {
+    return normalizeAddResult(this.raw.addMember(keyPackageMsg));
+  }
+  /** Stage a member remove by identity bytes (PENDING after). */
+  removeMember(memberId) {
+    const r = this.raw.removeMember(memberId);
+    return { commit: toBytes(r.commit) };
+  }
+  /** Stage a SINGLE atomic add+remove commit (PENDING after). */
+  commitChanges(addKeyPackages, removeMemberIds) {
+    return normalizeAddResult(this.raw.commitChanges(addKeyPackages, removeMemberIds));
+  }
+  /** Apply the staged commit (advance the local epoch). Only after server-accept. */
+  applyPendingCommit() {
+    this.raw.applyPendingCommit();
+  }
+  /** Discard the staged commit without advancing (the 409-rebase path). */
+  clearPendingCommit() {
+    this.raw.clearPendingCommit();
+  }
+  /** True while a staged (unapplied) commit exists. */
+  hasPendingCommit() {
+    return this.raw.hasPendingCommit();
+  }
+  /** Encrypt an application message at the current epoch → PrivateMessage bytes. */
+  encryptApplicationMessage(plaintext) {
+    return this.raw.encryptApplicationMessage(plaintext);
+  }
+  /** Process an incoming MLSMessage and apply its effect (normalized result). */
+  processIncomingMessage(message) {
+    return normalizeReceived(this.raw.processIncomingMessage(message));
+  }
+  /** Inspect an incoming Commit WITHOUT applying it (the gate's crypto-truth). */
+  describeIncomingCommit(commitMsg) {
+    const d = this.raw.describeIncomingCommit(commitMsg);
+    return {
+      kind: d.kind,
+      addedIdentities: d.addedIdentities.map(toBytes),
+      removedIdentities: d.removedIdentities.map(toBytes)
+    };
+  }
+  /** Persist the current group state through the JS group-storage callback. */
+  writeToStorage() {
+    this.raw.writeToStorage();
+  }
+};
+function normalizeAddResult(v) {
+  const r = v;
+  return {
+    commit: toBytes(r.commit),
+    welcome: optBytes(r.welcome),
+    addedLeafIndices: (r.addedLeafIndices ?? []).map((n) => Number(n))
+  };
+}
+function normalizeReceived(v) {
+  if (v === "Proposal") return { type: "proposal" };
+  if (v === "Other") return { type: "other" };
+  const obj = v;
+  if (obj.Application) {
+    const a = obj.Application;
+    return { type: "application", sender: toBytes(a.sender), data: toBytes(a.data) };
+  }
+  if (obj.CommitApplied) {
+    const c = obj.CommitApplied;
+    return { type: "commitApplied", epoch: Number(c.epoch), removedSelf: Boolean(c.removedSelf) };
+  }
+  return { type: "other" };
+}
+var MlsClientHandle = class {
+  /** @internal */
+  constructor(raw) {
+    this.raw = raw;
+  }
+  raw;
+  /** The SP-0 keydir enroll material (`{ signatureKey, credential, capabilities }`). */
+  enrollmentMaterial() {
+    const m = this.raw.enrollmentMaterial();
+    return {
+      signatureKey: toBytes(m.signatureKey),
+      credential: toBytes(m.credential),
+      capabilities: toBytes(m.capabilities)
+    };
+  }
+  /** The device's STABLE signature PUBLIC key bytes (the keydir `signature_key`). */
+  signaturePublicKey() {
+    return this.raw.signaturePublicKey();
+  }
+  /** The MLS Credential wire bytes (the keydir `credential`). */
+  credential() {
+    return this.raw.credential();
+  }
+  /** The MLS Capabilities wire bytes (the keydir `capabilities`). */
+  capabilities() {
+    return this.raw.capabilities();
+  }
+  /** The serialized STABLE signature keypair (secret-bearing — persist sealed). */
+  signatureKeypair() {
+    return this.raw.signatureKeypair();
+  }
+  /** Mint a one-use KeyPackage (RAW RFC 9420 §10 bytes). */
+  generateKeyPackage() {
+    return this.raw.generateKeyPackage();
+  }
+  /** Create a new group at epoch 0 (engine mints the rfc_group_id). */
+  createGroup(groupId) {
+    return new MlsGroupHandle(this.raw.createGroup(groupId ?? void 0));
+  }
+  /** Join a group from a Welcome (opaque MLSMessage bytes). */
+  joinGroup(welcome) {
+    return new MlsGroupHandle(this.raw.joinGroup(welcome));
+  }
+  /** Re-hydrate an already-joined group by its rfc_group_id bytes. */
+  loadGroup(groupId) {
+    return new MlsGroupHandle(this.raw.loadGroup(groupId));
+  }
+};
+function generateClient2(id, groupStorage, keyPackageStorage, signatureKeypair) {
+  const { generateClient: gen } = requireMls();
+  return new MlsClientHandle(
+    gen(id, groupStorage, keyPackageStorage, signatureKeypair ?? void 0)
+  );
+}
+
+// src/messaging/mls-engine.ts
+var utf8 = new TextEncoder();
+var gidHex = bytesToHex;
+var MlsEngine = class _MlsEngine {
+  constructor(userId, deviceId, client, groupStore, kpStore) {
+    this.userId = userId;
+    this.deviceId = deviceId;
+    this.client = client;
+    this.groupStore = groupStore;
+    this.kpStore = kpStore;
+  }
+  userId;
+  deviceId;
+  client;
+  groupStore;
+  kpStore;
+  groups = /* @__PURE__ */ new Map();
+  chain = Promise.resolve();
+  /**
+   * Build the engine: init the WASM, hydrate the durable stores into the sync
+   * caches, generate (or restore) the device client. Idempotent restore: the
+   * persisted signature keypair keeps the SAME MLS signing identity across
+   * reloads; the group-state cache makes already-joined groups reloadable.
+   */
+  static async create(opts) {
+    await initMls();
+    await Promise.all([opts.groupStore.hydrate(), opts.kpStore.hydrate()]);
+    const persistedKeypair = await opts.sigStore.load(opts.userId);
+    const idBytes = utf8.encode(opts.deviceId);
+    const client = generateClient2(idBytes, opts.groupStore, opts.kpStore, persistedKeypair);
+    if (!persistedKeypair) {
+      await opts.sigStore.save(opts.userId, client.signatureKeypair());
+    }
+    return new _MlsEngine(opts.userId, opts.deviceId, client, opts.groupStore, opts.kpStore);
+  }
+  /** Serialize an engine op onto the chain so the critical section is exclusive. */
+  enqueue(fn) {
+    const run = this.chain.then(fn, fn);
+    this.chain = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  /** Flush both storage caches durably (the post-mutation durability boundary). */
+  async flush() {
+    await Promise.all([this.groupStore.flush(), this.kpStore.flush()]);
+  }
+  // ── Enroll material / key packages ──
+  enrollmentMaterial() {
+    return this.enqueue(() => this.client.enrollmentMaterial());
+  }
+  signaturePublicKey() {
+    return this.enqueue(() => this.client.signaturePublicKey());
+  }
+  generateKeyPackage() {
+    return this.enqueue(async () => {
+      const kp = this.client.generateKeyPackage();
+      await this.flush();
+      return kp;
+    });
+  }
+  // ── Group create / join / reload ──
+  /** Create a group; returns its rfc_group_id (the routing key). */
+  createGroup() {
+    return this.enqueue(async () => {
+      const group = this.client.createGroup();
+      const gid = group.groupId();
+      this.groups.set(gidHex(gid), group);
+      group.writeToStorage();
+      await this.flush();
+      return gid;
+    });
+  }
+  /** Join from a Welcome; returns the joined group's rfc_group_id. */
+  joinFromWelcome(welcome) {
+    return this.enqueue(async () => {
+      const group = this.client.joinGroup(welcome);
+      const gid = group.groupId();
+      this.groups.set(gidHex(gid), group);
+      group.writeToStorage();
+      await this.flush();
+      return gid;
+    });
+  }
+  /** The current applied epoch for a group (0 if unknown). */
+  epoch(rfcGroupId) {
+    return this.enqueue(() => {
+      const g = this.handle(rfcGroupId);
+      return g ? g.currentEpoch() : 0;
+    });
+  }
+  // ── Membership commits (staged → applied/cleared by the rebase loop) ──
+  /** Stage a SINGLE atomic add+remove commit. Returns the AddResult (PENDING). */
+  commitChanges(rfcGroupId, adds, removeMemberIds) {
+    return this.enqueue(() => {
+      const g = this.requireHandle(rfcGroupId);
+      return g.commitChanges(adds, removeMemberIds);
+    });
+  }
+  /** Apply the staged commit (advance the epoch). Only after a server-accept. */
+  applyPendingCommit(rfcGroupId) {
+    return this.enqueue(async () => {
+      const g = this.requireHandle(rfcGroupId);
+      g.applyPendingCommit();
+      g.writeToStorage();
+      await this.flush();
+    });
+  }
+  /** Discard the staged commit (the 409-rebase path). */
+  clearPendingCommit(rfcGroupId) {
+    return this.enqueue(() => {
+      const g = this.handle(rfcGroupId);
+      if (g?.hasPendingCommit()) g.clearPendingCommit();
+    });
+  }
+  // ── Application messages ──
+  /** Encrypt a plaintext at the current epoch → PrivateMessage bytes. */
+  encryptApplication(rfcGroupId, plaintext) {
+    return this.enqueue(async () => {
+      const g = this.requireHandle(rfcGroupId);
+      const ct = g.encryptApplicationMessage(plaintext);
+      g.writeToStorage();
+      await this.flush();
+      return ct;
+    });
+  }
+  /**
+   * Process an incoming MLSMessage (decrypt application / apply commit). Returns
+   * the normalized ReceivedMessage. `describeIncomingCommit` could gate a commit
+   * before applying when the server fans a declaration; today the live server
+   * does not, so we process directly (parity with the iOS nil-declaration path).
+   */
+  processIncoming(rfcGroupId, blob) {
+    return this.enqueue(async () => {
+      const g = this.requireHandle(rfcGroupId);
+      const received = g.processIncomingMessage(blob);
+      g.writeToStorage();
+      await this.flush();
+      return received;
+    });
+  }
+  /** Inspect a commit WITHOUT applying (the reconciliation gate's crypto-truth). */
+  describeIncomingCommit(rfcGroupId, commit) {
+    return this.enqueue(() => this.requireHandle(rfcGroupId).describeIncomingCommit(commit));
+  }
+  /** Persist the current group state (explicit checkpoint). */
+  writeToStorage(rfcGroupId) {
+    return this.enqueue(async () => {
+      const g = this.handle(rfcGroupId);
+      if (g) {
+        g.writeToStorage();
+        await this.flush();
+      }
+    });
+  }
+  // ── Handle resolution ──
+  /** Resolve (or reload from storage) the handle for a group, or undefined. */
+  handle(rfcGroupId) {
+    const key = gidHex(rfcGroupId);
+    const cached = this.groups.get(key);
+    if (cached) return cached;
+    try {
+      const g = this.client.loadGroup(rfcGroupId);
+      this.groups.set(key, g);
+      return g;
+    } catch {
+      return void 0;
+    }
+  }
+  requireHandle(rfcGroupId) {
+    const g = this.handle(rfcGroupId);
+    if (!g) throw new Error(`MLS group not loaded: ${gidHex(rfcGroupId)}`);
+    return g;
+  }
+};
+
+// src/messaging/registry.ts
+var GroupRegistry = class {
+  byRfc = /* @__PURE__ */ new Map();
+  catalog = null;
+  chatFactory = null;
+  onListChange = null;
+  /** Wire the observable chat-list sink + the pointer-stable Chat factory, then
+   * replay the current set so a sink attached after groups loaded reflects them. */
+  attachChatList(onListChange, factory) {
+    this.onListChange = onListChange;
+    this.chatFactory = factory;
+    this.publish();
+  }
+  /** Hydrate from the durable catalog (live entries win — fresher epoch). */
+  async attachCatalog(catalog) {
+    this.catalog = catalog;
+    let changed = false;
+    for (const c of await catalog.all()) {
+      if (!this.byRfc.has(c.rfcGroupId)) {
+        this.byRfc.set(c.rfcGroupId, {
+          displayId: c.displayId,
+          rfcGroupId: c.rfcGroupId,
+          currentEpoch: c.currentEpoch,
+          ownerUserId: c.ownerUserId,
+          directKey: c.directKey,
+          name: c.name
+        });
+        changed = true;
+      }
+    }
+    if (changed) this.publish();
+  }
+  register(group) {
+    const isNew = !this.byRfc.has(group.rfcGroupId);
+    this.byRfc.set(group.rfcGroupId, group);
+    void this.persist(group);
+    if (isNew) this.publish();
+  }
+  remove(rfcGroupId) {
+    if (!this.byRfc.has(rfcGroupId)) return;
+    this.byRfc.delete(rfcGroupId);
+    if (this.catalog) void this.catalog.remove(rfcGroupId);
+    this.publish();
+  }
+  group(rfcGroupId) {
+    return this.byRfc.get(rfcGroupId);
+  }
+  /** The single known group, if exactly one (the wire-gap routing fallback). */
+  soleGroup() {
+    return this.byRfc.size === 1 ? this.byRfc.values().next().value : void 0;
+  }
+  all() {
+    return [...this.byRfc.values()];
+  }
+  /** Advance a cached epoch (after a processed commit). Does NOT publish (the
+   * group SET is unchanged — only metadata). */
+  bumpEpoch(rfcGroupId, epoch) {
+    const g = this.byRfc.get(rfcGroupId);
+    if (!g) return;
+    const bumped = { ...g, currentEpoch: epoch };
+    this.byRfc.set(rfcGroupId, bumped);
+    void this.persist(bumped);
+  }
+  publish() {
+    const factory = this.chatFactory;
+    if (!this.onListChange || !factory) return;
+    const chats = this.all().map((g) => factory(g));
+    this.onListChange(chats);
+  }
+  async persist(group) {
+    if (!this.catalog) return;
+    try {
+      await this.catalog.upsert({
+        displayId: group.displayId,
+        rfcGroupId: group.rfcGroupId,
+        currentEpoch: group.currentEpoch,
+        ownerUserId: group.ownerUserId,
+        directKey: group.directKey,
+        name: group.name
+      });
+    } catch {
+    }
+  }
+};
+
+// src/messaging/storage.ts
+var hasIndexedDB = () => typeof indexedDB !== "undefined" && typeof crypto !== "undefined" && !!crypto.subtle;
+function copyToArrayBuffer(view) {
+  const out = new ArrayBuffer(view.byteLength);
+  new Uint8Array(out).set(view);
+  return out;
+}
+var MemoryKV = class {
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    return Promise.resolve(this.map.get(key));
+  }
+  set(key, value) {
+    this.map.set(key, value.slice());
+    return Promise.resolve();
+  }
+  delete(key) {
+    this.map.delete(key);
+    return Promise.resolve();
+  }
+  keys(prefix) {
+    return Promise.resolve([...this.map.keys()].filter((k) => k.startsWith(prefix)));
+  }
+};
+var DB_NAME = "palbe.messaging";
+var STORE = "kv";
+var KEY_STORE = "keys";
+var SEAL_KEY_ID = "seal-key-v1";
+function openDb() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, 1);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE)) db.createObjectStore(STORE);
+      if (!db.objectStoreNames.contains(KEY_STORE)) db.createObjectStore(KEY_STORE);
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+function idbReq(req) {
+  return new Promise((resolve, reject) => {
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function getSealKey(db) {
+  const existing = await idbReq(
+    db.transaction(KEY_STORE, "readonly").objectStore(KEY_STORE).get(SEAL_KEY_ID)
+  );
+  if (existing) return existing;
+  const key = await crypto.subtle.generateKey({ name: "AES-GCM", length: 256 }, false, [
+    "encrypt",
+    "decrypt"
+  ]);
+  await idbReq(db.transaction(KEY_STORE, "readwrite").objectStore(KEY_STORE).put(key, SEAL_KEY_ID));
+  return key;
+}
+var IndexedDbKV = class {
+  dbPromise = null;
+  keyPromise = null;
+  db() {
+    if (!this.dbPromise) this.dbPromise = openDb();
+    return this.dbPromise;
+  }
+  async sealKey() {
+    if (!this.keyPromise) this.keyPromise = this.db().then(getSealKey);
+    return this.keyPromise;
+  }
+  async seal(plain) {
+    const key = await this.sealKey();
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const ct = new Uint8Array(
+      await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, copyToArrayBuffer(plain))
+    );
+    const out = new Uint8Array(iv.length + ct.length);
+    out.set(iv, 0);
+    out.set(ct, iv.length);
+    return out;
+  }
+  async open(sealed) {
+    const key = await this.sealKey();
+    const iv = copyToArrayBuffer(sealed.subarray(0, 12));
+    const ct = copyToArrayBuffer(sealed.subarray(12));
+    const pt = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ct);
+    return new Uint8Array(pt);
+  }
+  async get(k) {
+    const db = await this.db();
+    const sealed = await idbReq(db.transaction(STORE, "readonly").objectStore(STORE).get(k));
+    if (!sealed) return void 0;
+    return this.open(sealed);
+  }
+  async set(k, v) {
+    const db = await this.db();
+    const sealed = await this.seal(v);
+    await idbReq(db.transaction(STORE, "readwrite").objectStore(STORE).put(sealed, k));
+  }
+  async delete(k) {
+    const db = await this.db();
+    await idbReq(db.transaction(STORE, "readwrite").objectStore(STORE).delete(k));
+  }
+  async keys(prefix) {
+    const db = await this.db();
+    const all = await idbReq(
+      db.transaction(STORE, "readonly").objectStore(STORE).getAllKeys()
+    );
+    return all.map(String).filter((k) => k.startsWith(prefix));
+  }
+};
+function createDurableKV() {
+  return hasIndexedDB() ? new IndexedDbKV() : new MemoryKV();
+}
+function bytesKey(prefix, id) {
+  return prefix + bytesToHex(id);
 }
-function resolveStorage() {
-  try {
-    if (typeof localStorage === "undefined") {
-      return null;
+var GroupStateStorage = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  // In-memory authoritative cache (the engine reads/writes this synchronously).
+  stateCache = /* @__PURE__ */ new Map();
+  epochCache = /* @__PURE__ */ new Map();
+  maxEpochCache = /* @__PURE__ */ new Map();
+  // Keys touched since the last flush (durable write queue).
+  dirty = /* @__PURE__ */ new Set();
+  // ── sync engine seam ──
+  state(groupId) {
+    return this.stateCache.get(bytesKey("", groupId));
+  }
+  epoch(groupId, epochId) {
+    return this.epochCache.get(`${bytesKey("", groupId)}:${epochId}`);
+  }
+  write(groupId, groupState, epochInserts, epochUpdates) {
+    const gid = bytesKey("", groupId);
+    this.stateCache.set(gid, groupState.slice());
+    this.dirty.add(`state:${gid}`);
+    let max = this.maxEpochCache.get(gid) ?? -1n;
+    for (const rec of [...epochInserts, ...epochUpdates]) {
+      this.epochCache.set(`${gid}:${rec.id}`, rec.data.slice());
+      this.dirty.add(`epoch:${gid}:${rec.id}`);
+      if (rec.id > max) max = rec.id;
+    }
+    if (max >= 0n) {
+      this.maxEpochCache.set(gid, max);
+      this.dirty.add(`maxEpoch:${gid}`);
     }
-    const probe = "__palbase_flags_probe__";
-    localStorage.setItem(probe, "1");
-    localStorage.removeItem(probe);
-    return localStorage;
-  } catch {
-    return null;
   }
-}
-function resolveVisibility() {
-  if (typeof document === "undefined") {
-    return null;
+  maxEpochId(groupId) {
+    return this.maxEpochCache.get(bytesKey("", groupId));
   }
-  const doc = document;
-  return {
-    isHidden: () => doc.visibilityState === "hidden",
-    onVisibilityChange: (cb) => {
-      doc.addEventListener("visibilitychange", cb);
-      return () => doc.removeEventListener("visibilitychange", cb);
+  // ── async durable flush (called by the engine wrapper after a mutating op) ──
+  async flush() {
+    if (this.dirty.size === 0) return;
+    const pending = [...this.dirty];
+    this.dirty.clear();
+    await Promise.all(
+      pending.map(async (key) => {
+        if (key.startsWith("state:")) {
+          const gid = key.slice("state:".length);
+          const v = this.stateCache.get(gid);
+          if (v) await this.kv.set(`gss:state:${gid}`, v);
+        } else if (key.startsWith("epoch:")) {
+          const rest = key.slice("epoch:".length);
+          const v = this.epochCache.get(rest);
+          if (v) await this.kv.set(`gss:epoch:${rest}`, v);
+        } else if (key.startsWith("maxEpoch:")) {
+          const gid = key.slice("maxEpoch:".length);
+          const max = this.maxEpochCache.get(gid);
+          if (max != null) await this.kv.set(`gss:maxEpoch:${gid}`, encodeBigint(max));
+        }
+      })
+    );
+  }
+  /** Hydrate the in-memory cache from the durable KV (call before generateClient). */
+  async hydrate() {
+    const keys = await this.kv.keys("gss:");
+    for (const k of keys) {
+      const v = await this.kv.get(k);
+      if (!v) continue;
+      if (k.startsWith("gss:state:")) {
+        this.stateCache.set(k.slice("gss:state:".length), v);
+      } else if (k.startsWith("gss:epoch:")) {
+        this.epochCache.set(k.slice("gss:epoch:".length), v);
+      } else if (k.startsWith("gss:maxEpoch:")) {
+        this.maxEpochCache.set(k.slice("gss:maxEpoch:".length), decodeBigint(v));
+      }
     }
-  };
-}
-
-// src/flags-facade.ts
-function palbeAuthAdapter(auth) {
-  return {
-    onAuthStateChange(callback) {
-      const unsubscribe = auth.onAuthStateChange(() => {
-        const signedIn = auth.isSignedIn;
-        callback(signedIn ? "SIGNED_IN" : "SIGNED_OUT", signedIn ? { signedIn } : null);
-      });
-      return { data: { subscription: { unsubscribe } } };
+  }
+  async wipe() {
+    this.stateCache.clear();
+    this.epochCache.clear();
+    this.maxEpochCache.clear();
+    this.dirty.clear();
+    for (const k of await this.kv.keys("gss:")) await this.kv.delete(k);
+  }
+};
+var KeyPackageStorage = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  cache = /* @__PURE__ */ new Map();
+  dirtySet = /* @__PURE__ */ new Set();
+  dirtyDelete = /* @__PURE__ */ new Set();
+  // ── sync engine seam ──
+  delete(id) {
+    const k = bytesKey("", id);
+    this.cache.delete(k);
+    this.dirtyDelete.add(k);
+    this.dirtySet.delete(k);
+  }
+  insert(id, data) {
+    const k = bytesKey("", id);
+    this.cache.set(k, data.slice());
+    this.dirtySet.add(k);
+    this.dirtyDelete.delete(k);
+  }
+  get(id) {
+    return this.cache.get(bytesKey("", id));
+  }
+  // ── async durable flush ──
+  async flush() {
+    if (this.dirtySet.size === 0 && this.dirtyDelete.size === 0) return;
+    const sets = [...this.dirtySet];
+    const dels = [...this.dirtyDelete];
+    this.dirtySet.clear();
+    this.dirtyDelete.clear();
+    await Promise.all([
+      ...sets.map((k) => {
+        const v = this.cache.get(k);
+        return v ? this.kv.set(`kps:${k}`, v) : Promise.resolve();
+      }),
+      ...dels.map((k) => this.kv.delete(`kps:${k}`))
+    ]);
+  }
+  async hydrate() {
+    for (const k of await this.kv.keys("kps:")) {
+      const v = await this.kv.get(k);
+      if (v) this.cache.set(k.slice("kps:".length), v);
     }
-  };
+  }
+  async wipe() {
+    this.cache.clear();
+    this.dirtySet.clear();
+    this.dirtyDelete.clear();
+    for (const k of await this.kv.keys("kps:")) await this.kv.delete(k);
+  }
+};
+function encodeBigint(n) {
+  return new TextEncoder().encode(n.toString());
 }
-function serverPoolEnv() {
-  return {
-    now: () => Date.now(),
-    setInterval: () => {
-      throw new Error("palbe flags: polling is disabled server-side");
-    },
-    clearInterval: () => {
-    },
-    storage: null,
-    visibility: null
-  };
+function decodeBigint(b) {
+  return BigInt(new TextDecoder().decode(b));
 }
-function sameFlagValue(a, b) {
-  if (Object.is(a, b)) return true;
-  if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) {
-    return JSON.stringify(a) === JSON.stringify(b);
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+var DeviceIdStore = class {
+  constructor(kv) {
+    this.kv = kv;
   }
-  return false;
-}
-var PalbeFlags = class {
-  transport;
-  pool;
+  kv;
+  async load(userId) {
+    const v = await this.kv.get(`devid:${userId}`);
+    return v ? dec.decode(v) : void 0;
+  }
+  async save(userId, deviceId) {
+    await this.kv.set(`devid:${userId}`, enc.encode(deviceId));
+  }
+  async clear(userId) {
+    await this.kv.delete(`devid:${userId}`);
+  }
+};
+var SignatureKeyStore = class {
+  constructor(kv) {
+    this.kv = kv;
+  }
+  kv;
+  async load(userId) {
+    return this.kv.get(`sigkey:${userId}`);
+  }
+  async save(userId, keypair) {
+    await this.kv.set(`sigkey:${userId}`, keypair);
+  }
+};
+
+// src/messaging/coordinator.ts
+var MessagingCoordinator = class {
   constructor(rt) {
-    this.transport = new FlagsClient(rt.http);
-    const browser = typeof document !== "undefined";
-    const ref = endpointRefFromApiKey(rt.config.apiKey);
-    const options = {
-      auth: palbeAuthAdapter(rt.auth),
-      ...ref ? { storageKey: `palbe.flags.${ref}` } : {},
-      ...browser ? {} : { pollIntervalMs: 0, env: serverPoolEnv() }
+    this.rt = rt;
+    this.kv = createDurableKV();
+    this.deviceStore = new DeviceIdStore(this.kv);
+    this.sigStore = new SignatureKeyStore(this.kv);
+    this.groupStore = new GroupStateStorage(this.kv);
+    this.kpStore = new KeyPackageStorage(this.kv);
+    this.registry.attachChatList(
+      (chats) => {
+        this.chatList = chats;
+        this.emitList();
+      },
+      (group) => this.chatFor(group)
+    );
+  }
+  rt;
+  kv;
+  deviceStore;
+  sigStore;
+  groupStore;
+  kpStore;
+  registry = new GroupRegistry();
+  resolved = null;
+  resolvePromise = null;
+  // Pointer-stable Chat cache (one per rfc id) + the observable chat list.
+  chatByRfc = /* @__PURE__ */ new Map();
+  chatList = [];
+  listListeners = /* @__PURE__ */ new Set();
+  // ── ChatBackend identity ──
+  get selfUserId() {
+    const u = this.rt.auth.currentUser;
+    if (!u) throw new Error("not_signed_in");
+    return u.id;
+  }
+  // ── Public surface (used by the facade) ──
+  /** Self-enroll + start the delivery source (idempotent). The first chat op
+   * calls this implicitly; pb.messaging.start() is the opt-in warm-at-sign-in. */
+  async ensureEnrolled() {
+    await this.resolve();
+  }
+  /** Open the ONE direct chat with userId. INSTANT + LOCAL (no network); the
+   * group materializes on the first send. Pointer-stable per peer pair. */
+  directChat(peerUserId) {
+    const selfId = this.selfUserId;
+    const dk = directKey(selfId, peerUserId);
+    for (const chat2 of this.chatByRfc.values()) {
+      if (chat2.isDirect && chat2.state === "active") {
+        const g = this.registry.all().find((x) => x.displayId === chat2.id);
+        if (g?.directKey === dk) return chat2;
+      }
+    }
+    const draft = {
+      mode: { kind: "direct", peerUserId },
+      reservedId: `draft:${dk}`
     };
-    this.pool = new FlagsPool(this.transport, options);
-    if (browser) this.pool.start();
+    const cached = this.chatByRfc.get(draft.reservedId);
+    if (cached) return cached;
+    const chat = new Chat({ draft, kind: "direct", backend: this });
+    this.chatByRfc.set(draft.reservedId, chat);
+    void this.ensureEnrolled().catch(() => {
+    });
+    return chat;
   }
-  /** Resolves once the first snapshot (or persisted hydrate) is available. Auto-starts the pool. */
-  ready() {
-    return this.pool.ready();
+  /** Open a multi-party group chat (LOCAL + LAZY; created on first send). */
+  groupChat(members = []) {
+    const draft = {
+      mode: { kind: "group", members },
+      reservedId: `draft:group:${crypto.randomUUID()}`
+    };
+    const chat = new Chat({ draft, kind: "group", backend: this });
+    this.chatByRfc.set(draft.reservedId, chat);
+    void this.ensureEnrolled().catch(() => {
+    });
+    return chat;
   }
-  /** Force an immediate re-snapshot. */
-  refresh() {
-    return this.pool.refresh();
+  /** Look up an active chat by id (grp_ display id). */
+  chatById(id) {
+    const g = this.registry.all().find((x) => x.displayId === id);
+    return g ? this.chatFor(g) : this.chatByRfc.get(id) ?? null;
   }
-  /** Frozen snapshot of all cached values (identity-stable until a change). */
-  all() {
-    return this.pool.all();
+  /** The observable chat list (active chats only). */
+  get chats() {
+    void this.ensureEnrolled().catch(() => {
+    });
+    return this.chatList;
   }
-  /** Raw cached value for `key`, or `undefined` when not in the cache. */
-  get(key) {
-    return this.pool.all()[key];
+  onChatsChange(cb) {
+    this.listListeners.add(cb);
+    void this.ensureEnrolled().catch(() => {
+    });
+    return () => this.listListeners.delete(cb);
+  }
+  emitList() {
+    for (const cb of this.listListeners) cb();
+  }
+  /** Pointer-stable Chat for a group (one per rfc id). */
+  chatFor(group) {
+    const existing = this.chatByRfc.get(group.rfcGroupId);
+    if (existing) return existing;
+    const chat = new Chat({
+      group,
+      kind: group.directKey ? "direct" : "group",
+      backend: this
+    });
+    this.chatByRfc.set(group.rfcGroupId, chat);
+    return chat;
+  }
+  // ── Resolution (build-once) ──
+  resolve() {
+    if (this.resolved) return Promise.resolve(this.resolved);
+    if (this.resolvePromise) return this.resolvePromise;
+    this.resolvePromise = this.buildResolved();
+    return this.resolvePromise;
+  }
+  async buildResolved() {
+    const userId = this.selfUserId;
+    const deviceId = await this.deviceStore.load(userId) ?? mintDeviceId();
+    const engine = await MlsEngine.create({
+      userId,
+      deviceId,
+      groupStore: this.groupStore,
+      kpStore: this.kpStore,
+      sigStore: this.sigStore
+    });
+    const messageStore = new MessageStore(this.kv);
+    const catalog = new GroupCatalog(this.kv);
+    const hub = new MessageHub();
+    const groups = new GroupMessaging(this.rt, engine, userId, deviceId, messageStore);
+    const source = new MessageDeliverySource(
+      this.rt,
+      engine,
+      hub,
+      this.registry,
+      messageStore,
+      deviceId,
+      userId
+    );
+    await enrollDevice(this.rt, engine, this.deviceStore, {});
+    await this.registry.attachCatalog(catalog);
+    const resolved = {
+      engine,
+      groups,
+      source,
+      hub,
+      messageStore,
+      catalog,
+      registry: this.registry,
+      deviceId,
+      userId
+    };
+    this.resolved = resolved;
+    await source.start();
+    return resolved;
+  }
+  // ── ChatBackend impl ──
+  async materialize(draft) {
+    const r = await this.resolve();
+    let group;
+    if (draft.mode.kind === "direct") {
+      group = await r.groups.getOrCreateDirect(draft.mode.peerUserId);
+    } else {
+      group = await r.groups.createGroup();
+      for (const userId of draft.mode.members) {
+        await r.groups.addMember(group, userId);
+      }
+    }
+    r.registry.register(group);
+    void r.catalog.upsert({
+      displayId: group.displayId,
+      rfcGroupId: group.rfcGroupId,
+      currentEpoch: group.currentEpoch,
+      ownerUserId: group.ownerUserId,
+      directKey: group.directKey,
+      name: group.name
+    });
+    return group;
+  }
+  async sendText(group, text, replyTo) {
+    const r = await this.resolve();
+    return r.groups.sendText(group, text, replyTo);
+  }
+  async history(group, limit, before) {
+    const r = await this.resolve();
+    const rows = await r.messageStore.history(group.rfcGroupId, limit, before);
+    const lookup = /* @__PURE__ */ new Map();
+    for (const s of rows) {
+      const cid = s.clientMsgId ?? "";
+      if (cid && s.text !== null) {
+        const senderUserId = s.direction === "outgoing" ? this.selfUserId : "";
+        lookup.set(cid, { text: s.text, senderUserId });
+      }
+    }
+    return rows.map((s) => this.toChatMessage(group, s, (id) => lookup.get(id) ?? null));
+  }
+  toChatMessage(group, s, lookup) {
+    const clientMsgId = s.clientMsgId ?? "";
+    let replyTo = null;
+    if (s.replyTo && lookup) {
+      const ref = {
+        v: 1,
+        client_msg_id: s.replyTo.clientMsgId,
+        preview: {
+          kind: s.replyTo.previewKind,
+          author_user_id: s.replyTo.previewAuthorUserId ?? "",
+          body: s.replyTo.previewBody ?? void 0,
+          body_truncated: false
+        }
+      };
+      replyTo = resolveReply(ref, lookup);
+    }
+    return {
+      id: `${group.displayId}#${s.serverSeq}`,
+      kind: s.text != null ? "text" : "system",
+      direction: s.direction,
+      senderUserId: s.direction === "outgoing" ? this.selfUserId : null,
+      text: s.text,
+      serverSeq: s.serverSeq,
+      sentAt: new Date(s.at),
+      clientMsgId,
+      replyTo
+    };
   }
-  /** `true` only when the cached value is strictly `true`; `fallback` when the key is absent. */
-  isEnabled(key, fallback = false) {
-    return this.pool.isEnabled(key, fallback);
+  async members(group) {
+    const r = await this.resolve();
+    try {
+      const rows = await r.groups.listMembers(group.displayId);
+      const byUser = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        if (!byUser.has(row.user_id)) {
+          byUser.set(row.user_id, {
+            id: row.user_id,
+            userId: row.user_id,
+            displayName: null,
+            role: row.role,
+            isSelf: row.user_id === this.selfUserId
+          });
+        }
+      }
+      return [...byUser.values()];
+    } catch {
+      return [];
+    }
   }
-  /** Alias of {@link isEnabled} (iOS parity). */
-  bool(key, fallback = false) {
-    return this.isEnabled(key, fallback);
+  async addMember(group, userId) {
+    const r = await this.resolve();
+    await r.groups.addMember(group, userId);
   }
-  /** Cached value when it is a string, else `fallback`. */
-  getString(key, fallback) {
-    const value = this.pool.all()[key];
-    return typeof value === "string" ? value : fallback;
+  async removeMember(group, userId) {
+    const r = await this.resolve();
+    await r.groups.removeMember(group, userId);
   }
-  /** Cached value when it is an integer number, else `fallback`. */
-  getInt(key, fallback) {
-    const value = this.pool.all()[key];
-    return typeof value === "number" && Number.isInteger(value) ? value : fallback;
+  async leave(group) {
+    const r = await this.resolve();
+    await r.groups.leaveGroup(group);
+    r.registry.remove(group.rfcGroupId);
   }
-  /** Cached value when it is a number (integers included), else `fallback`. */
-  getDouble(key, fallback) {
-    const value = this.pool.all()[key];
-    return typeof value === "number" ? value : fallback;
+  registerActive(group) {
+    this.registry.register(group);
   }
-  /**
-   * Resolve the multivariate variant for `key` — the variant name, or `null`
-   * when the flag has no variant (or the read fails).
-   *
-   * Wire failures (network errors, 404, etc.) resolve to `null`.
-   * Invalid flag names throw `BackendError('validation', { code: 'invalid_flag_name' })`.
-   *
-   * DEVIATION from iOS sync-cache parity: the platform does not propagate
-   * variant metadata into the user-flags snapshot/delta cache, so this is an
-   * ASYNC transport read (`GET /v1/flags/{key}/variant`), not a cache lookup.
-   */
-  async getVariant(key) {
-    let res;
-    try {
-      res = await this.transport.getVariant(key);
-    } catch (err) {
-      throw new BackendError("validation", {
-        code: "invalid_flag_name",
-        message: err instanceof Error ? err.message : String(err)
+  setTyping(group, isTyping) {
+    void this.resolve().then((r) => r.source.setTyping(group, isTyping));
+  }
+  async markRead(group, upToServerSeq) {
+    const r = await this.resolve();
+    await r.source.markRead(group, upToServerSeq);
+  }
+  subscribeLive(group, chat) {
+    let offMsg = null;
+    let offConv = null;
+    void this.resolve().then((r) => {
+      offMsg = r.hub.onMessage(group.displayId, (m) => {
+        void chat.ingestLive(m);
       });
+      r.source.observeConversation(group);
+      offConv = r.hub.onConv(group.displayId, (e) => chat.applyConv(e.event, e.payload));
+    });
+    return () => {
+      offMsg?.();
+      offConv?.();
+    };
+  }
+  async userIdForDevice(group, deviceId) {
+    const r = await this.resolve();
+    try {
+      const rows = await r.groups.listMembers(group.displayId);
+      return rows.find((m) => m.device_id === deviceId)?.user_id ?? null;
+    } catch {
+      return null;
     }
-    return res.data?.name ?? null;
   }
-  /** Subscribe to any change in the cached flag set. */
-  onChange(callback) {
-    return this.pool.onChange(callback);
+  // ── Trust (chat-scoped) ──
+  /** List a user's devices (used by safety-number computation). */
+  async listUserDevices(userId) {
+    const res = await listDevices(this.rt, userId);
+    return res.devices.map((d) => d.device_id);
+  }
+};
+
+// src/messaging/facade.ts
+var PalbeMessaging = class {
+  coordinator;
+  constructor(rt) {
+    this.coordinator = new MessagingCoordinator(rt);
   }
   /**
-   * Observe ONE key: fires only when that key's value actually changes
-   * (per {@link sameFlagValue} — structural compare for objects), with the
-   * new value (`undefined` = deleted). P5 React-hook substrate.
+   * Warm messaging at sign-in (optional). Enrolls this device + starts the live
+   * delivery source so incoming DMs/Welcomes drain before the chat list opens.
+   * Never REQUIRED — any chat op self-enrolls. Idempotent.
    */
-  subscribeKey(key, callback) {
-    let last = this.pool.all()[key];
-    return this.pool.onChange(() => {
-      const next = this.pool.all()[key];
-      if (sameFlagValue(last, next)) return;
-      last = next;
-      callback(next);
-    });
+  async start() {
+    await this.coordinator.ensureEnrolled();
   }
   /**
-   * Async iteration over flag changes: yields the new {@link all} view on
-   * every pool change notification. The listener is detached when the
-   * consumer `break`s/`return`s/`throw`s — including while a `next()` is
-   * still pending (it resolves `{ done: true }` instead of hanging, which a
-   * plain async-generator `finally` would not guarantee).
+   * Open the ONE direct chat with `userId`. INSTANT + LOCAL — no network, nothing
+   * created yet. Returns a draft `Chat` to show immediately; the server group +
+   * MLS material materialize LAZILY on the first `chat.send`. Idempotent + stable:
+   * the same two users always resolve to the SAME Chat.
    */
-  changes() {
-    const queue = [];
-    const pending = [];
-    let finished = false;
-    const unsubscribe = this.pool.onChange(() => {
-      const snapshot = this.pool.all();
-      const resolve = pending.shift();
-      if (resolve) resolve({ value: snapshot, done: false });
-      else queue.push(snapshot);
-    });
-    const finish = () => {
-      if (finished) return;
-      finished = true;
-      unsubscribe();
-      while (pending.length > 0) pending.shift()?.({ value: void 0, done: true });
-    };
-    return {
-      next: () => {
-        if (finished) return Promise.resolve({ value: void 0, done: true });
-        const head = queue.shift();
-        if (head !== void 0) return Promise.resolve({ value: head, done: false });
-        return new Promise((resolve) => {
-          pending.push(resolve);
-        });
-      },
-      return: () => {
-        finish();
-        return Promise.resolve({ value: void 0, done: true });
-      },
-      throw: (error) => {
-        finish();
-        return Promise.reject(error);
-      },
-      [Symbol.asyncIterator]() {
-        return this;
-      }
-    };
+  directChat(userId) {
+    return this.coordinator.directChat(userId);
   }
-  /** Stop polling and detach all listeners (auth + visibility + subscribers). */
-  destroy() {
-    this.pool.destroy();
+  /**
+   * Open a multi-party group chat. LOCAL + LAZY like `directChat`: pick the
+   * members, get a draft Chat, the group is created on the FIRST `chat.send`.
+   */
+  groupChat(opts = {}) {
+    return this.coordinator.groupChat(opts.members ?? []);
+  }
+  /** Look up a chat by id (e.g. from a push payload / deep link). null if unknown. */
+  chat(id) {
+    return this.coordinator.chatById(id);
+  }
+  /** The observable chat list (DMs + groups, active only). Read it after an
+   * `onChatsChange` subscription to render the inbox. */
+  get chats() {
+    return this.coordinator.chats;
+  }
+  /** Subscribe to chat-list changes (a chat added/removed/hydrated). */
+  onChatsChange(cb) {
+    return this.coordinator.onChatsChange(cb);
   }
 };
 
@@ -1856,10 +5277,10 @@ var RealtimeSocket = class {
     this.flushPending(topic);
   }
   flushPending(topic) {
-    const ready = this.pendingBroadcasts.filter((p) => p.topic === topic);
-    if (ready.length === 0) return;
+    const ready2 = this.pendingBroadcasts.filter((p) => p.topic === topic);
+    if (ready2.length === 0) return;
     this.pendingBroadcasts = this.pendingBroadcasts.filter((p) => p.topic !== topic);
-    for (const p of ready) this.sendBroadcast(p.topic, p.event, p.payload);
+    for (const p of ready2) this.sendBroadcast(p.topic, p.event, p.payload);
   }
   startHeartbeat() {
     this.stopHeartbeat();
@@ -2195,7 +5616,7 @@ function localStorageSessionStorage(key = DEFAULT_KEY) {
 }
 
 // src/version.ts
-var VERSION = "1.0.1";
+var VERSION = "1.1.0";
 
 // src/internal.ts
 function getRuntime() {
@@ -2358,6 +5779,12 @@ function createClientProxy(resolveRt, nsAccessor) {
     },
     get analytics() {
       return resolveRt().analytics;
+    },
+    get calls() {
+      return resolveRt().calls;
+    },
+    get messaging() {
+      return resolveRt().messaging;
     }
   };
   return new Proxy(base, {
@@ -2382,10 +5809,13 @@ var pb = createClientProxy(getRuntime, getNamespace);
   BackendError,
   PalbeAnalytics,
   PalbeAuth,
+  PalbeCalls,
   PalbeFlags,
+  PalbeMessaging,
   PalbeRealtime,
   RealtimeChannel,
   VERSION,
+  initMls,
   isBackendError,
   localStorageSessionStorage,
   memorySessionStorage,