@wix/himalaya-cli 0.1320.0 → 0.1322.0

package/templates/retail-store/tier5-src/wix-spaces-collection-detail/index.ts

@@ -1,5 +1,15 @@
 // Tier-5 bundle: Wix Spaces clone — Collection detail (ON-DEVICE, site-scoped).
 // Prefer Catalog V3 `getStoreCategory`; V1 `getCollection` 428s on CATALOG_V3 sites.
+//
+// #4155 — the screen showed the category header ("N products") and never the products.
+// Once the category resolves, its products load through `searchStoreProducts({ categoryId })`
+// with the same row shape as `himi-store-shop`, so a category reads as a filtered Shop.
+//
+// Two lifecycles, deliberately kept apart:
+//   • the CATEGORY — presence flags (loading / found / missing / failed), as every detail screen;
+//   • its PRODUCTS — a cursor-paged list (`createCollectionQuery`) with its own loading, failed
+//     and empty states. A product read that fails leaves a FOUND category found: the header
+//     stays and the list offers a retry. It never turns into "Category not found".
 import { defineService } from "@himalaya/state";
 import {
   categoryCount,
@@ -8,46 +18,152 @@ import {
   type WixCollection,
 } from "@himalaya/wix-stores-collections";
 import { presence, presenceAfterError, detailInputId, type PresenceFlags } from "../_shared/detail-presence.js";
+import { createCollectionQuery, type CollectionQueryState } from "../_shared/collection-query.js";
+import { productImage, productPrice, searchStoreProducts, type StoreProduct } from "../_shared/himi-store.js";
+import { cleanTitle, initials } from "../_shared/himi-text.js";
 
-interface S extends PresenceFlags { status: "loading" | "ready"; name: string; subtitle: string; description: string }
+interface Row {
+  id: string;
+  name: string;
+  subtitle: string;
+  image: string;
+  initial: string;
+  hasImage: boolean;
+  noImage: boolean;
+  detailScreenId: string;
+}
 
+interface S extends PresenceFlags {
+  status: "loading" | "ready";
+  name: string;
+  subtitle: string;
+  description: string;
+  /** Which `load` the committed state belongs to — a products snapshot is only ever
+   *  projected onto the category it was fetched for. */
+  loadId: number;
+  products: Row[];
+  /** Load-more cursor — non-empty while another page exists and none is in flight. */
+  productsCursor: string;
+  hideProducts: boolean;
+  hideProductsLoading: boolean;
+  /** Gates the products retry block (the category's own failure is `hideLoadError`). */
+  productsNotErrored: boolean;
+  /** Gates the "next page failed" retry under the list. A failed load-more keeps the rows
+   *  and clears the cursor, so without this the list would just stop and read as complete. */
+  productsNoPageError: boolean;
+  /** One plain line for a screen that has no dedicated empty / error blocks ("" otherwise). */
+  productsMessage: string;
+  /** Gates the "no products in this category" block (screen-kit `emptyBlock` reads `noEmpty`). */
+  noEmpty: boolean;
+}
 
-const svc = defineService<S, { load: (s: S) => Promise<S> }>("spacesCollectionDetail", {
-  state: { status: "loading", name: "", subtitle: "", description: "", ...presence("loading") },
+/** The same row `himi-store-shop` emits, so the screen reuses the Shop tile. */
+function row(p: StoreProduct): Row {
+  const name = cleanTitle(p.name) || "Product";
+  const image = productImage(p);
+  return {
+    id: p.id ?? "",
+    name,
+    subtitle: productPrice(p),
+    image,
+    initial: initials(name),
+    hasImage: !!image,
+    noImage: !image,
+    detailScreenId: "himi_product",
+  };
+}
+
+let categoryId = "";
+let loadId = 0;
+const products = createCollectionQuery<Row>({
+  id: (item) => item.id,
+  async fetch(_criteria, cursor) {
+    const response = await searchStoreProducts({ categoryId, limit: 50, cursor: cursor || undefined });
+    return {
+      items: (response.products ?? []).map(row).filter((item) => !!item.id),
+      nextCursor: response.pagingMetadata?.cursors?.next ?? "",
+      total: response.pagingMetadata?.total,
+    };
+  },
+}, () => { void svc.productsChanged(); });
+
+/** Project the products snapshot onto a state whose category is FOUND. Anything else
+ *  (loading, missing, failed) shows no product UI at all. */
+function withProducts(s: S, page: CollectionQueryState<Row> = products.getState()): S {
+  const found = s.found;
+  const items = found ? page.items : [];
+  const loading = page.status === "idle" || page.status === "loading";
+  return {
+    ...s,
+    products: items,
+    productsCursor: found && !page.pageError && !page.loadingMore ? page.nextCursor : "",
+    hideProducts: items.length === 0,
+    hideProductsLoading: !(found && loading && items.length === 0),
+    productsNotErrored: !(found && page.status === "error"),
+    productsNoPageError: !(found && page.pageError),
+    noEmpty: !(found && page.status === "ready" && items.length === 0),
+    productsMessage: !found ? ""
+      : page.status === "error" || page.pageError ? "Products couldn't load. Pull to refresh to try again."
+        : page.status === "ready" && items.length === 0 ? "No products in this category yet." : "",
+  };
+}
+
+const NO_PRODUCTS = { products: [], productsCursor: "", hideProducts: true, hideProductsLoading: true,
+  productsNotErrored: true, productsNoPageError: true, noEmpty: true, productsMessage: "" };
+
+const initial: S = { status: "loading", name: "", subtitle: "", description: "", loadId: 0, ...NO_PRODUCTS, ...presence("loading") };
+
+/** The category header for `id`: V3 category first, V1 collection as the fallback. */
+async function readCategory(id: string): Promise<Pick<S, "name" | "subtitle" | "description">> {
+  try {
+    const c = (await getStoreCategory(id)).category;
+    if (c?.id || c?.name) return { name: c.name || "Category", subtitle: categoryCount(c), description: c.description || "" };
+  } catch { /* fall through to V1 */ }
+  const res = await getCollection(id);
+  const c = (((res as unknown as { collection?: WixCollection }).collection) ?? (res as unknown as WixCollection)) as unknown as {
+    name?: string; numberOfProducts?: number; description?: string;
+  };
+  const n = c.numberOfProducts;
+  return {
+    name: c.name || "Collection",
+    subtitle: n != null ? `${n} ${n === 1 ? "product" : "products"}` : "",
+    description: c.description || "",
+  };
+}
+
+const svc = defineService<S, {
+  load: (s: S) => Promise<S | undefined>;
+  productsChanged: (s: S) => S | undefined;
+  loadMoreProducts: (s: S) => Promise<undefined>;
+  retryProducts: (s: S) => Promise<undefined>;
+}>("spacesCollectionDetail", {
+  state: initial,
+  // A cold boot must not paint another category's products from last run's snapshot.
+  notHydrated: ["products", "productsCursor", "hideProducts", "hideProductsLoading", "productsNotErrored", "productsNoPageError", "noEmpty", "productsMessage", "loadId"],
   actions: {
     load: async (s) => {
+      const run = ++loadId;
       const id = detailInputId();
-      if (!id) return { ...s, status: "ready", ...presence("missing") };
-      try {
-        const res = await getStoreCategory(id);
-        const c = res.category;
-        if (c?.id || c?.name) {
-          return {
-            status: "ready",
-            name: c.name || "Category",
-            subtitle: categoryCount(c),
-            description: c.description || "",
-            ...presence("found"),
-          };
-        }
-      } catch { /* fall through to V1 */ }
+      if (!id) return { ...s, ...NO_PRODUCTS, loadId: run, status: "ready", ...presence("missing") };
+      let header: Pick<S, "name" | "subtitle" | "description">;
       try {
-        const res = await getCollection(id);
-        const c = (((res as unknown as { collection?: WixCollection }).collection) ?? (res as unknown as WixCollection)) as unknown as {
-          name?: string; numberOfProducts?: number; description?: string;
-        };
-        const n = c.numberOfProducts;
-        return {
-          status: "ready",
-          name: c.name || "Collection",
-          subtitle: n != null ? `${n} ${n === 1 ? "product" : "products"}` : "",
-          description: c.description || "",
-          ...presence("found"),
-        };
+        header = await readCategory(id);
       } catch (e) {
-        return { ...s, status: "ready", ...presenceAfterError(e) };
+        if (run !== loadId) return undefined;
+        return { ...s, ...NO_PRODUCTS, loadId: run, status: "ready", ...presenceAfterError(e) };
       }
+      // A newer load (onAppear after the boot load, pull-to-refresh) owns the screen now.
+      if (run !== loadId) return undefined;
+      categoryId = id;
+      // Starts the first page; its snapshots land through `productsChanged`, which ignores
+      // them until THIS state (stamped `run`) is committed. The "loading" snapshot is read
+      // synchronously below, so the header paints with the products skeleton under it.
+      void products.query({});
+      return withProducts({ ...s, ...header, loadId: run, status: "ready", ...presence("found") });
     },
+    productsChanged: (s) => (s.loadId === loadId && s.found ? withProducts(s) : undefined),
+    loadMoreProducts: async () => { await products.loadMore(); return undefined; },
+    retryProducts: async () => { await products.retry(); return undefined; },
   },
 });
 svc.load();

package/templates/yoga-studio/dev/index.ts

@@ -25845,6 +25845,9 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                             "actionId": "tier5.himiBrandedProgram.enroll"
                           }
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBrandedProgram.enrollHidden"
                       }
                     },
                     {
@@ -25858,6 +25861,44 @@ const TEMPLATED: { pattern: string; display: string; liveSeed?: LiveSeed; static
                           "color": "textSecondary",
                           "collapseWhenEmpty": true
                         }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBrandedProgram.enrollHidden"
+                      }
+                    },
+                    {
+                      "id": "himi_program.buy",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "$service:himiBrandedProgram.buyLabel",
+                          "style": "primary",
+                          "fullWidth": true,
+                          "disabledPath": "$service:himiBrandedProgram.buyDisabled",
+                          "action": {
+                            "actionId": "tier5.himiBrandedProgram.buy"
+                          }
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBrandedProgram.buyHidden"
+                      }
+                    },
+                    {
+                      "id": "himi_program.buy_note",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiBrandedProgram.buyNote",
+                          "style": "footnote",
+                          "color": "textSecondary",
+                          "collapseWhenEmpty": true
+                        }
+                      },
+                      "modifiers": {
+                        "hiddenPath": "$service:himiBrandedProgram.buyHidden"
                       }
                     },
                     {

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

@@ -1,49 +1,11 @@
-// Worker-side glue for the shared IAP catalog layer (`@himalaya/iap` → createIapCatalogPricing),
-// shared by every screen that shows or sells an IAP-backed item. Mapping, Apple prices and payment
-// guards live in the SDK; this only supplies the host scope, the copy, and the hydration reset.
-import { get as appInfo } from "@himalaya/app-info";
-import type { IapCatalogScope, IapPriceCopy } from "@himalaya/iap";
+// Worker-side glue for the shared IAP layer (`@himalaya/iap` catalog pricing and
+// `@himalaya/iap-checkout` → createIapCommerce), shared by every screen that shows or sells an
+// IAP-backed item. Mapping, Apple prices, payment guards, the host scope and the sale live in the
+// SDK; this only supplies the copy and the hydration reset.
+import type { IapPriceCopy } from "@himalaya/iap";
+import type { IapPurchaseCopy } from "@himalaya/iap-checkout";
 import { copyParam } from "./himi-copy.js";
 
-export interface HostIapScope {
-  scope: IapCatalogScope;
-  platform: string;
-}
-
-let hostScope: Promise<HostIapScope> | undefined;
-
-/** Read once per worker, and only by an enabled screen: a disabled one makes no app-info call.
- *  App identity and platform come from the host, never a screen param. The site is the host-owned
- *  native preference business (the web partition uses an OAuth client ID); without one, the mapping source's
- *  bound site applies. A failed read leaves identity empty, which fails every item closed — and is
- *  not kept, so the next lookup asks the host again instead of staying invalid for good. */
-export function hostIapScope(): Promise<HostIapScope> {
-  return hostScope ??= readHostScope().then((read) => {
-    if (!hostScopeComplete(read)) hostScope = undefined;
-    return read;
-  });
-}
-
-/** An incomplete scope prices every item `invalidInput`, which the shared layer never offers to
- *  retry — so a screen offers Retry itself while its own host read is what failed. */
-export function hostScopeComplete(read: HostIapScope): boolean {
-  return !!read.scope.appId && !!read.scope.bundleId && !!read.platform;
-}
-
-async function readHostScope(): Promise<HostIapScope> {
-  const identity = await appInfo().catch(() => undefined);
-  const siteId = identity?.platform === "web" ? "" : hostSiteId();
-  return {
-    scope: { appId: identity?.appId ?? "", bundleId: identity?.bundleId ?? "", ...(siteId ? { siteId } : {}) },
-    platform: identity?.platform ?? "",
-  };
-}
-
-function hostSiteId(): string {
-  const value = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.__himiPreferenceBusiness;
-  return typeof value === "string" ? value.trim() : "";
-}
-
 /** Price labels from the screen's copy pack (`<prefix>.priceLoadingText`, …). */
 export function iapPriceCopy(prefix: string): IapPriceCopy {
   return {
@@ -54,6 +16,21 @@ export function iapPriceCopy(prefix: string): IapPriceCopy {
   };
 }
 
+/** App Store purchase labels from the screen's copy pack (`<prefix>.buyCta`, …), for
+ *  `iapPurchaseFields`. Customer copy only: no backend names, ids or diagnostics. */
+export function iapPurchaseCopy(prefix: string): IapPurchaseCopy {
+  return {
+    buy: copyParam(`${prefix}.buyCta`, "Get access"),
+    processing: copyParam(`${prefix}.purchaseProcessingText`, "Processing your purchase…"),
+    awaitingApproval: copyParam(`${prefix}.purchaseAwaitingApprovalText`, "Waiting for approval"),
+    unavailable: copyParam(`${prefix}.purchaseTemporarilyUnavailableText`, "Purchasing is temporarily unavailable."),
+    signInRequired: copyParam(`${prefix}.purchaseSignInText`, "Sign in to buy."),
+    retry: copyParam(`${prefix}.purchaseRetryText`, "Something went wrong. Try again."),
+    priceChanged: copyParam(`${prefix}.purchasePriceChangedText`, "The price changed. Check it and try again."),
+    support: copyParam(`${prefix}.purchaseSupportText`, "We couldn't finish this purchase. Contact support."),
+  };
+}
+
 /** What `notHydrated` does, for a runtime that ignores the option (a binary older than it, still
  *  served new bundles): put the listed keys back to their declared values before any action runs,
  *  so a persisted price or an enabled purchase action never paints as this run's. */

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

@@ -14,8 +14,11 @@
 // back APPROVAL_PENDING (the owner approves; there is nothing to charge). Any failure
 // degrades to the site-directing message rather than a dead button.
 //
-// App Store prices and the payment route come from the shared IAP catalog layer (@himalaya/iap).
-// Until a mapping backend is connected it is disabled, and this worker runs its pre-pricing path.
+// App Store prices, the payment route and the App Store sale come from the shared IAP layer
+// (`createIapCommerce` in @himalaya/iap-checkout). An app that sells nothing through the App Store
+// reads every program as `disabled` and keeps Enrol on its own commerce. An Apple-routed program
+// offers Get access in place of Enrol and sells only through the shared checkout, never through the
+// Wix payment rail.
 import { defineService } from "@himalaya/state";
 import {
   getProgram,
@@ -31,8 +34,9 @@ import { cleanTitle, initials } from "../_shared/himi-text.js";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
 import { payCashierOrder } from "@himalaya/checkout";
 import { formatCurrency } from "../_shared/engine-intl.js";
-import { createIapCatalogPricing, iapPriceFields, onlineProgramItem, type IapCatalogItem, type IapPollDirective, type IapPriceFields } from "@himalaya/iap";
-import { hostIapScope, hostScopeComplete, iapPriceCopy, resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
+import { iapPriceFields, onlineProgramItem, type IapCatalogItem, type IapPollDirective, type IapPriceFields } from "@himalaya/iap";
+import { createIapCommerce, onlineProgramOrders, type IapPurchaseFields } from "@himalaya/iap-checkout";
+import { iapPriceCopy, iapPurchaseCopy, resetUnhydratedKeysOnOlderRuntime } from "../_shared/iap-worker.js";
 
 /** Wix Online Programs appDefId — the vertical a participant's cashier order is
  *  paid under (mirrors AppDefId.CHALLENGES in Wix's RN apps). */
@@ -66,6 +70,13 @@ interface State {
   /** Bound to the Enrol CTA's `disabledPath`; `enroll` re-checks the route itself regardless. */
   enrollDisabled: boolean;
   enrollNote: string;
+  /** An App Store program sells through Get access instead. */
+  enrollHidden: boolean;
+  /** The shared checkout's action (`commerce.purchaseFields`): shown only on the App Store route. */
+  buyHidden: boolean;
+  buyLabel: string;
+  buyDisabled: boolean;
+  buyNote: string;
   _poll?: IapPollDirective;
 }
 
@@ -174,15 +185,6 @@ async function fetchProgram(id: string): Promise<WixProgram | undefined> {
   }
 }
 
-async function load(state: State, arg?: unknown): Promise<State> {
-  stashCopy(arg);
-  try {
-    return ready(state, await fetchProgram(inputId()));
-  } catch {
-    return derive({ ...state, status: "error" });
-  }
-}
-
 /** Whether the existing commerce flow may start (before the join) and continue (before the Wix
  *  payment): a price refresh can move the program onto a route this flow must not charge. */
 interface CommerceGuards {
@@ -190,8 +192,6 @@ interface CommerceGuards {
   mayContinue(): boolean;
 }
 
-const ALWAYS_ALLOWED: CommerceGuards = { mayStart: () => true, mayContinue: () => true };
-
 async function enrollmentMessage(name: string, guards: CommerceGuards): Promise<string> {
   const blocked = () => iapPriceCopy("program").purchaseUnavailable;
   if (!guards.mayStart()) return blocked();
@@ -251,27 +251,27 @@ async function enrollmentMessage(name: string, guards: CommerceGuards): Promise<
   return copyTemplate("program.joinOnSiteMessage", "Enrolment happens on the website — visit the site to join {name}.", { name });
 }
 
-async function enroll(state: State): Promise<State> {
-  if (!inputId()) return state;
-  return derive({ ...state, actionMessage: await enrollmentMessage(state.name, ALWAYS_ALLOWED) });
-}
-
-// ── App Store pricing (enabled only when a mapping backend is connected) ─────
+// ── Content, App Store pricing and sale ─────
 //
-// One writer: `loadPriced` and `enrollPriced` keep their results here and every state change goes
-// through the synchronous `pricingPublish`, which re-reads the latest content and route. An async
-// action returning its own state could land after a refresh and revive a stale price or route.
+// One writer: `load`, `enroll` and `buy` keep their results here and every state
+// change goes through the synchronous `pricingPublish`, which re-reads the latest content, route
+// and checkout state. An async action returning its own state could land after a refresh and
+// revive a stale price, route or purchase.
 
-const pricing = createIapCatalogPricing({ onChange: () => { void svc.pricingPublish(); } });
-const PRICING_NOT_HYDRATED = ["priceLine", "priceNote", "hidePriceRetry", "enrollDisabled", "enrollNote"] as const;
+const commerce = createIapCommerce({ adapters: [onlineProgramOrders], onChange: () => { void svc.pricingPublish(); } });
+const pricing = commerce.pricing;
+const PRICING_NOT_HYDRATED = [
+  "priceLine", "priceNote", "hidePriceRetry", "enrollDisabled", "enrollNote", "enrollHidden", "buyHidden", "buyLabel", "buyDisabled", "buyNote",
+] as const;
 const CONTENT_KEYS = ["status", "name", "description", "meta", "image", "initial", "emptyText"] as const;
 type Content = Pick<State, (typeof CONTENT_KEYS)[number]>;
 const NO_PRICE: IapPriceFields = { priceText: "", priceNote: "", priceLoading: false, hidePriceRetry: true, actionDisabled: true, actionNote: "" };
+const NOT_APPLE: IapPurchaseFields = { appleRoute: false, accessReady: false, buyLabel: "", buyDisabled: true, buyBusy: false, buyNote: "" };
 let content: Content;
 let pricedItem: IapCatalogItem | undefined;
-let scopeIncomplete = false;
 let actionMessage = "";
 let loadSeq = 0;
+let commerceStarted = false;
 
 function contentOf(state: State): Content {
   return Object.fromEntries(CONTENT_KEYS.map((key) => [key, state[key]])) as Content;
@@ -279,7 +279,7 @@ function contentOf(state: State): Content {
 
 const programReference = () => onlineProgramItem({ id: inputId() })?.reference;
 
-async function loadPriced(state: State, arg?: unknown): Promise<undefined> {
+async function load(state: State, arg?: unknown): Promise<undefined> {
   stashCopy(arg);
   const seq = ++loadSeq;
   const found = await fetchProgram(inputId()).then((program) => ({ program }), () => undefined);
@@ -288,20 +288,27 @@ async function loadPriced(state: State, arg?: unknown): Promise<undefined> {
   pricedItem = found?.program ? onlineProgramItem({ id: inputId() }, priceOf(found.program)) : pricedItem;
   void svc.pricingPublish();
   if (found?.program) void priceProgram();
+  void resumeCommerce();
   return undefined;
 }
 
+/** First entry recovers held purchases; every later one (a return to the screen) reconciles. */
+async function resumeCommerce(): Promise<void> {
+  const first = !commerceStarted;
+  commerceStarted = true;
+  await (first ? commerce.start() : commerce.reconcile());
+  void svc.pricingPublish();
+}
+
 /** Content never waits on this, and the host scope is re-read each time, so a failed app-info
  *  read recovers on the next refresh. */
 async function priceProgram(): Promise<void> {
-  // The Retry action is declared in both modes; with no backend it must not reach the host.
-  if (!pricing.enabled) return;
-  const host = await hostIapScope();
-  scopeIncomplete = !hostScopeComplete(host);
-  if (pricedItem) await pricing.load({ ...host, items: [pricedItem] });
+  if (!pricedItem) return;
+  await commerce.loadPrices([pricedItem]);
+  void svc.pricingPublish();
 }
 
-async function enrollPriced(): Promise<undefined> {
+async function enroll(): Promise<undefined> {
   const reference = programReference();
   if (!reference) return undefined;
   // A tap that lands as a refresh starts is refused without a verdict: the route is unknown, not
@@ -314,13 +321,29 @@ async function enrollPriced(): Promise<undefined> {
   return undefined;
 }
 
+/** The App Store sale: only through the shared checkout, and only for the route the price shows. */
+async function buy(): Promise<undefined> {
+  const reference = programReference();
+  if (!reference) return undefined;
+  await commerce.buy({ reference });
+  void svc.pricingPublish();
+  return undefined;
+}
+
 function pricedState(state: State): State {
   const reference = programReference();
-  const price = reference ? iapPriceFields(pricing.view(reference), iapPriceCopy("program")) : NO_PRICE;
+  const view = reference && pricing.view(reference);
+  const price = view ? iapPriceFields(view, iapPriceCopy("program")) : NO_PRICE;
+  const purchase = reference ? commerce.purchaseFields(reference, iapPurchaseCopy("program")) : NOT_APPLE;
+  const poll = commerce.pollDirective("himiBrandedProgram.iapPoll");
   return derive({
-    ...state, ...content, actionMessage,
-    priceLine: price.priceText, priceNote: price.priceNote, hidePriceRetry: price.hidePriceRetry && !scopeIncomplete,
-    enrollDisabled: price.actionDisabled, enrollNote: price.actionNote,
+    ...state, ...content,
+    actionMessage: purchase.accessReady ? copyTemplate("program.joinedMessage", "You're enrolled in {name}.", { name: content.name }) : actionMessage,
+    // `disabled`: this app sells nothing through the App Store, so the program shows its own price.
+    priceLine: view?.route === "disabled" ? pricedItem?.commerceDisplayPrice ?? "" : price.priceText, priceNote: price.priceNote, hidePriceRetry: view?.route === "disabled" || (price.hidePriceRetry && commerce.scopeComplete()),
+    enrollDisabled: price.actionDisabled, enrollNote: price.actionNote, enrollHidden: purchase.appleRoute,
+    buyHidden: !purchase.appleRoute || purchase.accessReady, buyLabel: purchase.buyLabel, buyDisabled: purchase.buyDisabled, buyNote: purchase.buyNote,
+    ...(poll ? { _poll: poll } : {}),
   });
 }
 
@@ -344,34 +367,41 @@ const INITIAL_STATE: State = derive({
   hideContent: true,
   priceNote: "",
   hidePriceRetry: true,
-  enrollDisabled: pricing.enabled,
+  enrollDisabled: true,
   enrollNote: "",
+  enrollHidden: false,
+  buyHidden: true,
+  buyLabel: "",
+  buyDisabled: true,
+  buyNote: "",
 });
 
 type Actions = {
   load: (state: State, arg?: unknown) => Promise<State | undefined>;
   enroll: (state: State) => Promise<State | undefined>;
+  buy: (state: State) => Promise<State | undefined>;
   pricingPublish: (state: State) => State;
   pricingStart: (state: State) => State;
   pricingRefresh: (state: State) => Promise<undefined>;
+  iapPoll: (state: State) => Promise<undefined>;
 };
 
 const svc = defineService<State, Actions>("himiBrandedProgram", {
   state: INITIAL_STATE,
-  ...(pricing.enabled ? { notHydrated: [...PRICING_NOT_HYDRATED] } : {}),
+  notHydrated: [...PRICING_NOT_HYDRATED],
   actions: {
-    load: pricing.enabled ? loadPriced : load,
-    enroll: pricing.enabled ? enrollPriced : enroll,
+    load,
+    enroll,
+    buy,
     pricingPublish: pricedState,
-    pricingStart: (state) => ({ ...pricedState(state), _poll: pricing.pollDirective("himiBrandedProgram.pricingRefresh") }),
+    pricingStart: pricedState,
     pricingRefresh: async () => { await priceProgram(); return undefined; },
+    iapPoll: async () => { await commerce.poll(); void svc.pricingPublish(); return undefined; },
   },
 });
 
 content = contentOf(svc.getState());
-if (pricing.enabled) {
-  resetUnhydratedKeysOnOlderRuntime(svc, INITIAL_STATE, PRICING_NOT_HYDRATED);
-  void svc.pricingStart();
-}
+resetUnhydratedKeysOnOlderRuntime(svc, INITIAL_STATE, PRICING_NOT_HYDRATED);
+void svc.pricingStart();
 
 export { svc };