@palbase/web 1.6.2 → 1.7.0

package/dist/internal.d.cts

@@ -1,7 +1,7 @@
-import { v as PalbeConfig, N as PalbeRuntime } from './analytics-facade-ATGUv2-f.cjs';
-export { Q as buildRuntime } from './analytics-facade-ATGUv2-f.cjs';
+import { v as PalbeConfig, T as PalbeRuntime } from './analytics-facade-9GPSKnVG.cjs';
+export { V as buildRuntime } from './analytics-facade-9GPSKnVG.cjs';
 import { B as BackendError } from './errors-fDoNdTrJ.cjs';
-export { P as PB, c as createBoundClient } from './pb-VzJvX7Gg.cjs';
+export { P as PB, c as createBoundClient } from './pb-D4HyUbpb.cjs';
 import 'livekit-client';
 import './storage-BPaeSG8K.cjs';
 import './pooled-flags-Bwq4usn0.js';

package/dist/internal.d.ts

@@ -1,7 +1,7 @@
-import { v as PalbeConfig, N as PalbeRuntime } from './analytics-facade-DhcTP_kw.js';
-export { Q as buildRuntime } from './analytics-facade-DhcTP_kw.js';
+import { v as PalbeConfig, T as PalbeRuntime } from './analytics-facade-CQJ3b-zB.js';
+export { V as buildRuntime } from './analytics-facade-CQJ3b-zB.js';
 import { B as BackendError } from './errors-fDoNdTrJ.js';
-export { P as PB, c as createBoundClient } from './pb-TAUNVyT6.js';
+export { P as PB, c as createBoundClient } from './pb-BvfCJZux.js';
 import 'livekit-client';
 import './storage-BPaeSG8K.js';
 import './pooled-flags-Bwq4usn0.js';

package/dist/internal.js

@@ -6,7 +6,7 @@ import {
   createBoundClient,
   getRuntime,
   onConfigured
-} from "./chunk-XQZ53URR.js";
+} from "./chunk-QRO632M7.js";
 export {
   __configure,
   __registerNamespaces,

package/dist/next/client.cjs

@@ -2706,6 +2706,10 @@ var MessagingPaths = {
   groupMessages: (displayId) => `${GROUPS}/${seg(displayId)}/messages`,
   groupCommits: (displayId) => `${GROUPS}/${seg(displayId)}/commits`,
   groupRead: (displayId) => `${GROUPS}/${seg(displayId)}/read`,
+  // Server-metadata cluster: the per-(user,group) notify scope (mute toggle, GET/PUT)
+  // + the caller's own unread view (GET). {gid} is the grp_ display_id (M3 #7).
+  groupNotify: (displayId) => `${GROUPS}/${seg(displayId)}/notify`,
+  groupUnread: (displayId) => `${GROUPS}/${seg(displayId)}/unread`,
   deviceWelcomes: (deviceId) => `${DEVICES}/${seg(deviceId)}/welcomes`,
   deviceQueue: (deviceId) => `${DEVICES}/${seg(deviceId)}/queue`,
   deviceQueueAck: (deviceId) => `${DEVICES}/${seg(deviceId)}/queue/ack`,
@@ -4284,6 +4288,18 @@ var Chat = class {
         lastSeenAt: ts ? new Date(ts * 1e3) : null
       });
       this.emit();
+    } else if (event === "delivered" || event === "read") {
+      const seq = typeof payload.up_to_server_seq === "number" ? payload.up_to_server_seq : null;
+      if (seq === null) return;
+      let changed = false;
+      this.messageList = this.messageList.map((m) => {
+        if (m.direction !== "outgoing" || m.serverSeq > seq) return m;
+        const cur = event === "delivered" ? m.deliveredUpTo ?? -1 : m.readUpTo ?? -1;
+        if (seq <= cur) return m;
+        changed = true;
+        return event === "delivered" ? { ...m, deliveredUpTo: seq } : { ...m, readUpTo: seq };
+      });
+      if (changed) this.emit();
     }
   }
   kindOf(incoming) {
@@ -4532,6 +4548,31 @@ var Chat = class {
     this.readWatermark = Math.max(this.readWatermark, message.serverSeq);
     this.emit();
   }
+  // ── Server-metadata cluster: notify scope (mute) + server unread ──
+  /** Set this chat's notify scope (the mute toggle). `'none'` mutes the push wake;
+   * `'all'` unmutes (the default). Materializes a draft first (the scope is a
+   * per-(user,group) server row), PUTs `/notify`, and returns the server-echoed scope.
+   * Mirrors iOS `Chat.setNotifyScope`. */
+  async setNotifyScope(scope) {
+    const group = await this.materializeIfNeeded();
+    return this.backend.setNotifyScope(group, scope);
+  }
+  /** Refresh + return this chat's notify scope from the server (fail-OPEN to `'all'`).
+   * Returns `'all'` for a draft chat (no server row yet). */
+  async getNotifyScope() {
+    if (!this._group) return "all";
+    return this.backend.getNotifyScope(this._group);
+  }
+  /** Fetch the caller's authoritative SERVER unread count (opaque server metadata).
+   * Returns the clamped count (`max(0, …)`); `0` for a draft chat. The local computed
+   * `unreadCount` getter stays the instant, offline best-effort badge — this is the
+   * canonical count on demand. Named distinctly so it does not shadow the observable
+   * `unreadCount` snapshot getter. Mirrors iOS `Chat.refreshUnread`. */
+  async unreadCountFromServer() {
+    if (!this._group) return 0;
+    const v = await this.backend.unread(this._group);
+    return Math.max(0, v.unreadCount);
+  }
   // ── Reactions ──
   /** Add an emoji reaction to a message. No-op if the message isn't reactable
    * (empty clientMsgId — a legacy/system row). The reaction folds locally with
@@ -4970,7 +5011,7 @@ var MessageDeliverySource = class {
     if (this.observed.has(group.displayId)) return;
     try {
       const channel = this.rt.realtime.channel(`messaging:conv:${group.rfcGroupId}`);
-      const subs = ["presence", "typing", "read"].map(
+      const subs = ["presence", "typing", "read", "delivered"].map(
         (ev) => channel.on(ev, (payload) => {
           this.hub.emitConv(group.displayId, { event: ev, payload });
         })
@@ -5010,6 +5051,40 @@ var MessageDeliverySource = class {
       body: { read_seq: upToServerSeq, read_epoch: group.currentEpoch, is_private: false }
     });
   }
+  // ── Server-metadata cluster: notify scope (mute) + unread (HTTP) ──
+  /** PUT `/v1/messaging/groups/{gid}/notify` — set the caller's per-(user,group) notify
+   * scope (`'all'`|`'none'`). The server stores the opaque enum verbatim and stays blind.
+   * Returns the server-echoed scope (fail-OPEN to `'all'` on an unknown value). */
+  async setNotifyScope(group, scope) {
+    const res = await palbeRequest(
+      this.rt,
+      "PUT",
+      MessagingPaths.groupNotify(group.displayId),
+      { body: { notify_scope: scope } }
+    );
+    return res.notify_scope === "none" ? "none" : "all";
+  }
+  /** GET `/v1/messaging/groups/{gid}/notify` — the caller's notify scope. An absent
+   * server row / unknown value reads as `'all'` (fail-OPEN — never silently mutes). */
+  async getNotifyScope(group) {
+    const res = await palbeRequest(
+      this.rt,
+      "GET",
+      MessagingPaths.groupNotify(group.displayId)
+    );
+    return res.notify_scope === "none" ? "none" : "all";
+  }
+  /** GET `/v1/messaging/groups/{gid}/unread` — the caller's OWN unread view (opaque
+   * server metadata). Maps the snake_case wire → the camelCase `UnreadView`. */
+  async unread(group) {
+    const res = await palbeRequest(this.rt, "GET", MessagingPaths.groupUnread(group.displayId));
+    return {
+      groupMaxSeq: res.group_max_seq,
+      lastReadSeq: res.last_read_seq,
+      deliveredSeq: res.delivered_seq,
+      unreadCount: res.unread_count
+    };
+  }
 };
 function isOwnEchoOrConsumed(e) {
   const msg = e instanceof Error ? e.message : String(e);
@@ -7167,6 +7242,19 @@ var MessagingCoordinator = class {
     const r = await this.resolve();
     await r.source.markRead(group, upToServerSeq);
   }
+  // ── Server-metadata cluster: notify scope (mute) + unread ──
+  async setNotifyScope(group, scope) {
+    const r = await this.resolve();
+    return r.source.setNotifyScope(group, scope);
+  }
+  async getNotifyScope(group) {
+    const r = await this.resolve();
+    return r.source.getNotifyScope(group);
+  }
+  async unread(group) {
+    const r = await this.resolve();
+    return r.source.unread(group);
+  }
   subscribeLive(group, chat) {
     let offMsg = null;
     let offConv = null;
@@ -8106,7 +8194,7 @@ function defaultSessionStorage(key) {
 }
 
 // src/version.ts
-var VERSION = "1.6.2";
+var VERSION = "1.7.0";
 
 // src/runtime.ts
 function buildRuntime(config) {