@wix/himalaya-cli 0.904.0 → 0.905.0

package/guides/sdk-reference.json

@@ -14313,7 +14313,7 @@
         "name": "WixEvent",
         "kind": "interface",
         "jsdoc": "",
-        "decl": "export interface WixEvent {\n  id: string;\n  title?: string;\n  /** Normally one of `WixEventStatus`, but deliberately NOT narrowed to it: `decodeEvent`\n   *  fills this from the server's `status` and passes a value it does not recognise straight\n   *  through, because dropping or rewriting one would lose a real event. A union here would\n   *  be a claim this SDK cannot enforce. Compare against `WixEventStatus` when you need the\n   *  stored set; the narrowing that IS enforced is on the `statuses` filter below. */\n  eventStatus?: string;\n  /** EventType: RSVP | TICKETS | EXTERNAL | NO_REGISTRATION */\n  eventType?: string;\n  scheduling?: WixEventScheduling;\n  location?: WixEventLocation;\n  mainImage?: WixEventImage;\n  slug?: string;\n  about?: string;\n  description?: string;\n}"
+        "decl": "export interface WixEvent {\n  id: string;\n  title?: string;\n  /** Normally one of `WixEventStatus` — `UPCOMING` (published and scheduled to start),\n   *  `STARTED`, `ENDED`, `CANCELED`, `DRAFT`. Events v1 called the first of those `SCHEDULED`,\n   *  and this SDK reads v3, so a row here never carries `SCHEDULED`.\n   *\n   *  Deliberately NOT narrowed to that union: `decodeEvent` fills this from the server's\n   *  `status` and passes a value it does not recognise straight through, because dropping or\n   *  rewriting one would lose a real event. A union here would be a claim this SDK cannot\n   *  enforce. Compare against `WixEventStatus` when you need the set it knows. */\n  eventStatus?: string;\n  /** EventType: RSVP | TICKETS | EXTERNAL | NO_REGISTRATION */\n  eventType?: string;\n  scheduling?: WixEventScheduling;\n  location?: WixEventLocation;\n  mainImage?: WixEventImage;\n  slug?: string;\n  about?: string;\n  description?: string;\n}"
       },
       {
         "name": "WixGetEventListResponse",
@@ -14336,20 +14336,20 @@
       {
         "name": "EVENT_STATUSES",
         "kind": "const",
-        "jsdoc": "/** The stored event statuses — what this SDK knows the server stores, and so the only values\n *  the `statuses` filter can match. The one source for both the runtime guard and the type\n *  below, so a status added here cannot be missed by either.\n *\n *  Exported because `WixEventStatus` is declared in terms of it: the generated SDK reference\n *  ships each exported declaration verbatim, and a reader copying a type that names a symbol\n *  they cannot see gets TS2304.\n *\n *  Frozen because `as const` is erased: it makes the TYPE readonly and leaves an ordinary\n *  mutable array behind. Unexported that was academic; exported it is not — module bindings\n *  share one array object, so a `push` from any untyped caller would edit the very set\n *  `queryEvents` validates against, for every caller in that realm. The freeze makes the\n *  runtime keep the promise the type already makes. */",
-        "decl": "export const EVENT_STATUSES = Object.freeze([\"SCHEDULED\", \"STARTED\", \"ENDED\", \"CANCELED\", \"DRAFT\"] as const);"
+        "jsdoc": "/** The event statuses this SDK knows the server stores — the Events **v3** set, because that\n *  is the API `queryEvents` and `getEvent` call. `UPCOMING` is a published event that has not\n *  started; v1 called that one `SCHEDULED`, and v3 does not use that spelling at all, so a\n *  filter copied from v1 docs matches nothing. The one source for `WixEventStatus` below, so\n *  the two cannot drift.\n *\n *  Known, not exhaustive. The server owns this list and versions it — it has already been\n *  renamed once, and v3 declares an `UNKNOWN_EVENT_STATUS` of its own — so nothing here\n *  refuses a value that is absent from it. Use it to recognise a status, never to reject one.\n *\n *  Exported because `WixEventStatus` is declared in terms of it: the generated SDK reference\n *  ships each exported declaration verbatim, and a reader copying a type that names a symbol\n *  they cannot see gets TS2304.\n *\n *  Frozen because `as const` is erased: it makes the TYPE readonly and leaves an ordinary\n *  mutable array behind. Unexported that was academic; exported it is not — module bindings\n *  share one array object, so a `push` from any untyped caller would edit the set every\n *  caller in that realm reads. The freeze makes the runtime keep the promise the type makes. */",
+        "decl": "export const EVENT_STATUSES = Object.freeze([\"UPCOMING\", \"STARTED\", \"ENDED\", \"CANCELED\", \"DRAFT\"] as const);"
       },
       {
         "name": "WixEventStatus",
         "kind": "type",
-        "jsdoc": "/** One of the stored event statuses. `WixQueryEventsOptions.statuses` takes these, so a value\n *  outside the set is refused while the call is being written rather than when it is made. */",
+        "jsdoc": "/** One of the event statuses this SDK knows about. `WixQueryEventsOptions.statuses` accepts\n *  these and suggests them as you type, but does not require them — see that field. */",
         "decl": "export type WixEventStatus = (typeof EVENT_STATUSES)[number];"
       },
       {
         "name": "WixQueryEventsOptions",
         "kind": "interface",
         "jsdoc": "",
-        "decl": "export interface WixQueryEventsOptions {\n  /** Server-side WQL filter/sort for Events v3. Unlike the legacy convenience\n   * options below, these criteria are applied before paging. */\n  query?: { filter?: Record<string, unknown>; sort?: Array<{ fieldName: string; order: \"ASC\" | \"DESC\" }>; paging?: { limit?: number; offset?: number } };\n  /** Page size. */\n  limit?: number;\n  /** Page offset. */\n  offset?: number;\n  /** Status filter (e.g. `[\"SCHEDULED\"]`). Every entry must be a `WixEventStatus`; anything\n   * else is refused rather than quietly matching nothing — by the compiler for a typed caller,\n   * and at runtime for one that is not. Omitted → all statuses returned.\n   * There is no stored \"upcoming\" status; select future events by their start date.\n   * For a value the server accepts that `WixEventStatus` does not name, use `query.filter`,\n   * which is passed through to the server unchanged. */\n  statuses?: WixEventStatus[];\n  /** Sort property (the Owner list orders by \"start\"). */\n  order?: string;\n  /** Free-text title search. */\n  title?: string;\n  /** Include draft events in the result. */\n  includeDrafts?: boolean;\n}"
+        "decl": "export interface WixQueryEventsOptions {\n  /** Server-side WQL filter/sort for Events v3. Unlike the legacy convenience\n   * options below, these criteria are applied before paging. */\n  query?: { filter?: Record<string, unknown>; sort?: Array<{ fieldName: string; order: \"ASC\" | \"DESC\" }>; paging?: { limit?: number; offset?: number } };\n  /** Page size. */\n  limit?: number;\n  /** Page offset. */\n  offset?: number;\n  /** Status filter (e.g. `[\"UPCOMING\"]`), matched exactly against each row's `eventStatus`.\n   * Omitted → all statuses returned; a value no row carries selects nothing.\n   *\n   * This route is Events **v3**, whose statuses are `UPCOMING` (published and scheduled to\n   * start), `STARTED`, `ENDED`, `CANCELED` and `DRAFT`. Events v1 named the first of those\n   * `SCHEDULED`, so a filter copied from v1 docs matches no row a v3 site returns — reach\n   * for `UPCOMING` instead.\n   *\n   * The type suggests `EVENT_STATUSES` without closing on them: the server owns that list and\n   * versions it, so a value it adds later must reach the match rather than be refused on the\n   * strength of a copy that has fallen behind. A status this SDK does not know is filtered on\n   * like any other and selects the rows that carry it — or none, which is the honest answer\n   * and one a caller can read.\n   *\n   * Applied to the fetched page, after paging. To filter server-side instead, use\n   * `query.filter`, which is passed through unchanged. */\n  statuses?: Array<WixEventStatus | (string & {})>;\n  /** Sort property (the Owner list orders by \"start\"). */\n  order?: string;\n  /** Free-t\n/* … */"
       },
       {
         "name": "decodeEvent",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.904.0",
+  "version": "0.905.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": [
@@ -64,5 +64,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "abffb4fd9c21f3bdcf5e2be1c2f28ddcbd9b0f2e9fbae74755eeeac4"
+  "falconPackageHash": "4712eb68e7f2ecbd289330a1edda23126be3218b4a5869c6fecbde14"
 }

package/templates/beauty-salon/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/branded-lite/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/community-club/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/events-meetups/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/gym-fitness/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/nonprofit-cause/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];

package/templates/podcast-creator/tier5-src/himi-branded-lite-home/index.ts

@@ -20,6 +20,39 @@ import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-save
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 
+/** Latched once the member feed is refused because of WHERE the app is running rather
+ *  than because of the request — see the catch in `loadExtras`. Module scope, so it
+ *  survives every refresh of this worker and is reset only by a fresh boot. */
+let feedSurfaceRefused = false;
+
+/** True for the one refusal that can never change while the app keeps running: the web
+ *  bridge reporting that this host is not reachable from a browser at all. Deliberately
+ *  narrower than `isBridgeUnavailable` — a 502/503 is an outage worth retrying, and only
+ *  this typed refusal is permanent. */
+function isFeedSurfaceRefusal(error: unknown): boolean {
+  return /webwix_owner_only/.test(String((error as Error)?.message ?? error));
+}
+
+/** In-flight feed reads, keyed by the container they are for.
+ *
+ *  The latch alone still let ONE duplicate through: two Home refreshes that overlap both read
+ *  `feedSurfaceRefused === false` before the first rejection reaches the catch. Sharing the
+ *  request closes that window — the second refresh awaits the first instead of sending its own,
+ *  and both see the same rejection, so the latch is set exactly once.
+ *
+ *  Keyed by container, not a single slot: `active` is the most recently active group, recomputed
+ *  per refresh from a live `queryGroups`, so two overlapping refreshes can legitimately want
+ *  DIFFERENT containers. A single shared promise would hand the second one the first one's feed. */
+const feedInFlight = new Map<string, Promise<Awaited<ReturnType<typeof listFeedItems>>>>();
+
+function feedFor(containerId: string, limit: number): Promise<Awaited<ReturnType<typeof listFeedItems>>> {
+  const pending = feedInFlight.get(containerId);
+  if (pending) return pending;
+  const started = listFeedItems(containerId, limit).finally(() => { feedInFlight.delete(containerId); });
+  feedInFlight.set(containerId, started);
+  return started;
+}
+
 interface ProductFeature {
   id: string;
   name: string;
@@ -714,10 +747,10 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
         const response = await queryGroups({ paging: { limit: 12 } });
         const groups = (response.groups ?? []).filter((group) => group.id);
         if (verticals.includes("groups")) extras.groupCards = groups.slice(0, 6).map(groupCard);
-        if (verticals.includes("feed") && groups.length) {
+        if (verticals.includes("feed") && groups.length && !feedSurfaceRefused) {
           const active = groups.slice().sort((a, b) =>
             new Date(b.lastActivityDate ?? 0).getTime() - new Date(a.lastActivityDate ?? 0).getTime())[0];
-          const feed = await listFeedItems(active.id, 8);
+          const feed = await feedFor(active.id, 8);
           const profiles = feed.profiles ?? [];
           const items = (feed.feedItems ?? []).filter((item) => item.feedItemId);
           extras.feedHighlights = items.slice(0, 5).map((item) => {
@@ -742,7 +775,15 @@ async function fetchExtrasSignal(arg: unknown): Promise<ExtrasSignal> {
             }))
             .slice(0, 12);
         }
-      } catch { /* collapse silently */ }
+      } catch (error) {
+        // This particular refusal is PERMANENT, not a blip: in a browser the member feed's
+        // host cannot be reached at all, so asking again can only fail again. Retrying on
+        // every Home visit spent one doomed round trip each time and filled the error log
+        // with something nobody can act on. Latch it once and stop asking; on a phone,
+        // where the call does work, this never trips.
+        if (isFeedSurfaceRefusal(error)) feedSurfaceRefused = true;
+        /* otherwise collapse silently, as before */
+      }
     })());
   }
   await Promise.all(jobs);
@@ -893,6 +934,7 @@ function baseState(): State {
  *  let a stale failure clobber a newer success (returning `undefined` keeps the
  *  current service state; see JSRuntimeBootstrap.applyNext). */
 let refreshGen = 0;
+
 /** Last successful featured list — catch paths read this when the action's
  *  `state` snapshot was captured before a racing refresh painted products. */
 let lastFeaturedProducts: ProductFeature[] = [];