@wix/himalaya-cli 0.1570.0 → 0.1572.0

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

@@ -9,7 +9,7 @@
 // `chatRealtime` channel, else a 4 s foreground `_poll` of `refresh`. A message from the
 // business then appears without the member leaving the screen. `load`, `setDraft` and
 // `send` keep their contract; the directives are stripped by the runtime, never state.
-import { defineService, type PollDirective, type StreamDirective } from "@himalaya/state";
+import { defineService, type PollDirective, type PollStopDirective, type StreamDirective } from "@himalaya/state";
 import { getMessages, sendChatMessage, getOrCreateDirectChatroom, getChatToken, type ChatMessage } from "@himalaya/wix-chat-web";
 import { getMyData } from "@himalaya/wix-users";
 import { formatMonthDay, formatMonthDayTime } from "../_shared/engine-intl.js";
@@ -17,7 +17,10 @@ import { initials } from "../_shared/himi-text.js";
 import { copyParam, stashCopy } from "../_shared/himi-copy.js";
 import { presence, presenceAfterError, detailInputId, type PresenceFlags } from "../_shared/detail-presence.js";
 import { writeMayHaveLanded } from "../_shared/owner-load-error.js";
-import { chatRealtimeConfig, createReloadGate, createSendIntents, createVisitToken, liveDirectives, postWithVisitToken, liveFallback, type ChatLiveMode, type ChatRealtimeConfig } from "../_shared/chat-live.js";
+import { CHAT_LIVE_POLL_ID, chatRealtimeConfig, createReloadGate, createSendIntents, createVisitToken, liveDirectives, postWithVisitToken, isTokenRejected, liveFallback, type ChatLiveMode, type ChatRealtimeConfig } from "../_shared/chat-live.js";
+
+import { memberAccess, memberAccessChanged } from "../_shared/member-access.js";
+import { readAccess, assertReadAccess, readAccessDenied, NO_READ_SIGN_IN, type ReadAccess } from "../_shared/member-read.js";
 
 const SERVICE = "spacesChatThread";
 const EMPTY_TEXT = "No messages yet. Say hello!";
@@ -31,13 +34,14 @@ interface Row {
   imageUrl: string; imageDescription: string; imageHidden: boolean; dayLabel: string; dayHidden: boolean;
 }
 interface S extends PresenceFlags {
+  threadMember: ReadAccess | null; signInRequired: boolean; noSignIn: boolean;
   status: "loading" | "ready"; messages: Row[]; emptyText: string; emptyHidden: boolean; draft: string; sendHint: string; resolvedChatroomId: string; myUserId: string;
   /** Send token for the host's transcript scroll: a new value follows the tail. */
   scrollSend: string;
   /** Which path keeps the open thread live (diagnostic). */
   live?: ChatLiveMode;
   _stream?: StreamDirective;
-  _poll?: PollDirective;
+  _poll?: PollDirective | PollStopDirective;
 }
 
 function inputId(): string {
@@ -125,15 +129,21 @@ function nextScrollToken(prev: string): string {
 // mint a token every 4 s on top of its GET. Reset on every `load`.
 const memberToken = createVisitToken(() => getChatToken({ role: "member" }).then((t) => t.chatToken));
 
-async function reload(id: string, myUserId: string): Promise<Row[]> {
+async function reload(id: string, myUserId: string, member: ReadAccess): Promise<Row[]> {
   if (!id) return [];
-  const token = memberToken.get();
-  try {
-    const msgs = await getMessages(id, 30, { role: "member", chatToken: await token });
-    return rowsOf(msgs ?? [], myUserId);
-  } catch (e) {
-    memberToken.drop(token);
-    throw e;
+  for (let attempt = 0; ; attempt++) {
+    const token = memberToken.get();
+    try {
+      const chatToken = await token;
+      await assertReadAccess(member);
+      const msgs = await getMessages(id, 30, { role: "member", chatToken });
+      return rowsOf(msgs ?? [], myUserId);
+    } catch (error) {
+      memberToken.drop(token);
+      // An expired visit token gets one fresh attempt. A repeated refusal still
+      // clears private history; checking identity before each read prevents stale retries.
+      if (attempt > 0 || !isTokenRejected(error)) throw error;
+    }
   }
 }
 
@@ -142,9 +152,13 @@ const intents = createSendIntents();
 
 /** Post once per intent: a retried tap of the same text reuses its message id, so a send
  *  that failed ambiguously and is tapped again stays one message. */
-async function postOnce(chatroomId: string, text: string): Promise<void> {
+async function postOnce(chatroomId: string, text: string, member: ReadAccess): Promise<void> {
   const messageId = intents.idFor(chatroomId, text);
-  await postWithVisitToken(memberToken, (chatToken) => sendChatMessage(chatroomId, text, { role: "member", chatToken, messageId }));
+  await postWithVisitToken(memberToken, async (chatToken) => {
+    await assertReadAccess(member);
+    if (liveState().threadMember !== member) throw memberAccessChanged();
+    return sendChatMessage(chatroomId, text, { role: "member", chatToken, messageId });
+  });
   intents.settle(chatroomId, text);
 }
 
@@ -155,7 +169,7 @@ let sendingNow = false;
 // The conversation a live re-read reads, and the channel the screen passed (if any).
 let current = { chatroomId: "", myUserId: "" };
 let realtime: ChatRealtimeConfig | null = null;
-const gate = createReloadGate(() => reload(current.chatroomId, current.myUserId));
+const gate = createReloadGate(() => reload(current.chatroomId, current.myUserId, liveState().threadMember!));
 
 /** A tick or a stream event: re-read the open conversation. A failed tick keeps the
  *  thread as it is — the next one tries again.
@@ -167,12 +181,16 @@ const gate = createReloadGate(() => reload(current.chatroomId, current.myUserId)
 async function reread(s: S): Promise<S> {
   if (!s.found || !s.resolvedChatroomId || s.resolvedChatroomId !== current.chatroomId) return s;
   try {
+    await assertThreadMember(s);
     const messages = await gate.request();
+    await assertThreadMember(s);
     const now = svc.getState();
-    if (now.resolvedChatroomId !== s.resolvedChatroomId) return now;
+    if (now.threadMember !== s.threadMember || now.resolvedChatroomId !== s.resolvedChatroomId) return now;
     return { ...now, messages, emptyText: messages.length ? "" : now.emptyText || EMPTY_TEXT, emptyHidden: messages.length > 0 };
-  } catch {
-    return svc.getState();
+  } catch (error) {
+    const now = svc.getState();
+    if (now.threadMember !== s.threadMember) return now;
+    return readAccessDenied(error) ? threadFailure(error) : now;
   }
 }
 
@@ -187,40 +205,71 @@ async function resolveMyUserId(): Promise<string> {
   try { return (await getMyData()).userId || ""; } catch { return ""; }
 }
 
+const INITIAL: S = { status: "loading", messages: [], emptyText: "", emptyHidden: true, scrollSend: "", draft: "", sendHint: "", resolvedChatroomId: "", myUserId: "", ...presence("loading"), ...NO_READ_SIGN_IN, threadMember: null };
+let loadVersion = 0;
+
+async function threadFailure(error: unknown): Promise<S> {
+  const version = loadVersion;
+  const member = await memberAccess();
+  const flags = member.email ? NO_READ_SIGN_IN : { signInRequired: true, noSignIn: false };
+  if (version !== loadVersion) return liveState();
+  current = { chatroomId: "", myUserId: "" };
+  memberToken.reset();
+  return { ...INITIAL, status: "ready", ...presenceAfterError(error), ...flags, live: "off", _poll: { id: CHAT_LIVE_POLL_ID, stop: true } };
+}
+async function assertThreadMember(s: S): Promise<void> {
+  if (!s.threadMember?.member?.email) throw new Error("Unauthenticated: sign in to read messages");
+  await assertReadAccess(s.threadMember);
+}
+
 const svc = defineService<S, {
-  load: (s: S, a?: unknown) => Promise<S>;
+  prepare: (s: S) => S;
+  load: (s: S, a?: unknown) => Promise<S | undefined>;
   setDraft: (s: S, a?: unknown) => S;
   send: (s: S) => Promise<S>;
   refresh: (s: S) => Promise<S>;
   onStreamEvent: (s: S) => Promise<S>;
   onStreamError: (s: S) => S;
 }>(SERVICE, {
-  state: { status: "loading", messages: [], emptyText: "", emptyHidden: true, scrollSend: "", draft: "", sendHint: "", resolvedChatroomId: "", myUserId: "", ...presence("loading") },
+  state: INITIAL,
   actions: {
-    load: async (s, a) => {
+    prepare: (s) => ({ ...s, ...INITIAL, _poll: { id: CHAT_LIVE_POLL_ID, stop: true } }),
+    load: async (s, a): Promise<S | undefined> => {
+      const version = ++loadVersion;
+      await svc.prepare();
+      current = { chatroomId: "", myUserId: "" };
       stashCopy(a);
       const param = (a as { chatRealtime?: unknown } | null | undefined)?.chatRealtime;
       if (param !== undefined) realtime = chatRealtimeConfig(param);
       const raw = inputId();
       // No thread / recipient id (a stale link, a route opened directly) -> the shared
       // not-found state, and no composer: there is nobody to send to.
-      if (!detailInputId()) return { ...s, status: "ready", messages: [], emptyText: "", emptyHidden: true, ...presence("missing") };
+      if (!detailInputId()) return { ...INITIAL, status: "ready", messages: [], emptyText: "", emptyHidden: true, ...presence("missing") };
       memberToken.reset();
-      // Resolve chatroom + my user id concurrently (myUserId tags own messages).
-      const [chatroomId, myUserId] = await Promise.all([resolveChatroomId(raw, inputKind()), resolveMyUserId()]);
-      // A recipient whose 1:1 chatroom could not be resolved is not a conversation yet:
-      // reload("") would return [] without throwing and publish a live, empty thread
-      // whose Send can only fail. Show the load-error line instead.
-      if (!chatroomId) return { ...s, status: "ready", resolvedChatroomId: "", myUserId, messages: [], emptyText: "", emptyHidden: true, ...presence("failed") };
       try {
-        const messages = await reload(chatroomId, myUserId);
+        const member = await readAccess();
+        if (!member.member.email) throw new Error("Unauthenticated: sign in to read messages");
+        // Resolve chatroom + my user id concurrently (myUserId tags own messages).
+        const [chatroomId, myUserId] = await Promise.all([resolveChatroomId(raw, inputKind()), resolveMyUserId()]);
+        // A recipient whose 1:1 chatroom could not be resolved is not a conversation yet:
+        // reload("") would return [] without throwing and publish a live, empty thread
+        // whose Send can only fail. Show the load-error line instead.
+        if (!chatroomId) return version === loadVersion ? { ...INITIAL, status: "ready", ...presence("failed") } : undefined;
+        const messages = await reload(chatroomId, myUserId, member);
+        await assertReadAccess(member);
+        if (version !== loadVersion) return undefined;
         current = { chatroomId, myUserId };
-        return { ...s, status: "ready", resolvedChatroomId: chatroomId, myUserId, messages, emptyText: messages.length ? "" : EMPTY_TEXT, emptyHidden: messages.length > 0, scrollSend: messages.length ? nextScrollToken(s.scrollSend) : "", ...presence("found"), ...liveDirectives(realtime, chatroomId, SERVICE) };
+        const previous = s.threadMember;
+        const sameReader = previous?.member.email === member.member.email && previous?.member.scope === member.member.scope && previous?.tenant === member.tenant;
+        const draft = sameReader && s.resolvedChatroomId === chatroomId ? s.draft : "";
+        return { ...INITIAL, draft, threadMember: member, status: "ready", resolvedChatroomId: chatroomId, myUserId, messages, emptyText: messages.length ? "" : EMPTY_TEXT, emptyHidden: messages.length > 0, scrollSend: messages.length ? nextScrollToken(s.scrollSend) : "", ...presence("found"), ...liveDirectives(realtime, chatroomId, SERVICE) };
       } catch (e) {
         // A thread whose messages cannot be read is not a live, empty conversation: a 404
         // is the shared not-found state, anything else the load-error line — never a
         // "Say hello!" composer that can only fail.
-        return { ...s, status: "ready", resolvedChatroomId: chatroomId, myUserId, messages: [], emptyText: "", emptyHidden: true, ...presenceAfterError(e) };
+        if (version !== loadVersion) return undefined;
+        const failed = await threadFailure(e);
+        return version === loadVersion ? failed : undefined;
       }
     },
     setDraft: (s, a) => ({ ...s, draft: val(a) }),
@@ -234,9 +283,14 @@ const svc = defineService<S, {
     // Every return builds on the LIVE state: the runtime replaces state wholesale, and ticks
     // or typing may have changed it while this awaited.
     send: async (s) => {
+      if (!s.found) return s;
       const text = s.draft.trim();
-      if (!text) return { ...s, sendHint: "Type a message first." };
-      if (sendingNow) return s;
+      try { await assertThreadMember(s); }
+      catch (error) { return liveState().threadMember !== s.threadMember ? liveState() : threadFailure(error); }
+      if (liveState().threadMember !== s.threadMember) return liveState();
+      const checked = liveState();
+      if (!text) return checked.draft.trim() ? checked : { ...checked, sendHint: "Type a message first." };
+      if (sendingNow) return checked;
       sendingNow = true;
       try {
         // Resolve lazily in case send() runs before load() settled.
@@ -244,8 +298,11 @@ const svc = defineService<S, {
         if (!chatroomId) chatroomId = await resolveChatroomId(inputId(), inputKind());
         if (!chatroomId) return { ...liveState(), sendHint: "Couldn't start conversation." };
         try {
-          await postOnce(chatroomId, text);
+          await postOnce(chatroomId, text, s.threadMember!);
         } catch (e) {
+          if (liveState().threadMember !== s.threadMember) return liveState();
+          try { await assertThreadMember(s); }
+          catch (error) { return threadFailure(error); }
           // Surface a short reason (the SDK rejects with "HTTP <code>: <body>") so a
           // real failure is diagnosable on-device instead of an opaque "Couldn't send".
           // A failure that may have posted anyway (a gateway timeout after the backend stored
@@ -255,6 +312,8 @@ const svc = defineService<S, {
           if (writeMayHaveLanded(e)) return { ...liveState(), resolvedChatroomId: chatroomId, sendHint: "Couldn't confirm it was sent — check before sending again." };
           return { ...liveState(), resolvedChatroomId: chatroomId, sendHint: msg ? `Couldn't send — ${msg.slice(0, 80)}` : "Couldn't send — try again." };
         }
+        await assertThreadMember(s);
+        if (liveState().threadMember !== s.threadMember) return liveState();
         // SENT. From here on nothing may say otherwise: a failed re-read must not offer a
         // second Send of a message that already posted.
         const myUserId = s.myUserId || (await resolveMyUserId());
@@ -264,18 +323,26 @@ const svc = defineService<S, {
         const cleared = (now: S): string => (now.draft.trim() === text ? "" : now.draft);
         try {
           const messages = await gate.request();
+          await assertThreadMember(s);
+          if (liveState().threadMember !== s.threadMember) return liveState();
           const now = liveState();
           return { ...now, resolvedChatroomId: chatroomId, myUserId, messages, draft: cleared(now), emptyText: "", emptyHidden: true, scrollSend: nextScrollToken(now.scrollSend), sendHint: "Sent ✓" };
-        } catch {
+        } catch (error) {
+          if (liveState().threadMember !== s.threadMember) return liveState();
+          if (readAccessDenied(error)) return threadFailure(error);
           const now = liveState();
           const local: Row = { id: `local-${now.messages.length}`, text, when: "", leadFill: " ", mine: true, notMine: false, senderBadge: "", avatarUrl: "", avatarInitials: "", imageUrl: "", imageDescription: "", imageHidden: true, dayLabel: "", dayHidden: true };
           return { ...now, resolvedChatroomId: chatroomId, myUserId, messages: [...now.messages, local], draft: cleared(now), emptyText: "", emptyHidden: true, scrollSend: nextScrollToken(now.scrollSend), sendHint: "Sent ✓" };
         }
+      } catch (error) {
+        if (liveState().threadMember !== s.threadMember) return liveState();
+        return threadFailure(error);
       } finally {
         sendingNow = false;
       }
     },
   },
 });
+svc.prepare();
 svc.load();
 export { svc };

package/templates/branded-lite/tier5-src/wix-spaces-forum-post/index.ts

@@ -7,7 +7,10 @@ import { presence, presenceAfterError, detailInputId, type PresenceFlags } from
 import { openRichLink } from "../_shared/rich-content-link.js";
 import { richBody } from "../_shared/rich-body.js";
 
+import { readAccess, assertReadAccess, readSignInFlags, NO_READ_SIGN_IN } from "../_shared/member-read.js";
+
 interface S extends PresenceFlags {
+  signInRequired: boolean; noSignIn: boolean;
   status: "loading" | "ready"; id: string; title: string; author: string; subtitle: string;
   /** The plain-text body (`contentText`): RichContent's fallback, and what shows when there is no document. */
   body: string;
@@ -26,8 +29,12 @@ function val(arg?: unknown): string {
   return typeof arg === "string" ? arg : ((arg as { value?: string; text?: string })?.value ?? (arg as { text?: string })?.text ?? "");
 }
 
+const INITIAL: S = { status: "loading", id: "", title: "", author: "", subtitle: "", body: "", bodyJson: "", hasBodyJson: false, initial: "", likeHint: "", commentText: "", commentHint: "", ...presence("loading"), ...NO_READ_SIGN_IN };
+let loadVersion = 0;
+
 const svc = defineService<S, {
-  load: (s: S) => Promise<S>;
+  prepare: (s: S) => S;
+  load: (s: S) => Promise<S | undefined>;
   like: (s: S) => Promise<S>;
   unlike: (s: S) => Promise<S>;
   setComment: (s: S, a?: unknown) => S;
@@ -35,12 +42,16 @@ const svc = defineService<S, {
   /** [rico] #3372 — RichContent's on_link: `{ url }` of the tapped link. */
   openLink: (s: S, a?: unknown) => Promise<S>;
 }>("spacesForumPost", {
-  state: { status: "loading", id: "", title: "", author: "", subtitle: "", body: "", bodyJson: "", hasBodyJson: false, initial: "", likeHint: "", commentText: "", commentHint: "", ...presence("loading") },
+  state: INITIAL,
   actions: {
-    load: async (s) => {
+    prepare: (s) => ({ ...s, ...INITIAL }),
+    load: async (s): Promise<S | undefined> => {
+      const version = ++loadVersion;
+      await svc.prepare();
       const id = detailInputId();
-      if (!id) return { ...s, status: "ready", ...presence("missing") };
+      if (!id) return { ...INITIAL, status: "ready", ...presence("missing") };
       try {
+        const access = await readAccess();
         const res = await getPost(id);
         const p = ((res as unknown as { post?: WixPost }).post) ?? (res as unknown as WixPost);
         const pp = p as unknown as { title?: string; contentText?: string; content?: unknown; writer?: { name?: string }; commentCount?: number; viewCount?: number };
@@ -56,10 +67,15 @@ const svc = defineService<S, {
         // which is the document's own text when there is no contentText.
         const { bodyJson, bodyText } = richBody(doc, legacy);
         const body = legacy || bodyText || "No content.";
-        return { status: "ready", id, title: pp.title || "Post", author, subtitle: bits.join(" · "),
+        await assertReadAccess(access);
+        if (version !== loadVersion) return undefined;
+        return { ...INITIAL, status: "ready", id, title: pp.title || "Post", author, subtitle: bits.join(" · "),
           body, bodyJson, hasBodyJson: bodyJson !== "", initial: (author[0] || "#").toUpperCase(),
           likeHint: "", commentText: "", commentHint: "", ...presence("found") };
-      } catch (e) { return { ...s, status: "ready", id, ...presenceAfterError(e) }; }
+      } catch (e) {
+        const flags = await readSignInFlags(e);
+        return version === loadVersion ? { ...INITIAL, status: "ready", id, ...presenceAfterError(e), ...flags } : undefined;
+      }
     },
     // REAL WRITE: react to / un-react to the post.
     like: async (s) => {
@@ -85,5 +101,6 @@ const svc = defineService<S, {
     openLink: async (s, a) => ((await openRichLink(a)) ? s : { ...s, commentHint: "This link could not be opened." }),
   },
 });
+svc.prepare();
 svc.load();
 export { svc };

package/templates/branded-lite/tier5-src/wix-spaces-member-detail/index.ts

@@ -14,7 +14,10 @@ import {
 } from "@himalaya/wix-members";
 import { presence, presenceAfterError, detailInputId, type PresenceFlags } from "../_shared/detail-presence.js";
 
+import { readAccess, assertReadAccess, readSignInFlags, NO_READ_SIGN_IN } from "../_shared/member-read.js";
+
 interface S extends PresenceFlags {
+  signInRequired: boolean; noSignIn: boolean;
   status: "loading" | "ready";
   id: string;
   name: string;
@@ -43,11 +46,7 @@ function followCountFor(followers: number, following: number): string {
   return followers + " Followers · " + following + " Following";
 }
 
-const svc = defineService<S, {
-  load: (s: S) => Promise<S>;
-  toggleFollow: (s: S) => Promise<S>;
-}>("spacesMemberDetail", {
-  state: {
+const INITIAL: S = {
     status: "loading",
     id: "",
     name: "",
@@ -61,13 +60,25 @@ const svc = defineService<S, {
     following: 0,
     followLabel: "Follow",
     followCount: "0 Followers · 0 Following",
-    ...presence("loading"),
-  },
+    ...presence("loading"), ...NO_READ_SIGN_IN,
+  };
+let loadVersion = 0;
+
+const svc = defineService<S, {
+  prepare: (s: S) => S;
+  load: (s: S) => Promise<S | undefined>;
+  toggleFollow: (s: S) => Promise<S>;
+}>("spacesMemberDetail", {
+  state: INITIAL,
   actions: {
-    load: async (s) => {
+    prepare: (s) => ({ ...s, ...INITIAL }),
+    load: async (s): Promise<S | undefined> => {
+      const version = ++loadVersion;
+      await svc.prepare();
       const id = detailInputId();
-      if (!id) return { ...s, status: "ready", ...presence("missing") };
+      if (!id) return { ...INITIAL, status: "ready", ...presence("missing") };
       try {
+        const access = await readAccess();
         const res = await getMember(id);
         const m = ((res as unknown as { member?: WixMember }).member) ?? (res as unknown as WixMember);
         const n = name(m);
@@ -87,8 +98,10 @@ const svc = defineService<S, {
           isFollowing = await isFollowingMember(id);
         } catch { /* default false */ }
 
+        await assertReadAccess(access);
+        if (version !== loadVersion) return undefined;
         return {
-          status: "ready",
+          ...INITIAL, status: "ready",
           id,
           name: n,
           email: m.loginEmail || "",
@@ -104,7 +117,8 @@ const svc = defineService<S, {
           ...presence("found"),
         };
       } catch (e) {
-        return { ...s, status: "ready", id, ...presenceAfterError(e) };
+        const flags = await readSignInFlags(e);
+        return version === loadVersion ? { ...INITIAL, status: "ready", id, ...presenceAfterError(e), ...flags } : undefined;
       }
     },
     // REAL WRITE: two-state toggle. Flips the relationship and optimistically
@@ -144,5 +158,6 @@ const svc = defineService<S, {
     },
   },
 });
+svc.prepare();
 svc.load();
 export { svc };

package/templates/community-club/config.ts

@@ -37,7 +37,7 @@ export default defineApp({
     actions: "http://localhost:8190/v1/actions",
     sync: "http://localhost:8190/v1/sync",
   },
-  capabilities: ["live_activity","push","share","secure_storage","open_url","calendar","local_database","wix_api","wix_platform","app_info","iap","release_control","clipboard","theme"],
+  capabilities: ["push","share","secure_storage","open_url","calendar","local_database","wix_api","wix_platform","app_info","iap","release_control","clipboard","theme","wix_cashier"],
   cache: {
     "rules": [
       {

package/templates/community-club/dev/index.ts

@@ -11262,6 +11262,9 @@ const SCREENS = runtimeSetting({
                           "style": "body",
                           "color": "textSecondary"
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiMyEvents.signInRequired"
                       }
                     },
                     {
@@ -11276,6 +11279,32 @@ const SCREENS = runtimeSetting({
                             "actionId": "tier5.himiMyEvents.load"
                           }
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiMyEvents.signInRequired"
+                      }
+                    },
+                    {
+                      "id": "himi_my_events.retry.sign_in",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Sign in",
+                          "style": "primary",
+                          "action": {
+                            "actionId": "himi.open",
+                            "params": {
+                              "screenId": "himi_sign_in",
+                              "mode": "signin",
+                              "modal": "1"
+                            },
+                            "presentation": "sheet"
+                          }
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiMyEvents.noSignIn"
                       }
                     }
                   ]
@@ -11706,7 +11735,11 @@ const SCREENS = runtimeSetting({
           "bottom": 24
         },
         "onAppear": {
-          "actionId": "tier5.himiMyEvents.load"
+          "actionId": "tier5.himiMyEvents.load",
+          "params": {
+            "signInScreenId": "himi_sign_in",
+            "memberOnly": "1"
+          }
         }
       }
     },
@@ -23137,6 +23170,9 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                           "style": "body",
                           "color": "textSecondary"
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBlogPost.signInRequired"
                       }
                     },
                     {
@@ -23151,6 +23187,32 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                             "actionId": "tier5.himiBlogPost.retry"
                           }
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBlogPost.signInRequired"
+                      }
+                    },
+                    {
+                      "id": "himi_blog_post.retry.sign_in",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Sign in",
+                          "style": "primary",
+                          "action": {
+                            "actionId": "himi.open",
+                            "params": {
+                              "screenId": "himi_sign_in",
+                              "mode": "signin",
+                              "modal": "1"
+                            },
+                            "presentation": "sheet"
+                          }
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBlogPost.noSignIn"
                       }
                     }
                   ]
@@ -23855,7 +23917,8 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
         "onAppear": {
           "actionId": "tier5.himiBlogPost.load",
           "params": {
-            "id": "__HIMI_ID__"
+            "id": "__HIMI_ID__",
+            "signInScreenId": "himi_sign_in"
           }
         }
       }

package/templates/community-club/tier5-src/_shared/branded-load-state.ts

@@ -0,0 +1,106 @@
+// Load-state honesty for the branded-lite vertical workers.
+//
+// These workers used to answer every failed or empty query with representative SAMPLE
+// rows — discount codes, gift-card balances, invoices, reservations, inbox messages —
+// under a "Sample content" banner. On a customer build that is invented data presented
+// as the customer's own: a code that does not exist, a balance in the wrong currency, an
+// "Overdue" invoice, a booking labelled "tap to cancel". The banner did not make it
+// honest; the rows were still the first thing a visitor read.
+//
+// The rule now:
+//   • query FAILED     → status "error" with a customer sentence, a Retry, and — when
+//                        Wix refused an anonymous visitor (401) — a Sign in path instead;
+//   • query was EMPTY  → status "ready", no rows, the vertical's own empty sentence;
+//   • sample rows      → ONLY when the host explicitly asked for sample data (the web
+//                        preview's sample data mode, `__himiOwnerPreview: "sample"`).
+//                        Never on a device, never as a fallback.
+//
+// Every field here is flat and boolean-gated because descriptors can only
+// `hiddenWhen(<path>)` on a TRUE value: `notErrored` hides the error card, `noSignIn`
+// hides the sign-in CTA, `signInRequired` hides Retry when retrying cannot help.
+import { copyParam } from "./himi-copy.js";
+
+export interface LoadFlags {
+  status: "loading" | "ready" | "error";
+  /** The customer-facing failure sentence; "" unless status is "error". */
+  error: string;
+  signInRequired: boolean;
+  notErrored: boolean;
+  /** hiddenWhen gate for a loading skeleton. */
+  notLoading: boolean;
+  /** Loading or failed — gates content that has nothing to say in either. */
+  busy: boolean;
+  noSignIn: boolean;
+  isMock: boolean;
+  notMock: boolean;
+  notMockEmpty: boolean;
+  notMockUnavailable: boolean;
+}
+
+export const LOADING: LoadFlags = {
+  status: "loading", error: "", signInRequired: false, notErrored: true, notLoading: false, busy: true, noSignIn: true,
+  isMock: false, notMock: true, notMockEmpty: true, notMockUnavailable: true,
+};
+
+const READY: LoadFlags = { ...LOADING, status: "ready", notLoading: true, busy: false };
+
+/** Did the HOST ask for sample data? Only the web preview's sample mode does; a native
+ *  build, a visitor preview and a live owner preview never carry it. */
+export function samplesRequested(): boolean {
+  const input = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input;
+  return input?.__himiOwnerPreview === "sample";
+}
+
+/** Wix refused an ANONYMOUS visitor: signing in is the fix, not retrying. A 403 is not
+ *  this — it also answers "feature not installed" and a signed-in member without the
+ *  permission, where a Sign in button leads nowhere — so it stays a Retry-able failure. */
+export function needsSignIn(err: unknown): boolean {
+  const msg = String((err as { message?: unknown })?.message ?? err ?? "");
+  return /\b401\b|unauthori[sz]ed|unauthenticated/i.test(msg);
+}
+
+export interface LoadCopy<T> {
+  /** The copy namespace (`giftCards`, `coupons`, …) — keys resolve through copyParam. */
+  prefix: string;
+  /** Shown when the site genuinely has none. */
+  empty: string;
+  /** Shown when the query failed. */
+  error: string;
+  /** Shown when Wix refused the visitor (member-only data). */
+  signIn: string;
+  /** Sample rows for the explicit sample preview ONLY. */
+  sample: () => T[];
+}
+
+type Rows<K extends string, T> = { [P in K]: T[] } & { emptyText: string } & LoadFlags;
+
+/** A query answered. Rows win; an empty answer is a real empty state. */
+export function loaded<K extends string, T>(key: K, rows: T[], copy: LoadCopy<T>): Rows<K, T> {
+  if (rows.length) return { ...READY, [key]: rows, emptyText: "" } as Rows<K, T>;
+  if (samplesRequested()) return sampleRows(key, copy, "empty");
+  return { ...READY, [key]: [], emptyText: copyParam(`${copy.prefix}.emptyText`, copy.empty) } as Rows<K, T>;
+}
+
+/** A query threw. Never rows the customer did not create. */
+export function loadFailed<K extends string, T>(key: K, err: unknown, copy: LoadCopy<T>): Rows<K, T> {
+  if (samplesRequested()) return sampleRows(key, copy, "unavailable");
+  const signIn = needsSignIn(err);
+  return {
+    ...READY,
+    status: "error",
+    [key]: [],
+    emptyText: "",
+    error: signIn ? copyParam(`${copy.prefix}.signInText`, copy.signIn) : copyParam(`${copy.prefix}.errorText`, copy.error),
+    signInRequired: signIn,
+    notErrored: false,
+    busy: true,
+    noSignIn: !signIn,
+  } as Rows<K, T>;
+}
+
+function sampleRows<K extends string, T>(key: K, copy: LoadCopy<T>, reason: "empty" | "unavailable"): Rows<K, T> {
+  return {
+    ...READY, [key]: copy.sample(), emptyText: "",
+    isMock: true, notMock: false, notMockEmpty: reason !== "empty", notMockUnavailable: reason !== "unavailable",
+  } as Rows<K, T>;
+}