@wix/himalaya-cli 0.1403.0 → 0.1404.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/chat-web/src/index.d.ts

@@ -5,8 +5,33 @@ declare global {
         };
     };
 }
+export type ChatWebErrorCode = "token_empty" | "token_mint_failed" | "invalid_argument" | "invalid_response";
+/** Typed failure so callers can tell "no token / bad input / bad response" from
+ *  an empty inbox.
+ *
+ *  A tagged Error, NOT a subclass (same pattern as `genieChatError`): Tier-5
+ *  bundles are built for a target that refuses `class` syntax, so this module
+ *  stays class-free. Test with `isChatWebError`, not `instanceof`. */
+export interface ChatWebError extends Error {
+    code: ChatWebErrorCode;
+    cause?: unknown;
+}
+/** Creates a typed error for token, validation, and malformed-response failures. */
+export declare function chatWebError(code: ChatWebErrorCode, message: string, cause?: unknown): ChatWebError;
+/** Returns whether a value is a typed Wix chat SDK error. */
+export declare function isChatWebError(e: unknown): e is ChatWebError;
+export type ChatRole = "owner" | "member";
+export interface ChatOptions {
+    /** `owner` (default) mints with isForUnifiedList=true; `member` with false. */
+    role?: ChatRole;
+    /** A caller-supplied chatToken; skips the mint. Never stored by this module. */
+    chatToken?: string;
+}
+/** Opaque server cursor. `0` is a valid cursor, so test for null/undefined only. */
+export type ChatCursor = number | string;
 export interface ChatMessage {
     id: string;
+    sequence?: number;
     summary?: string;
     createdAt?: number;
     sender?: {
@@ -29,18 +54,44 @@ export interface ChatMessage {
         };
     }>;
 }
-/** Fetch the recent messages for a chatroom. Verified live (200): the message
- *  LIST is chat-web **v1** with the chatToken in the QUERY (the v2 path is
- *  send-only — GET there is 405); `pageSize` is required. Returns `{items}`. */
-export declare function getMessages(chatroomId: string, pageSize?: number): Promise<ChatMessage[]>;
+export interface ChatMessagesPage {
+    items: ChatMessage[];
+    /** Raw server cursors: `before` pages Desc (older), `since` pages Asc (newer). */
+    next?: {
+        before?: ChatCursor | null;
+        since?: ChatCursor | null;
+    };
+    /** The cursor for the next page in the requested ordering; undefined = end. */
+    nextPointer?: ChatCursor;
+}
+export interface GetMessagesPageParams extends ChatOptions {
+    pageSize?: number;
+    /** Omitted = server default (what the array helper has always sent). */
+    ordering?: "Asc" | "Desc";
+    nextPointer?: ChatCursor;
+}
+/** One page of history. Verified live (200) for the plain form: chat-web **v1**,
+ *  chatToken in the QUERY, `pageSize` required. Contract (chat-sdk 24.0.40
+ *  `server-api.ts:128-139`): optional `ordering=Asc|Desc` and `nextPointer`,
+ *  response `{items, next:{before,since}}`. */
+export declare function getMessagesPage(chatroomId: string, params?: GetMessagesPageParams): Promise<ChatMessagesPage>;
+/** Fetch the recent messages for a chatroom (first page of `getMessagesPage`). */
+export declare function getMessages(chatroomId: string, pageSize?: number, options?: ChatOptions): Promise<ChatMessage[]>;
+export interface SendChatMessageOptions extends ChatOptions {
+    /** Caller-owned message id: the same id on a user retry is the same send
+     *  intent. Generated when omitted. */
+    messageId?: string;
+}
 /** Send a plain-text message to a chatroom. Verified live (200): the body is
  *  SendMessageRequest{sendMessageBody:{...,data:[{mimeType:"text/plain",data:{text}}]}}
- *  with the chatToken in the `ChatToken` HEADER (query param is rejected). */
-export declare function sendChatMessage(chatroomId: string, text: string): Promise<void>;
+ *  with the chatToken in the `ChatToken` HEADER (query param is rejected).
+ *  The send is issued exactly once — this module never retries it; a caller
+ *  that retries should pass the same `messageId`. */
+export declare function sendChatMessage(chatroomId: string, text: string, options?: SendChatMessageOptions): Promise<void>;
 /** Archive (or unarchive) a chatroom. Verified live (200): chat-web **v1**,
  *  `PUT .../chatrooms/{id}/archive|unarchive` with the chatToken in the QUERY.
  *  Used by the inbox swipe action. */
-export declare function archiveChatroom(chatroomId: string, archived?: boolean): Promise<void>;
+export declare function archiveChatroom(chatroomId: string, archived?: boolean, options?: ChatOptions): Promise<void>;
 export interface ChatMessagePreview {
     summary?: string;
     createdAt?: number;
@@ -58,6 +109,7 @@ export interface Chatroom {
     isArchived?: boolean;
     createdAt?: number;
     participantId?: string;
+    lastReadMessageSequence?: number;
     displayData?: {
         name?: string;
         image?: {
@@ -66,26 +118,68 @@ export interface Chatroom {
     };
     lastMessage?: ChatMessagePreview;
 }
-/** Mint a chatToken (required by every chat-web call). Retries ONCE on a
- *  failed/empty mint: the token endpoint occasionally returns a transient 5xx /
- *  empty body on a cold worker, which would otherwise flash an empty thread
- *  ("No messages yet") or a spurious send failure. Every chat-web call mints via
- *  this, so the single retry hardens the whole surface at the source. */
-export declare function getChatToken(): Promise<{
+/** Mint a chatToken (required by every chat-web call). Tries the mint exactly
+ *  `TOKEN_MINT_ATTEMPTS` times: the token endpoint occasionally returns a
+ *  transient 5xx / empty body on a cold worker. If every attempt throws or
+ *  returns no token this THROWS a typed `chatWebError` (`token_mint_failed` with
+ *  the last thrown cause if any attempt threw, else `token_empty`) — it never returns an empty
+ *  token, so callers cannot render a false "No messages yet". A caller-supplied
+ *  `options.chatToken` is returned as is (no network). */
+export declare function getChatToken(options?: ChatOptions): Promise<{
     chatToken: string;
 }>;
-/** List the site's inbox chatrooms (conversations). Mints a chatToken first. */
-export declare function listChatrooms(pageSize?: number): Promise<Chatroom[]>;
-/** Mark a chatroom UNREAD. Verified live (200): chat-web **v1**,
+/** List the site's inbox chatrooms (conversations). Mints a chatToken first.
+ *  The v2 GET below is the owner (unified-list) endpoint; a member list is the v1
+ *  list view, so `role: "member"` is served by `listChatroomsPage` (first page). */
+export declare function listChatrooms(pageSize?: number, options?: ChatOptions): Promise<Chatroom[]>;
+export type ParticipantType = "business" | "siteMember";
+export interface ChatroomsPage {
+    items: Chatroom[];
+    /** Cursor for the next page (`chatrooms.next.before`); undefined = end. */
+    nextPointer?: ChatCursor;
+    unreadChatroomCount?: number;
+    unreadChatroomIds?: string[];
+}
+export interface ListChatroomsPageParams extends ChatOptions {
+    /** Optional participant filter; default and `[]` = no filter (the reference
+     *  allows it: with an `isForUnifiedList=false` chatToken the server scopes the
+     *  list itself). Elements, when present, must be non-empty strings. */
+    participantIds?: string[];
+    participantType?: ParticipantType;
+    pageSize?: number;
+    nextPointer?: ChatCursor;
+    archived?: boolean;
+    onlyUnread?: boolean;
+    unreadChatroomLimit?: number;
+}
+/** One page of the v1 list view (the member list). Contract (chat-sdk 24.0.40
+ *  `server-api.ts:107-125`): `POST v1/chatrooms-for-list-view[/{participantType}]`,
+ *  chatToken + paging in the query, body `{participantIds, labelIds}` (`participantIds` may be `[]`), response
+ *  `{chatrooms:{items,next:{before}}, unreadChatroomCount, unreadChatroomIds}`.
+ *  Not yet live-verified for a member session. */
+export declare function listChatroomsPage(params?: ListChatroomsPageParams): Promise<ChatroomsPage>;
+/** Mark ONE chatroom read up to a message sequence. Contract (chat-sdk 24.0.40
+ *  `server-api.ts:268-281`): `PUT v1/chatrooms/{id}/users` body
+ *  `{lastReadMessageSequence, readMethod?}` → `{lastReadMessageSequence}`
+ *  (the old `/read` variants 404 — that is a different path). `readMethod` names
+ *  the channel, e.g. `WixMembersMobileApp` in the member reference apps.
+ *  Not yet live-verified. */
+export declare function markChatroomRead(chatroomId: string, lastReadMessageSequence: number, options?: ChatOptions & {
+    readMethod?: string;
+}): Promise<{
+    lastReadMessageSequence?: number;
+}>;
+/** Mark a chatroom UNREAD. Verified live (200) with an empty body: chat-web **v1**,
  *  `PUT .../chatrooms/{id}/unread?chatToken=<t>` → `{hasRead, unreadChatroomCount}`.
- *  NOTE there is NO public mark-READ endpoint — every `/read` variant 404s; the
- *  real Owner app auto-reads a thread on open. Used by the inbox "Mark as unread"
- *  swipe. */
-export declare function markChatroomUnread(chatroomId: string): Promise<void>;
+ *  The reference sends `{lastReadMessageSequence}` = newest unreadable message
+ *  sequence − 1 (`server-api.ts:283-287`); pass it as `lastReadMessageSequence`.
+ *  Omitted = the legacy empty body, so existing callers are unchanged. Used by the
+ *  inbox "Mark as unread" swipe. */
+export declare function markChatroomUnread(chatroomId: string, lastReadMessageSequence?: number, options?: ChatOptions): Promise<void>;
 /** Delete a chatroom entirely. Verified live (200): chat-web **v1**,
  *  `DELETE .../chatrooms/{id}?chatToken=<t>`. Used by the inbox "Delete" swipe
  *  (distinct from Archive, which is reversible). */
-export declare function deleteChatroom(chatroomId: string): Promise<void>;
+export declare function deleteChatroom(chatroomId: string, options?: ChatOptions): Promise<void>;
 export interface SocialChatroom {
     id: string;
     name?: string;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-chat-web.mjs

@@ -12,73 +12,237 @@ function uuid() {
     return v.toString(16);
   });
 }
-async function getMessages(chatroomId, pageSize = 30) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) return [];
+function chatWebError(code, message, cause) {
+  const e = new Error(`@himalaya/wix-chat-web: ${message}`);
+  e.name = "ChatWebError";
+  e.code = code;
+  if (cause !== void 0) e.cause = cause;
+  return e;
+}
+function isChatWebError(e) {
+  return !!e && typeof e === "object" && e.name === "ChatWebError";
+}
+var BASE = "https://manage.wix.com";
+var TOKEN_MINT_ATTEMPTS = 2;
+function pathSegment(value, what) {
+  if (typeof value !== "string" || !/^[^\s/\\%?#\u0000-\u001f]+$/.test(value) || value === "." || value === "..") {
+    throw chatWebError("invalid_argument", `invalid ${what}`);
+  }
+  try {
+    return encodeURIComponent(value);
+  } catch (e) {
+    throw chatWebError("invalid_argument", `invalid ${what}`, e);
+  }
+}
+function sequence(value, what) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw chatWebError("invalid_argument", `invalid ${what}`);
+  }
+  return value;
+}
+var MAX_PAGE_SIZE = 100;
+function pageSizeOf(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > MAX_PAGE_SIZE) {
+    throw chatWebError("invalid_argument", `pageSize must be an integer 1..${MAX_PAGE_SIZE}`);
+  }
+  return value;
+}
+function isCursor(v) {
+  if (typeof v === "number") return Number.isSafeInteger(v) && v >= 0;
+  if (typeof v !== "string" || v.length === 0 || v.length > 2048) return false;
+  try {
+    encodeURIComponent(v);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cursorOf(value) {
+  if (value !== void 0 && !isCursor(value)) throw chatWebError("invalid_argument", "invalid nextPointer");
+  return value;
+}
+function responseCursor(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (!isCursor(value)) throw chatWebError("invalid_response", "malformed cursor in response");
+  return value;
+}
+function requiredArray(value, what) {
+  if (!Array.isArray(value)) throw chatWebError("invalid_response", `${what} is missing or not an array`);
+  return value;
+}
+function nextOf(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "object" || Array.isArray(value)) throw chatWebError("invalid_response", "next is not an object");
+  return value;
+}
+function responseArray(value, what) {
+  if (value === void 0 || value === null) return void 0;
+  if (!Array.isArray(value)) throw chatWebError("invalid_response", `${what} is not an array`);
+  return value;
+}
+function queryString(params) {
+  return Object.keys(params).filter((k) => params[k] !== void 0 && params[k] !== null).map((k) => `${encodeURIComponent(k)}=${encodeURIComponent(String(params[k]))}`).join("&");
+}
+async function getMessagesPage(chatroomId, params = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  const size = pageSizeOf(params.pageSize === void 0 ? 30 : params.pageSize);
+  const { ordering } = params;
+  const nextPointer = cursorOf(params.nextPointer);
+  if (ordering !== void 0 && ordering !== "Asc" && ordering !== "Desc") {
+    throw chatWebError("invalid_argument", "invalid ordering");
+  }
+  const { chatToken } = await getChatToken(params);
+  const query = queryString({ chatToken, pageSize: size, ordering, nextPointer });
   const res = await wixCall(
     "GET",
-    `${BASE}/_api/chat-web/v1/chatrooms/${chatroomId}/messages?chatToken=${encodeURIComponent(chatToken)}&pageSize=${pageSize}`
+    `${BASE}/_api/chat-web/v1/chatrooms/${room}/messages?${query}`
   );
-  return res.items ?? [];
+  if (!res || typeof res !== "object") throw chatWebError("invalid_response", "history response is not an object");
+  const items = requiredArray(res.items, "items");
+  const next = nextOf(res.next);
+  const before = responseCursor(next?.before);
+  const since = responseCursor(next?.since);
+  return { items, next, nextPointer: ordering === "Asc" ? since : before };
+}
+async function getMessages(chatroomId, pageSize = 30, options = {}) {
+  return (await getMessagesPage(chatroomId, { ...options, pageSize })).items;
 }
-async function sendChatMessage(chatroomId, text) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) throw new Error("chat-web: no chatToken");
+async function sendChatMessage(chatroomId, text, options = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  if (options.messageId !== void 0 && (typeof options.messageId !== "string" || !options.messageId)) {
+    throw chatWebError("invalid_argument", "invalid messageId");
+  }
+  const id = options.messageId ?? uuid();
+  const { chatToken } = await getChatToken(options);
   await wixCall(
     "POST",
-    `${BASE}/_api/chat-web/v2/chatrooms/${chatroomId}/messages`,
-    { sendMessageBody: { id: uuid(), messageType: "message", messageTypeVersion: 1, summary: text, data: [{ mimeType: "text/plain", data: { text } }] } },
+    `${BASE}/_api/chat-web/v2/chatrooms/${room}/messages`,
+    { sendMessageBody: { id, messageType: "message", messageTypeVersion: 1, summary: text, data: [{ mimeType: "text/plain", data: { text } }] } },
     { ChatToken: chatToken }
   );
 }
-var BASE = "https://manage.wix.com";
-async function archiveChatroom(chatroomId, archived = true) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) throw new Error("chat-web: no chatToken");
+async function archiveChatroom(chatroomId, archived = true, options = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  const { chatToken } = await getChatToken(options);
   const verb = archived ? "archive" : "unarchive";
   await wixCall(
     "PUT",
-    `${BASE}/_api/chat-web/v1/chatrooms/${chatroomId}/${verb}?chatToken=${encodeURIComponent(chatToken)}`,
+    `${BASE}/_api/chat-web/v1/chatrooms/${room}/${verb}?chatToken=${encodeURIComponent(chatToken)}`,
     {}
   );
 }
-async function getChatToken() {
-  const mint = () => wixCall(
-    "POST",
-    `${BASE}/_api/wix-chat-tokens-server/v1/chat-tokens?isForUnifiedList=true`,
-    {}
-  );
-  try {
-    const r = await mint();
-    if (r?.chatToken) return r;
-  } catch {
+async function getChatToken(options = {}) {
+  if (options.chatToken !== void 0) {
+    if (typeof options.chatToken !== "string" || !options.chatToken) {
+      throw chatWebError("invalid_argument", "empty chatToken option");
+    }
+    return { chatToken: options.chatToken };
+  }
+  const role = options.role ?? "owner";
+  if (role !== "owner" && role !== "member") {
+    throw chatWebError("invalid_argument", "invalid role");
+  }
+  const unified = role === "owner";
+  let failure;
+  for (let attempt = 0; attempt < TOKEN_MINT_ATTEMPTS; attempt++) {
+    try {
+      const r = await wixCall(
+        "POST",
+        `${BASE}/_api/wix-chat-tokens-server/v1/chat-tokens?isForUnifiedList=${unified}`,
+        {}
+      );
+      if (typeof r?.chatToken === "string" && r.chatToken) return { chatToken: r.chatToken };
+    } catch (e) {
+      failure = e;
+    }
   }
-  return mint();
+  throw failure === void 0 ? chatWebError("token_empty", `chat token mint returned no token after ${TOKEN_MINT_ATTEMPTS} attempts`) : chatWebError("token_mint_failed", `chat token mint failed after ${TOKEN_MINT_ATTEMPTS} attempts`, failure);
 }
-async function listChatrooms(pageSize = 20) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) return [];
+async function listChatrooms(pageSize = 20, options = {}) {
+  if (options.role === "member") return (await listChatroomsPage({ ...options, pageSize })).items;
+  const { chatToken } = await getChatToken(options);
   const res = await wixCall(
     "GET",
     `${BASE}/_api/chat-web/v2/chatrooms?chatToken=${encodeURIComponent(chatToken)}&pageSize=${pageSize}`
   );
   return res.chatrooms?.items ?? [];
 }
-async function markChatroomUnread(chatroomId) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) throw new Error("chat-web: no chatToken");
+var LAST_MESSAGE_LIMIT = 10;
+var UNREAD_CHATROOM_LIMIT = 100;
+function unreadChatroomLimitOf(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > UNREAD_CHATROOM_LIMIT) {
+    throw chatWebError("invalid_argument", `unreadChatroomLimit must be an integer 1..${UNREAD_CHATROOM_LIMIT}`);
+  }
+  return value;
+}
+async function listChatroomsPage(params = {}) {
+  const { participantIds = [], participantType, archived, onlyUnread, unreadChatroomLimit } = params;
+  const size = pageSizeOf(params.pageSize === void 0 ? 20 : params.pageSize);
+  const nextPointer = cursorOf(params.nextPointer);
+  const unreadLimit = unreadChatroomLimit === void 0 ? UNREAD_CHATROOM_LIMIT : unreadChatroomLimitOf(unreadChatroomLimit);
+  if (!Array.isArray(participantIds) || participantIds.some((p) => typeof p !== "string" || !p)) {
+    throw chatWebError("invalid_argument", "participantIds must be an array of non-empty strings");
+  }
+  if (participantType !== void 0 && participantType !== "business" && participantType !== "siteMember") {
+    throw chatWebError("invalid_argument", "participantType must be business or siteMember");
+  }
+  const type = participantType === void 0 ? "" : `/${participantType}`;
+  const { chatToken } = await getChatToken(params);
+  const query = queryString({
+    chatToken,
+    nextPointer,
+    pageSize: size,
+    archived,
+    onlyUnread,
+    lastMessageLimit: LAST_MESSAGE_LIMIT,
+    unreadChatroomLimit: unreadLimit
+  });
+  const res = await wixCall("POST", `${BASE}/_api/chat-web/v1/chatrooms-for-list-view${type}?${query}`, { participantIds, labelIds: [] });
+  if (!res || typeof res !== "object" || !res.chatrooms || typeof res.chatrooms !== "object") {
+    throw chatWebError("invalid_response", "list response has no chatrooms");
+  }
+  const items = requiredArray(res.chatrooms.items, "chatrooms.items");
+  const next = nextOf(res.chatrooms.next);
+  const unreadChatroomIds = responseArray(res.unreadChatroomIds, "unreadChatroomIds");
+  if (res.unreadChatroomCount !== void 0 && typeof res.unreadChatroomCount !== "number") {
+    throw chatWebError("invalid_response", "unreadChatroomCount is not a number");
+  }
+  return {
+    items,
+    nextPointer: responseCursor(next?.before),
+    unreadChatroomCount: res.unreadChatroomCount,
+    unreadChatroomIds
+  };
+}
+async function markChatroomRead(chatroomId, lastReadMessageSequence, options = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  const seq = sequence(lastReadMessageSequence, "lastReadMessageSequence");
+  const body = { lastReadMessageSequence: seq };
+  if (options.readMethod !== void 0) body.readMethod = options.readMethod;
+  const { chatToken } = await getChatToken(options);
+  const res = await wixCall(
+    "PUT",
+    `${BASE}/_api/chat-web/v1/chatrooms/${room}/users?chatToken=${encodeURIComponent(chatToken)}`,
+    body
+  );
+  return { lastReadMessageSequence: res?.lastReadMessageSequence };
+}
+async function markChatroomUnread(chatroomId, lastReadMessageSequence, options = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  const body = lastReadMessageSequence === void 0 ? {} : { lastReadMessageSequence: sequence(lastReadMessageSequence, "lastReadMessageSequence") };
+  const { chatToken } = await getChatToken(options);
   await wixCall(
     "PUT",
-    `${BASE}/_api/chat-web/v1/chatrooms/${chatroomId}/unread?chatToken=${encodeURIComponent(chatToken)}`,
-    {}
+    `${BASE}/_api/chat-web/v1/chatrooms/${room}/unread?chatToken=${encodeURIComponent(chatToken)}`,
+    body
   );
 }
-async function deleteChatroom(chatroomId) {
-  const { chatToken } = await getChatToken();
-  if (!chatToken) throw new Error("chat-web: no chatToken");
+async function deleteChatroom(chatroomId, options = {}) {
+  const room = pathSegment(chatroomId, "chatroomId");
+  const { chatToken } = await getChatToken(options);
   await wixCall(
     "DELETE",
-    `${BASE}/_api/chat-web/v1/chatrooms/${chatroomId}?chatToken=${encodeURIComponent(chatToken)}`
+    `${BASE}/_api/chat-web/v1/chatrooms/${room}?chatToken=${encodeURIComponent(chatToken)}`
   );
 }
 async function getOrCreateDirectChatroom(memberId) {
@@ -99,11 +263,16 @@ async function getOrCreateDirectChatroom(memberId) {
 }
 export {
   archiveChatroom,
+  chatWebError,
   deleteChatroom,
   getChatToken,
   getMessages,
+  getMessagesPage,
   getOrCreateDirectChatroom,
+  isChatWebError,
   listChatrooms,
+  listChatroomsPage,
+  markChatroomRead,
   markChatroomUnread,
   sendChatMessage
 };

package/dist/cli.mjs

@@ -5696,8 +5696,8 @@ var init_catalog_v2 = __esm({
   "../html-to-t5/catalog.v2.json"() {
     catalog_v2_default = {
       encoding: "gzip-base64",
-      sha256: "da570183b69dd99418144d19844b226550eda25ca8f2f0ebc4e63a43fcc922f1",
-      data: "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"
+      sha256: "04187347464a18aef8f97a92444fc8541890a38c81c518f661d36a40ae6c82be",
+      data: "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"
     };
   }
 });
@@ -16808,7 +16808,6 @@ function resolveIdiom(tokens2, ctx = {}) {
 var IDIOM_CONTEXTS, UNSAFE_KEYS;
 var init_idiom = __esm({
   "../../core/ts/src/idiom.ts"() {
-    "use strict";
     IDIOM_CONTEXTS = {
       ios: { native: ["ios"] },
       android: { native: ["material"] },

package/guides/sdk-reference.json

@@ -10277,29 +10277,95 @@
     "source": "stdlib/wix-sdk/chat-web/src/index.ts",
     "description": "Web chat widget",
     "api": [
+      {
+        "name": "ChatWebErrorCode",
+        "kind": "type",
+        "jsdoc": "",
+        "decl": "export type ChatWebErrorCode = \"token_empty\" | \"token_mint_failed\" | \"invalid_argument\" | \"invalid_response\";"
+      },
+      {
+        "name": "ChatWebError",
+        "kind": "interface",
+        "jsdoc": "/** Typed failure so callers can tell \"no token / bad input / bad response\" from\n *  an empty inbox.\n *\n *  A tagged Error, NOT a subclass (same pattern as `genieChatError`): Tier-5\n *  bundles are built for a target that refuses `class` syntax, so this module\n *  stays class-free. Test with `isChatWebError`, not `instanceof`. */",
+        "decl": "export interface ChatWebError extends Error {\n  code: ChatWebErrorCode;\n  cause?: unknown;\n}"
+      },
+      {
+        "name": "chatWebError",
+        "kind": "function",
+        "jsdoc": "/** Creates a typed error for token, validation, and malformed-response failures. */",
+        "decl": "export function chatWebError(code: ChatWebErrorCode, message: string, cause?: unknown): ChatWebError;"
+      },
+      {
+        "name": "isChatWebError",
+        "kind": "function",
+        "jsdoc": "/** Returns whether a value is a typed Wix chat SDK error. */",
+        "decl": "export function isChatWebError(e: unknown): e is ChatWebError;"
+      },
+      {
+        "name": "ChatRole",
+        "kind": "type",
+        "jsdoc": "",
+        "decl": "export type ChatRole = \"owner\" | \"member\";"
+      },
+      {
+        "name": "ChatOptions",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface ChatOptions {\n  /** `owner` (default) mints with isForUnifiedList=true; `member` with false. */\n  role?: ChatRole;\n  /** A caller-supplied chatToken; skips the mint. Never stored by this module. */\n  chatToken?: string;\n}"
+      },
+      {
+        "name": "ChatCursor",
+        "kind": "type",
+        "jsdoc": "/** Opaque server cursor. `0` is a valid cursor, so test for null/undefined only. */",
+        "decl": "export type ChatCursor = number | string;"
+      },
       {
         "name": "ChatMessage",
         "kind": "interface",
         "jsdoc": "",
-        "decl": "export interface ChatMessage {\n  id: string;\n  summary?: string;\n  createdAt?: number;\n  sender?: { type?: string; userId?: string };\n  senderDisplayData?: { name?: string; initials?: string; image?: { url?: string } };\n  data?: Array<{ mimeType?: string; data?: { text?: string; uri?: string; thumbnailUrl?: string } }>;\n}"
+        "decl": "export interface ChatMessage {\n  id: string;\n  sequence?: number;\n  summary?: string;\n  createdAt?: number;\n  sender?: { type?: string; userId?: string };\n  senderDisplayData?: { name?: string; initials?: string; image?: { url?: string } };\n  data?: Array<{ mimeType?: string; data?: { text?: string; uri?: string; thumbnailUrl?: string } }>;\n}"
+      },
+      {
+        "name": "ChatMessagesPage",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface ChatMessagesPage {\n  items: ChatMessage[];\n  /** Raw server cursors: `before` pages Desc (older), `since` pages Asc (newer). */\n  next?: { before?: ChatCursor | null; since?: ChatCursor | null };\n  /** The cursor for the next page in the requested ordering; undefined = end. */\n  nextPointer?: ChatCursor;\n}"
+      },
+      {
+        "name": "GetMessagesPageParams",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface GetMessagesPageParams extends ChatOptions {\n  pageSize?: number;\n  /** Omitted = server default (what the array helper has always sent). */\n  ordering?: \"Asc\" | \"Desc\";\n  nextPointer?: ChatCursor;\n}"
+      },
+      {
+        "name": "getMessagesPage",
+        "kind": "function",
+        "jsdoc": "/** One page of history. Verified live (200) for the plain form: chat-web **v1**,\n *  chatToken in the QUERY, `pageSize` required. Contract (chat-sdk 24.0.40\n *  `server-api.ts:128-139`): optional `ordering=Asc|Desc` and `nextPointer`,\n *  response `{items, next:{before,since}}`. */",
+        "decl": "export async function getMessagesPage(chatroomId: string, params: GetMessagesPageParams = {}): Promise<ChatMessagesPage>;"
       },
       {
         "name": "getMessages",
         "kind": "function",
-        "jsdoc": "/** Fetch the recent messages for a chatroom. Verified live (200): the message\n *  LIST is chat-web **v1** with the chatToken in the QUERY (the v2 path is\n *  send-only — GET there is 405); `pageSize` is required. Returns `{items}`. */",
-        "decl": "export async function getMessages(chatroomId: string, pageSize = 30): Promise<ChatMessage[]>;"
+        "jsdoc": "/** Fetch the recent messages for a chatroom (first page of `getMessagesPage`). */",
+        "decl": "export async function getMessages(chatroomId: string, pageSize = 30, options: ChatOptions = {}): Promise<ChatMessage[]>;"
+      },
+      {
+        "name": "SendChatMessageOptions",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface SendChatMessageOptions extends ChatOptions {\n  /** Caller-owned message id: the same id on a user retry is the same send\n   *  intent. Generated when omitted. */\n  messageId?: string;\n}"
       },
       {
         "name": "sendChatMessage",
         "kind": "function",
-        "jsdoc": "/** Send a plain-text message to a chatroom. Verified live (200): the body is\n *  SendMessageRequest{sendMessageBody:{...,data:[{mimeType:\"text/plain\",data:{text}}]}}\n *  with the chatToken in the `ChatToken` HEADER (query param is rejected). */",
-        "decl": "export async function sendChatMessage(chatroomId: string, text: string): Promise<void>;"
+        "jsdoc": "/** Send a plain-text message to a chatroom. Verified live (200): the body is\n *  SendMessageRequest{sendMessageBody:{...,data:[{mimeType:\"text/plain\",data:{text}}]}}\n *  with the chatToken in the `ChatToken` HEADER (query param is rejected).\n *  The send is issued exactly once — this module never retries it; a caller\n *  that retries should pass the same `messageId`. */",
+        "decl": "export async function sendChatMessage(chatroomId: string, text: string, options: SendChatMessageOptions = {}): Promise<void>;"
       },
       {
         "name": "archiveChatroom",
         "kind": "function",
         "jsdoc": "/** Archive (or unarchive) a chatroom. Verified live (200): chat-web **v1**,\n *  `PUT .../chatrooms/{id}/archive|unarchive` with the chatToken in the QUERY.\n *  Used by the inbox swipe action. */",
-        "decl": "export async function archiveChatroom(chatroomId: string, archived = true): Promise<void>;"
+        "decl": "export async function archiveChatroom(chatroomId: string, archived = true, options: ChatOptions = {}): Promise<void>;"
       },
       {
         "name": "ChatMessagePreview",
@@ -10311,31 +10377,61 @@
         "name": "Chatroom",
         "kind": "interface",
         "jsdoc": "",
-        "decl": "export interface Chatroom {\n  id: string;\n  unreadCount?: number;\n  isArchived?: boolean;\n  createdAt?: number;\n  participantId?: string;\n  displayData?: { name?: string; image?: { url?: string } };\n  lastMessage?: ChatMessagePreview;\n}"
+        "decl": "export interface Chatroom {\n  id: string;\n  unreadCount?: number;\n  isArchived?: boolean;\n  createdAt?: number;\n  participantId?: string;\n  lastReadMessageSequence?: number;\n  displayData?: { name?: string; image?: { url?: string } };\n  lastMessage?: ChatMessagePreview;\n}"
       },
       {
         "name": "getChatToken",
         "kind": "function",
-        "jsdoc": "/** Mint a chatToken (required by every chat-web call). Retries ONCE on a\n *  failed/empty mint: the token endpoint occasionally returns a transient 5xx /\n *  empty body on a cold worker, which would otherwise flash an empty thread\n *  (\"No messages yet\") or a spurious send failure. Every chat-web call mints via\n *  this, so the single retry hardens the whole surface at the source. */",
-        "decl": "export async function getChatToken(): Promise<{ chatToken: string }>;"
+        "jsdoc": "/** Mint a chatToken (required by every chat-web call). Tries the mint exactly\n *  `TOKEN_MINT_ATTEMPTS` times: the token endpoint occasionally returns a\n *  transient 5xx / empty body on a cold worker. If every attempt throws or\n *  returns no token this THROWS a typed `chatWebError` (`token_mint_failed` with\n *  the last thrown cause if any attempt threw, else `token_empty`) — it never returns an empty\n *  token, so callers cannot render a false \"No messages yet\". A caller-supplied\n *  `options.chatToken` is returned as is (no network). */",
+        "decl": "export async function getChatToken(options: ChatOptions = {}): Promise<{ chatToken: string }>;"
       },
       {
         "name": "listChatrooms",
         "kind": "function",
-        "jsdoc": "/** List the site's inbox chatrooms (conversations). Mints a chatToken first. */",
-        "decl": "export async function listChatrooms(pageSize = 20): Promise<Chatroom[]>;"
+        "jsdoc": "/** List the site's inbox chatrooms (conversations). Mints a chatToken first.\n *  The v2 GET below is the owner (unified-list) endpoint; a member list is the v1\n *  list view, so `role: \"member\"` is served by `listChatroomsPage` (first page). */",
+        "decl": "export async function listChatrooms(pageSize = 20, options: ChatOptions = {}): Promise<Chatroom[]>;"
+      },
+      {
+        "name": "ParticipantType",
+        "kind": "type",
+        "jsdoc": "",
+        "decl": "export type ParticipantType = \"business\" | \"siteMember\";"
+      },
+      {
+        "name": "ChatroomsPage",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface ChatroomsPage {\n  items: Chatroom[];\n  /** Cursor for the next page (`chatrooms.next.before`); undefined = end. */\n  nextPointer?: ChatCursor;\n  unreadChatroomCount?: number;\n  unreadChatroomIds?: string[];\n}"
+      },
+      {
+        "name": "ListChatroomsPageParams",
+        "kind": "interface",
+        "jsdoc": "",
+        "decl": "export interface ListChatroomsPageParams extends ChatOptions {\n  /** Optional participant filter; default and `[]` = no filter (the reference\n   *  allows it: with an `isForUnifiedList=false` chatToken the server scopes the\n   *  list itself). Elements, when present, must be non-empty strings. */\n  participantIds?: string[];\n  participantType?: ParticipantType;\n  pageSize?: number;\n  nextPointer?: ChatCursor;\n  archived?: boolean;\n  onlyUnread?: boolean;\n  unreadChatroomLimit?: number;\n}"
+      },
+      {
+        "name": "listChatroomsPage",
+        "kind": "function",
+        "jsdoc": "/** One page of the v1 list view (the member list). Contract (chat-sdk 24.0.40\n *  `server-api.ts:107-125`): `POST v1/chatrooms-for-list-view[/{participantType}]`,\n *  chatToken + paging in the query, body `{participantIds, labelIds}` (`participantIds` may be `[]`), response\n *  `{chatrooms:{items,next:{before}}, unreadChatroomCount, unreadChatroomIds}`.\n *  Not yet live-verified for a member session. */",
+        "decl": "export async function listChatroomsPage(params: ListChatroomsPageParams = {}): Promise<ChatroomsPage>;"
+      },
+      {
+        "name": "markChatroomRead",
+        "kind": "function",
+        "jsdoc": "/** Mark ONE chatroom read up to a message sequence. Contract (chat-sdk 24.0.40\n *  `server-api.ts:268-281`): `PUT v1/chatrooms/{id}/users` body\n *  `{lastReadMessageSequence, readMethod?}` → `{lastReadMessageSequence}`\n *  (the old `/read` variants 404 — that is a different path). `readMethod` names\n *  the channel, e.g. `WixMembersMobileApp` in the member reference apps.\n *  Not yet live-verified. */",
+        "decl": "export async function markChatroomRead(\n  chatroomId: string,\n  lastReadMessageSequence: number,\n  options: ChatOptions & { readMethod?: string } = {},\n): Promise<{ lastReadMessageSequence?: number }>;"
       },
       {
         "name": "markChatroomUnread",
         "kind": "function",
-        "jsdoc": "/** Mark a chatroom UNREAD. Verified live (200): chat-web **v1**,\n *  `PUT .../chatrooms/{id}/unread?chatToken=<t>` → `{hasRead, unreadChatroomCount}`.\n *  NOTE there is NO public mark-READ endpoint — every `/read` variant 404s; the\n *  real Owner app auto-reads a thread on open. Used by the inbox \"Mark as unread\"\n *  swipe. */",
-        "decl": "export async function markChatroomUnread(chatroomId: string): Promise<void>;"
+        "jsdoc": "/** Mark a chatroom UNREAD. Verified live (200) with an empty body: chat-web **v1**,\n *  `PUT .../chatrooms/{id}/unread?chatToken=<t>` → `{hasRead, unreadChatroomCount}`.\n *  The reference sends `{lastReadMessageSequence}` = newest unreadable message\n *  sequence − 1 (`server-api.ts:283-287`); pass it as `lastReadMessageSequence`.\n *  Omitted = the legacy empty body, so existing callers are unchanged. Used by the\n *  inbox \"Mark as unread\" swipe. */",
+        "decl": "export async function markChatroomUnread(\n  chatroomId: string,\n  lastReadMessageSequence?: number,\n  options: ChatOptions = {},\n): Promise<void>;"
       },
       {
         "name": "deleteChatroom",
         "kind": "function",
         "jsdoc": "/** Delete a chatroom entirely. Verified live (200): chat-web **v1**,\n *  `DELETE .../chatrooms/{id}?chatToken=<t>`. Used by the inbox \"Delete\" swipe\n *  (distinct from Archive, which is reversible). */",
-        "decl": "export async function deleteChatroom(chatroomId: string): Promise<void>;"
+        "decl": "export async function deleteChatroom(chatroomId: string, options: ChatOptions = {}): Promise<void>;"
       },
       {
         "name": "SocialChatroom",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1403.0",
+  "version": "0.1404.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -71,5 +71,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "b7509775f94648b360d9d536857b7302b76b5f77e75d92853a350bc3"
+  "falconPackageHash": "cf0f67f6a26c27900f90a26c190e8ec4ecb1d22e96fb426248d86d09"
 }

package/templates/branded-lite/tier5-src/wix-spaces-chat-thread/index.ts

@@ -50,7 +50,7 @@ function norm(m: ChatMessage, i: number, myUserId: string): Row {
 }
 
 async function reload(id: string, myUserId: string): Promise<Row[]> {
-  const msgs = id ? await getMessages(id) : [];
+  const msgs = id ? await getMessages(id, 30, { role: "member" }) : [];
   return (msgs ?? []).map((m, i) => norm(m, i, myUserId));
 }
 
@@ -97,7 +97,7 @@ const svc = defineService<S, {
       if (!chatroomId) chatroomId = await resolveChatroomId(inputId(), inputKind());
       if (!chatroomId) return { ...s, sendHint: "Couldn't start conversation." };
       try {
-        await sendChatMessage(chatroomId, text);
+        await sendChatMessage(chatroomId, text, { role: "member" });
         const myUserId = s.myUserId || (await resolveMyUserId());
         const messages = await reload(chatroomId, myUserId);
         return { ...s, resolvedChatroomId: chatroomId, myUserId, messages, draft: "", emptyText: "", sendHint: "Sent ✓" };