@wix/himalaya-cli 0.1498.0 → 0.1500.0

package/templates/retail-store/tier5-src/himi-store-product/index.ts

@@ -442,7 +442,7 @@ let checkoutEntered = false;
 const defineService = withIapPresentation<S>({
   adapters: SELLS_THROUGH_APPLE ? [storesProductOrders] : [],
   onCreate: commerce => { productPricing = commerce; }, prefix: "product",
-  transientKeys: ["price", "optionsIncomplete", "cartHint", "cartHidden", "buyHidden", "buyLabel", "buyDisabled", "buyNote", "purchasedNote", "addedSheetPresented", "shareHint"], contentActions: ["load", "paintCached"],
+  transientKeys: ["price", "optionsIncomplete", "cartHint", "cartHidden", "buyHidden", "buyLabel", "buyDisabled", "buyNote", "purchasedNote", "addedSheetPresented", "shareHint"], contentActions: ["load", "paintCached"], concurrentPublishActions: ["buy"],
   items: state => inputId() ? [{ reference: { kind: "storesProduct", id: inputId() }, commerceDisplayPrice: state.price }] : [],
   present: (state, price, allowed) => {
     const purchase = applePurchase(state);
@@ -885,5 +885,6 @@ const svc = defineService<S, {
   },
 });
 
+// The boot sweep loads the bound product; root onAppear refreshes it when the screen returns.
 svc.load();
 export { svc };

package/templates/retail-store/tier5-src/himi-store-saved/index.ts

@@ -36,6 +36,7 @@ function failed(s: S): S {
   return shape({ ...s, status: "error", error: copyParam("savedProducts.error", "Could not update your wishlist. Try again.") });
 }
 const defineService = withIapPresentation<S>({
+  forcePriceRefreshActions: ["load", "remove"],
   prefix: "savedProducts", transientKeys: ["rows"], contentActions: ["load", "remove"],
   items: state => state.rows.map(row => ({ reference: { kind: "storesProduct", id: row.id }, commerceDisplayPrice: row.commercePrice ?? row.price })),
   present: (state, price) => ({ ...state, rows: state.rows.map(row => {

package/templates/yoga-studio/tier5-src/_shared/himi-store-categories.ts

@@ -0,0 +1,102 @@
+// Store categories for the Branded Lite Shop chip row and the Home "Shop by category"
+// rail — one reader, so both list the same categories in the same order.
+//
+// Catalog V3 Categories first, V1 collections only when V3 THROWS (a legacy V1 site):
+// a V3 success with zero rows is an empty catalogue, and V1 on a V3 site answers 428.
+// Same rule as wix-spaces-collections; see the reasoning there.
+import { categoryImage, queryCollections, queryStoreCategories, type StoreCategoriesResponse, type StoreCategory, type WixCollection } from "@himalaya/wix-stores-collections";
+import { wixMediaUrl } from "@himalaya/wix-media";
+
+export interface StoreCategoryCard {
+  id: string;
+  name: string;
+  image: string;
+  hasImage: boolean;
+  noImage: boolean;
+}
+
+/** "All Products" is a Wix system collection — every product is in it, so it is
+ *  the Shop's own "All" chip, not a category a shopper picks. */
+const SYSTEM_NAMES = ["all products"];
+const SYSTEM_COLLECTION_IDS = ["00000000-000000-000000-000000000001"];
+
+function card(id: string, name: string, image: string): StoreCategoryCard {
+  return { id, name, image, hasImage: !!image, noImage: !image };
+}
+
+function fromCategory(c: StoreCategory): StoreCategoryCard {
+  return card(c.id ?? "", (c.name ?? "").trim(), categoryImage(c));
+}
+
+function fromCollection(c: WixCollection): StoreCategoryCard {
+  const raw = c as unknown as { id?: string; name?: string; media?: { mainMedia?: { image?: { url?: string }; thumbnail?: { url?: string } } } };
+  const media = raw.media?.mainMedia;
+  return card(raw.id ?? "", (raw.name ?? "").trim(), wixMediaUrl(media?.image?.url ?? media?.thumbnail?.url ?? ""));
+}
+
+function visible(rows: StoreCategoryCard[]): StoreCategoryCard[] {
+  const seen = new Set<string>();
+  return rows.filter((r) => {
+    if (!r.id || !r.name || SYSTEM_COLLECTION_IDS.includes(r.id) || SYSTEM_NAMES.includes(r.name.toLowerCase()) || seen.has(r.id)) return false;
+    seen.add(r.id);
+    return true;
+  });
+}
+
+const PAGE_SIZE = 50;
+const MAX_PAGES = 100;
+
+async function loadLegacyCategories(): Promise<StoreCategoryCard[]> {
+  const cards: StoreCategoryCard[] = [];
+  const seen = new Set<string>();
+  let offset = 0;
+  let total: number | undefined;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const r = await queryCollections({ query: { paging: { limit: PAGE_SIZE, offset } } });
+    const rows = r.collections ?? [];
+    const reportedTotal = r.totalResults ?? r.metadata?.total;
+    if (reportedTotal != null) total = Math.max(total ?? 0, reportedTotal);
+    if (!rows.length) {
+      if (total != null && seen.size < total) throw new Error("Category pagination is incomplete");
+      return visible(cards);
+    }
+    const priorCount = seen.size;
+    rows.forEach(row => { if (row.id) seen.add(row.id); });
+    if (page > 0 && seen.size === priorCount) throw new Error("Category pagination made no progress");
+    cards.push(...rows.filter(c => c.visible !== false).map(fromCollection));
+    offset += rows.length;
+    if (total != null ? offset >= total : rows.length < PAGE_SIZE) {
+      if (total != null && seen.size < total) throw new Error("Category pagination is incomplete");
+      return visible(cards);
+    }
+  }
+  throw new Error("Category pagination exceeded the page limit");
+}
+
+/** The store's browsable categories in site order. Rejects incomplete reads so callers
+ *  can retain their last good catalog instead of invalidating a later category. */
+export async function loadStoreCategories(): Promise<StoreCategoryCard[]> {
+  let r: StoreCategoriesResponse;
+  try {
+    r = await queryStoreCategories(PAGE_SIZE);
+  } catch { return loadLegacyCategories(); /* Only the initial failure can identify a legacy V1 site. */ }
+  const cards: StoreCategoryCard[] = [];
+  const cursors = new Set<string>();
+  const seen = new Set<string>();
+  let total = 0;
+  for (let page = 0; page < MAX_PAGES; page++) {
+    const categories = r.categories ?? [];
+    categories.forEach(c => { if (c.id) seen.add(c.id); });
+    total = Math.max(total, r.pagingMetadata?.total ?? 0);
+    cards.push(...categories.filter(c => c.visible !== false).map(fromCategory));
+    const next = r.pagingMetadata?.cursors?.next;
+    if (!next) {
+      if (seen.size < total) throw new Error("Category pagination is incomplete");
+      return visible(cards);
+    }
+    if (cursors.has(next)) throw new Error("Category pagination repeated a cursor");
+    cursors.add(next);
+    if (page + 1 < MAX_PAGES) r = await queryStoreCategories(PAGE_SIZE, next);
+  }
+  throw new Error("Category pagination exceeded the page limit");
+}

package/templates/yoga-studio/tier5-src/_shared/iap-presentation.ts

@@ -11,46 +11,189 @@ export function withIapPresentation<S extends object>(options: {
   onCreate?(commerce: IapCommerce): void;
   onContent?(state: S): void;
   items(state: S): IapCatalogItem[];
-  present(state: S, price: (id: string, commercePrice?: string) => string, allowed: (id: string) => boolean): S;
+  present(state: S, price: (id: string, commercePrice?: string) => string, allowed: (id: string) => boolean, appleIapOrResolving: (id: string) => boolean): S;
   contentActions: string[];
+  /** Defaults to load/refresh/retry; mutations can explicitly request fresh mapping. */
+  forcePriceRefreshActions?: string[];
+  concurrentPublishActions?: string[];
+  /** Override the commerce factory in focused worker tests. */
+  commerceFactory?: typeof createIapCommerce;
   transientKeys: (keyof S & string)[];
   prefix: string;
 }): typeof defineService {
   return ((name: string, definition: ServiceDefinition<S>) => {
-    const commerce = createIapCommerce({ adapters: options.adapters, onChange: () => { void service.iapPublish(); } });
+    let queuePublish = () => {};
+    const commerce = (options.commerceFactory ?? createIapCommerce)({ adapters: options.adapters, onChange: () => queuePublish() });
     options.onCreate?.(commerce);
     let items: IapCatalogItem[] = [];
+    let loadedItemsKey = "";
+    const settledViews = new Map<string, { commerceDisplayPrice?: string; view: ReturnType<IapCommerce["pricing"]["view"]> }>();
+    const forcePriceRefreshActions = new Set(options.forcePriceRefreshActions ?? options.contentActions.filter(action => ["load", "refresh", "retry"].includes(action)));
     let contentVersion = 0;
-    const project = (state: S): S => {
+    let actionVersion = 0;
+    let activeActions = 0;
+    let activeConcurrentPublishActions = 0;
+    let actionWaiters: Array<() => void> = [];
+    let publishQueued = false;
+    // pollDirective() arms its interval as a side effect. Keep a directive from a
+    // projection that loses a commit race so the retry can still publish it.
+    let uncommittedPollDirective: ReturnType<IapCommerce["pollDirective"]>;
+    let uncommittedPollVersion = 0;
+    // The committed state, read when a publish runs. Assigned once the service exists, so the
+    // service's own initializer never refers to it.
+    let committed: () => S = () => definition.state;
+    queuePublish = () => {
+      if (publishQueued) return;
+      publishQueued = true;
+      // Tier-5 workers have no timer globals. A microtask is enough here: if the
+      // action that caused the price update is still in flight, iapPublish's
+      // action-version check queues another publish after that action commits.
+      const publish = () => {
+        publishQueued = false;
+        void service.iapPublish();
+      };
+      void Promise.resolve().then(publish);
+    };
+    const project = (state: S, retainedPoll?: ReturnType<IapCommerce["pollDirective"]>): S => {
+      const presentationView = (id: string, commercePrice?: string) => {
+        const item = items.find(item => item.reference.id === id);
+        const reference = item?.reference ?? { kind: "storesProduct", id };
+        const key = `${reference.kind}:${reference.id}`;
+        const current = commerce.pricing.view(reference);
+        const cached = settledViews.get(key);
+        const displayPrice = commercePrice ?? item?.commerceDisplayPrice;
+        if (current.route === "resolving" && cached && cached.commerceDisplayPrice === displayPrice) return cached.view;
+        if (current.route !== "resolving" && item) settledViews.set(key, { commerceDisplayPrice: item.commerceDisplayPrice, view: current });
+        return current;
+      };
       const price = (id: string, commercePrice?: string) => {
         const item = items.find(item => item.reference.id === id);
         if (!item) return "";
-        const view = commerce.pricing.view(item.reference);
+        const view = presentationView(id, commercePrice);
+        if (view.route === "resolving") return iapPriceCopy(options.prefix).loading;
         return view.route === "disabled" || view.route === "regular" ? commercePrice ?? item.commerceDisplayPrice ?? "" : iapPriceFields(view, iapPriceCopy(options.prefix)).priceText;
       };
       const allowed = (id: string) => commerce.pricing.checkoutGuard({ kind: "storesProduct", id }).allowed;
-      const poll = commerce.pollDirective(`${name}.iapPoll`);
-      return { ...options.present(state, price, allowed), ...(poll ? { _poll: poll } : {}) };
+      const appleIapOrResolving = (id: string) => ["appleIap", "resolving", "unavailable"].includes(presentationView(id).route);
+      // Re-evaluate the cadence first. A checkout can enter/leave due work while a prior
+      // projection is waiting to retry; a fresh directive supersedes the retained one.
+      const poll = commerce.pollDirective(`${name}.iapPoll`) ?? retainedPoll;
+      return { ...options.present(state, price, allowed, appleIapOrResolving), ...(poll ? { _poll: poll } : {}) };
     };
-    const actions = Object.fromEntries(Object.entries(definition.actions ?? {}).map(([action, reduce]) => [action, async (state: S, ...args: never[]) => {
+    const mergeConcurrent = (before: S, next: S, current: S): S => {
+      if (current === before) return next;
+      const merged = { ...current } as Record<string, unknown>;
+      const previous = before as Record<string, unknown>;
+      const changed = next as Record<string, unknown>;
+      for (const key of new Set([...Object.keys(previous), ...Object.keys(changed)])) {
+        if (JSON.stringify(previous[key]) === JSON.stringify(changed[key])) continue;
+        if (Object.prototype.hasOwnProperty.call(changed, key)) merged[key] = changed[key];
+        else delete merged[key];
+      }
+      return merged as S;
+    };
+    const actions = Object.fromEntries(Object.entries(definition.actions ?? {}).map(([action, reduce]) => [action, (state: S, ...args: never[]) => {
+      actionVersion++;
+      activeActions++;
+      const concurrentPublish = options.concurrentPublishActions?.includes(action) ?? false;
+      if (concurrentPublish) activeConcurrentPublishActions++;
       const content = options.contentActions.includes(action);
       const version = action === "load" ? ++contentVersion : contentVersion;
-      const next = await reduce(state, ...args);
-      if (!next || (content && version !== contentVersion)) return undefined;
-      if (content) {
-        options.onContent?.(next);
-        items = options.items(next);
-        void commerce.loadPrices(items);
+      const presentResult = (next: S | undefined) => {
+        // scopeLanded is the completion of the active load, not a stale load result. It
+        // must publish even if another overlapping onAppear load advanced contentVersion.
+        if (!next || (content && action !== "scopeLanded" && version !== contentVersion)) return undefined;
+        if (content) {
+          options.onContent?.(next);
+          const nextItems = options.items(next);
+          // This is an order-independent identity key, not display text. Default
+          // string ordering is deterministic on every worker engine, including QuickJS.
+          const nextItemsKey = JSON.stringify(nextItems.map(item => JSON.stringify([item.reference.kind, item.reference.id, item.commerceDisplayPrice]))
+            .sort());
+          items = nextItems;
+          const forcePriceRefresh = forcePriceRefreshActions.has(action);
+          if (forcePriceRefresh) settledViews.clear();
+          if (nextItemsKey !== loadedItemsKey || forcePriceRefresh) {
+            loadedItemsKey = nextItemsKey;
+            void commerce.loadPrices(items);
+          }
+        }
+        // Checkout preserves prices published while it ran.
+        return project(concurrentPublish ? mergeConcurrent(state, next, committed()) : next);
+      };
+      const finished = () => {
+        activeActions--;
+        if (concurrentPublish) activeConcurrentPublishActions--;
+        const waiters = actionWaiters;
+        actionWaiters = [];
+        for (const resolve of waiters) resolve();
+      };
+      try {
+        const next = reduce(state, ...args);
+        // Keep synchronous sidecars synchronous. Adding an await lets their old
+        // catalog snapshot commit after a newer asynchronous refresh.
+        if (content || (next && typeof (next as Promise<S | undefined>).then === "function")) {
+          return (async () => {
+            try { return presentResult(await next); }
+            finally { finished(); }
+          })();
+        }
+        const result = presentResult(next as S | undefined);
+        finished();
+        return result;
+      } catch (error) {
+        finished();
+        throw error;
       }
-      return project(next);
     }]));
     const service = (options.register ?? defineService)(name, {
       // The collection's shown page goes with the rows and chrome it copies: kept out of the restore with them.
       ...definition, notHydrated: [...(definition.notHydrated ?? []), ...options.transientKeys,
         ...((options.transientKeys as string[]).includes('collection') ? ['collectionShown' as keyof S & string] : [])],
-      actions: { ...actions, iapPublish: project, iapPoll: async () => { await commerce.poll(); return undefined; },
+      // Prices land on their own clock, and a commit replaces the whole state — so a publish
+      // can carry a snapshot that an in-flight commit (a page that just landed, a tap) has
+      // since replaced. Project the state as it is now, and publish only when the prices
+      // actually change it: with no App Store mapping, or prices already shown, there is
+      // nothing to publish and nothing to overwrite.
+      actions: { ...actions, iapPublish: async () => {
+        // Checkout actions publish their busy phase while running. Every other action
+        // finishes before we take a projection, so it cannot erase a reducer's result.
+        for (;;) {
+          if (activeActions > activeConcurrentPublishActions) await new Promise<void>(resolve => actionWaiters.push(resolve));
+          await Promise.resolve();
+          const version = actionVersion;
+          await Promise.resolve();
+          if (activeActions <= activeConcurrentPublishActions && version === actionVersion) break;
+        }
+        const current = committed();
+        // The runtime commits an action's result just after this wrapper returns. If a
+        // scope action lands while prices are being projected, publishing this snapshot
+        // would put the older scope back on top. Drop it and retry against the commit.
+        const retainedPollVersion = uncommittedPollVersion;
+        const retainedPoll = uncommittedPollDirective;
+        const next: S & { _poll?: unknown } = project(current, retainedPoll);
+        await Promise.resolve();
+        if (committed() !== current) {
+          // Overlapping retries can race too: a projection with no new directive must
+          // not erase one another already retained after pollDirective() armed itself.
+          if (next._poll) {
+            uncommittedPollDirective = next._poll as ReturnType<IapCommerce["pollDirective"]>;
+            uncommittedPollVersion++;
+          }
+          queuePublish();
+          return undefined;
+        }
+        // Another concurrent projection may have retained a newer directive since this
+        // snapshot. Clear only the exact retained generation this successful commit used.
+        if (next._poll && retainedPollVersion === uncommittedPollVersion && retainedPoll === uncommittedPollDirective) {
+          uncommittedPollDirective = undefined;
+          uncommittedPollVersion++;
+        }
+        return !next._poll && JSON.stringify(next) === JSON.stringify(current) ? undefined : next;
+      }, iapPoll: async () => { await commerce.poll(); return undefined; },
         iapRefresh: async () => { await commerce.loadPrices(items); return undefined; } },
     });
+    committed = () => (service as unknown as { getState(): S }).getState();
     resetUnhydratedKeysOnOlderRuntime(service, definition.state, options.transientKeys);
     return service;
   }) as unknown as typeof defineService;

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

@@ -2,6 +2,7 @@ import { fetchMemberBookings, type MemberBookingRow } from "../_shared/member-bo
 import { hostSiteFromInput, hostedExploreCards, hostedHiddenFlags, type HostedExploreCard } from "../_shared/branded-lite-hosted.js";
 import { memberAccess, assertMemberAccess } from "../_shared/member-access.js";
 import { defineService as registerHome } from "../_shared/home-service.js";
+import { navigate } from "@himalaya/state";
 import { withIapPresentation } from "../_shared/iap-presentation.js";
 import { queryServices, type WixService } from "@himalaya/wix-bookings";
 import { getPost, queryPosts, type WixPost } from "@himalaya/wix-blog";
@@ -20,6 +21,7 @@ import { parseWeeklyGoal, weeklyGoalProgress, weeklySessionsFromPages } from "..
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { formatDateMedium } from "../_shared/engine-intl.js";
 import { readSavedProducts, type SavedProduct } from "../_shared/himi-store-saved.js";
+import { loadStoreCategories, type StoreCategoryCard } from "../_shared/himi-store-categories.js";
 import { readSavedIds } from "../_shared/himi-blog-saved.js";
 import { wixMediaUrl } from "@himalaya/wix-media";
 import { isWixVideoWebRefusal, listLatestVideos, videoCard, type WixVideoCard } from "@himalaya/wix-video";
@@ -270,6 +272,9 @@ interface State {
   noHeroImage: boolean;
   hasFeaturedProducts: boolean;
   noFeaturedProducts: boolean;
+  /** The store's categories for the "Shop by category" rail; each opens Shop on that chip. */
+  homeCategories: StoreCategoryCard[];
+  noHomeCategories: boolean;
   /** Schedule-only trainingFirst fields (design §4.1). They remain empty until
    *  a dated availability source can back them; collapse gates hide them. */
   todaysClasses: ClassEntry[];
@@ -857,6 +862,7 @@ function derive(state: State): State {
     noHeroImage: !hasHeroImage,
     hasFeaturedProducts: state.featuredProducts.length > 0,
     noFeaturedProducts: state.featuredProducts.length === 0,
+    noHomeCategories: (state.homeCategories ?? []).length === 0,
     noSavedProducts: state.savedProducts.length === 0,
     noSavedPosts: state.savedPosts.length === 0,
     noSavedContent: state.savedProducts.length === 0 && state.savedPosts.length === 0,
@@ -950,6 +956,8 @@ function baseState(): State {
     noHeroImage: true,
     hasFeaturedProducts: false,
     noFeaturedProducts: true,
+    homeCategories: [],
+    noHomeCategories: true,
     todaysClasses: [],
     noTodaysClasses: true,
     coachAvatars: [],
@@ -998,6 +1006,7 @@ 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[] = [];
+let lastHomeCategories: StoreCategoryCard[] = [];
 
 async function refreshPublic(state: State, arg?: unknown): Promise<State | undefined> {
   // Absorb the descriptor's copy-pack overrides (if any) before any string is
@@ -1034,6 +1043,21 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       effectiveLayout: resolveEffectiveLayout(arg, 0),
     });
   }
+  // Categories ride beside the products; a failed read only hides their rail. Started
+  // outside the try, and merged as a separate action so a slow categories endpoint cannot
+  // hold the primary products rail behind it. Offline on a cold boot the module copy is
+  // still empty: fall back to the rail the state restored.
+  let categoriesResolved = false;
+  let resolvedCategories: StoreCategoryCard[] = [];
+  const categoriesRead = loadStoreCategories().catch(() => (lastHomeCategories.length ? lastHomeCategories : state.homeCategories ?? []));
+  void categoriesRead.then((homeCategories) => {
+    categoriesResolved = true;
+    resolvedCategories = homeCategories;
+    if (gen === refreshGen) {
+      lastHomeCategories = homeCategories;
+      void svc.categoriesLoaded({ generation: gen, categories: homeCategories });
+    }
+  });
   try {
     const response = await queryStoreProducts(50);
     if (gen !== refreshGen) return undefined;
@@ -1051,6 +1075,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       welcome: welcome(),
       refreshedAt: new Date().toISOString(),
       featuredProducts,
+      homeCategories: categoriesResolved ? resolvedCategories : state.homeCategories ?? [],
       ...bookings,
       ...extras,
       ...saved,
@@ -1075,6 +1100,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
       // genuine store outage still raises the banner.
       isErrored: keptProducts.length === 0 && !isBridgeUnavailable(e),
       featuredProducts: keptProducts,
+      homeCategories: categoriesResolved ? resolvedCategories : state.homeCategories ?? [],
       welcome: welcome(),
       refreshedAt: new Date().toISOString(),
       ...bookings,
@@ -1087,6 +1113,7 @@ async function refreshPublic(state: State, arg?: unknown): Promise<State | undef
 }
 
 let personalGeneration = 0;
+let shopCategoryActivation = 0;
 function memberSchedule(rows: MemberBookingRow[], now = new Date()): { label: string; fraction: number } {
   const weekStart = new Date(now);
   const day = (weekStart.getDay() + 6) % 7;
@@ -1184,20 +1211,33 @@ const svc = defineService<State, {
   refresh: (state: State, arg?: unknown) => Promise<State | undefined>;
   dismissOnboarding: (state: State) => State;
   clearPersonal: (state: State) => State;
+  openShopCategory: (state: State, arg?: unknown) => State;
   personalLoaded: (state: State, arg: { generation: number; rows: MemberBookingRow[]; progress: { label: string; fraction: number }; error: boolean; weekly: { count: number; fraction: number; label: string } | null }) => State;
+  categoriesLoaded: (state: State, arg: { generation: number; categories: StoreCategoryCard[] }) => State | undefined;
 }>("himiBrandedHome", {
   state: baseState(),
   // The host's site is read fresh at every boot: a snapshot of the last session's site must not
   // decide this one's verticals or name (an owner installs or removes one; another site opens).
-  notHydrated: ["hosted", "hostedName", "hostedCards"],
+  notHydrated: ["hosted", "hostedName", "hostedCards", "homeCategories", "noHomeCategories"],
   actions: {
     clearPersonal: state => derive({ ...state, nextBooking: [], hideNextBooking: true, memberProgressLabel: "", memberProgressFraction: 0, hideMemberProgress: true, personalError: false, hidePersonalError: true,
       weeklyClassCount: 0, weeklyClassGoalFraction: 0, weeklyGoalLabel: "" }),
+    openShopCategory: (state, arg) => {
+      const category = String((arg as { category?: unknown } | undefined)?.category ?? "");
+      if (!category) return state;
+      shopCategoryActivation++;
+      // Nav params are strings and the activation nonce is a transient route event,
+      // not a distinct Shop record. ScreenHost forwards these live params to onAppear
+      // when a pooled worker is reused.
+      const activation = `${Date.now()}-${shopCategoryActivation}`;
+      return navigate(state, { screenId: "himi_shop", args: { category, categoryId: category, categoryActivation: activation } });
+    },
     personalLoaded: (state, arg) => arg.generation !== personalGeneration ? state : derive({ ...state,
       nextBooking: arg.rows, hideNextBooking: !arg.rows.length,
       memberProgressLabel: arg.progress.label, memberProgressFraction: arg.progress.fraction, hideMemberProgress: !arg.progress.label,
       personalError: arg.error, hidePersonalError: !arg.error,
       weeklyClassCount: arg.weekly?.count ?? 0, weeklyClassGoalFraction: arg.weekly?.fraction ?? 0, weeklyGoalLabel: arg.weekly?.label ?? "" }),
+    categoriesLoaded: (state, arg) => arg.generation !== refreshGen ? undefined : derive({ ...state, homeCategories: arg.categories }),
     refresh,
     // "Got it" on the first-run card: persist + hide. Persistence is
     // best-effort — the UI hides either way for this session.
@@ -1213,7 +1253,7 @@ const svc = defineService<State, {
 // name. In place, because on those runtimes getState() IS the stored state (as himi-player-home does).
 if ((globalThis as { himalaya?: { hydrationOptOut?: unknown } }).himalaya?.hydrationOptOut !== true) {
   const live = (svc as { getState?: () => State | undefined }).getState?.();
-  if (live && typeof live === "object") Object.assign(live, hostedBoot);
+  if (live && typeof live === "object") Object.assign(live, hostedBoot, { homeCategories: [], noHomeCategories: true });
 }
 
 svc.refresh();

package/templates/beauty-salon/tier5-src/_shared/himi-store-collection.ts

@@ -1,22 +0,0 @@
-import { withCollectionSaving, type CollectionSaving } from './collection-service.js';
-import { readSavedProducts, writeSavedProducts } from './himi-store-saved.js';
-
-export const storeCollectionSaving: CollectionSaving = {
-  read: () => readSavedProducts().map(row => row.id),
-  write(ids, rows) {
-    const products = new Map(readSavedProducts().map(row => [row.id, row]));
-    for (const row of rows) {
-      if (typeof row.id !== 'string' || typeof row.name !== 'string') continue;
-      const previous = products.get(row.id);
-      const freshPrice = typeof row.commercePrice === 'string' ? row.commercePrice : typeof row.subtitle === 'string' ? row.subtitle : '';
-      const wasPrice = typeof row.wasPrice === 'string' ? row.wasPrice || undefined : previous?.price === freshPrice ? previous?.wasPrice : undefined;
-      products.set(row.id, { ...previous, wasPrice, id: row.id, name: row.name,
-        price: freshPrice || previous?.price || '',
-        image: typeof row.image === 'string' && row.image ? row.image : previous?.image ?? '' });
-    }
-    const selected = ids.map(id => products.get(id));
-    if (selected.some(row => !row)) throw new Error('Saved product metadata is unavailable');
-    writeSavedProducts(selected.filter((row): row is NonNullable<typeof row> => !!row));
-  },
-};
-export const defineService = withCollectionSaving(storeCollectionSaving);