@wix/himalaya-cli 0.1209.0 → 0.1211.0

package/templates/events-meetups-owner/tier5-src/_shared/owner-site-pick.ts

@@ -0,0 +1,74 @@
+// Switching the business an __HIMI_APP_NAME__ session manages — the one implementation
+// behind every "pick a business" row (the Sites list and the cross-business Overview).
+//
+// Previously those rows were declarative `himi.open{business}` taps: the shell scoped
+// the bridge and PUSHED Home, and nothing recorded which business was picked, so the
+// chrome kept naming the build-time one and a `‹ Back` led to the list just left. As a
+// worker action the row can record the name first, then hand the shell the same
+// `business`-carrying open — now as a `replace` onto the Home root.
+//
+// Scoping stays with the shell's router (SP-1: a `business` nav param scopes the Wix
+// bridge BEFORE navigating, on iOS and Android). It is deliberately not done here with
+// `site.setActiveSite`: owner-lite's native shells do not register the worker-facing
+// `siteSetActive` capability, so the call throws and the tap would go nowhere.
+
+import { navigate, type NavDirective } from "@himalaya/state";
+import { forgetCatalogVersion } from "@himalaya/wix-stores";
+import { rememberSelectedSite } from "./owner-selected-site.js";
+
+export const OWNER_HOME = "himi_owner_lite_home";
+
+/** Set by a pick, cleared by `settleBusinessSwitch` once the new business is scoped. */
+const SWITCH_PENDING_KEY = "himi.ownerLite.businessSwitchPending.v1";
+
+type StorageLike = { getItem(key: string): string | null; setItem(key: string, value: string): void };
+const storage = (): StorageLike | undefined =>
+  (globalThis as { himalaya?: { storage?: StorageLike } }).himalaya?.storage;
+
+/** `{ id | business, name }` from a row's action params (or a bare msid string). */
+export function pickedSite(arg: unknown): { msid: string; name: string } {
+  if (typeof arg === "string") return { msid: arg.trim(), name: "" };
+  const a = (arg ?? {}) as { business?: unknown; id?: unknown; name?: unknown };
+  const msid = typeof a.business === "string" && a.business ? a.business : typeof a.id === "string" ? a.id : "";
+  return { msid: msid.trim(), name: typeof a.name === "string" ? a.name.trim() : "" };
+}
+
+/**
+ * Record `name` as the business being managed, then return `state` carrying a
+ * `replace` onto the Home root that asks the shell to scope to `msid`. Returns `state`
+ * untouched (no navigation) when there is no msid.
+ */
+export function pickSite<S extends object>(state: S, msid: string, name: string): S | (S & { _nav: NavDirective }) {
+  if (!msid) return state;
+  // Another business may run the other Stores catalog. The resolved version is
+  // persisted app-wide and routes WRITES, which have no 428 retry, so it is dropped
+  // before the switch rather than left to be re-used against the new site.
+  forgetCatalogVersion();
+  // ...but the shell scopes the bridge to `msid` only AFTER this returns, so a warm
+  // Stores worker resolving in that gap still talks to the OLD site and can persist
+  // its version over the tombstone above. Leave a marker so the first worker that
+  // runs after scoping drops the catalog version once more (`settleBusinessSwitch`).
+  try { storage()?.setItem(SWITCH_PENDING_KEY, msid); } catch { /* no storage: the first forget stands */ }
+  if (name) rememberSelectedSite({ id: msid, name });
+  // `replace` onto Home, the tab root the pickers are reached from: the core router
+  // lands ON the root instead of stacking a second Home above the list.
+  return navigate(state, { screenId: OWNER_HOME, presentation: "replace", args: { business: msid } });
+}
+
+/**
+ * Finish a business switch: if a pick is pending, drop the Stores catalog version
+ * again and clear the marker. Call it first in a worker that runs only after the shell
+ * has scoped the bridge to the picked business (Home's `load`: the pick `replace`s
+ * onto Home, and the router scopes before it navigates), so a version persisted from
+ * the old site during the scoping gap is discarded. Never throws.
+ */
+export function settleBusinessSwitch(): void {
+  try {
+    const s = storage();
+    if (!s?.getItem(SWITCH_PENDING_KEY)) return;
+    forgetCatalogVersion();
+    s.setItem(SWITCH_PENDING_KEY, "");
+  } catch {
+    // No storage, or it failed: nothing pending can be recorded either.
+  }
+}

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-account/index.ts

@@ -11,6 +11,11 @@
 //     from provisioning.json `identity` — so a branded template ships ITS links,
 //     and `openLink` can only ever open one of those three URLs.
 //
+//   • which business this is — the one the owner picked on Sites (see
+//     `_shared/owner-selected-site.ts`), not the build-time provisioning name,
+//     which arrives only as the cold-start `businessName` param. A local read,
+//     so it is set synchronously in the initial state and again on every load.
+//
 // Every read is best-effort: an identity or version the host cannot answer
 // collapses its line rather than rendering an error on a settings screen.
 
@@ -20,19 +25,24 @@ import { displayVersion } from "@himalaya/app-info";
 import { open } from "@himalaya/open-url";
 import { stashCopy, copyTemplate } from "../_shared/himi-copy.js";
 import { ownerLineOf, shapeAccount, type AccountState } from "../_shared/owner-account.js";
+import { fallbackNameFrom, selectedSiteName } from "../_shared/owner-selected-site.js";
 
 type LinkKind = "support" | "privacy" | "terms";
 
 const obj = (v: unknown): Record<string, unknown> => (v && typeof v === "object" ? v as Record<string, unknown> : {});
 
+let fallbackBusinessName = "";
+
 const svc = defineService<AccountState, {
   load: (s: AccountState, arg?: unknown) => Promise<AccountState>;
   openLink: (s: AccountState, arg?: unknown) => Promise<AccountState>;
 }>("himiOwnerLiteAccount", {
-  state: shapeAccount({}),
+  state: shapeAccount({ businessName: selectedSiteName(fallbackBusinessName) }),
   actions: {
     load: async (s, arg) => {
       stashCopy(arg);
+      fallbackBusinessName = fallbackNameFrom(arg, fallbackBusinessName);
+      const businessName = selectedSiteName(fallbackBusinessName);
       const p = obj(arg);
       const links = { supportUrl: String(p.supportUrl ?? s.supportUrl), privacyUrl: String(p.privacyUrl ?? s.privacyUrl), termsUrl: String(p.termsUrl ?? s.termsUrl) };
       let ownerLine = "";
@@ -54,7 +64,7 @@ const svc = defineService<AccountState, {
         const v = await displayVersion();
         versionLine = v ? copyTemplate("ownerAccount.version", "Version {version}", { version: v }) : "";
       } catch { /* host without app_info — the row collapses */ }
-      return shapeAccount({ ...s, ...links, status: "ready", ownerLine, versionLine, error });
+      return shapeAccount({ ...s, ...links, status: "ready", businessName, ownerLine, versionLine, error });
     },
     openLink: async (s, arg) => {
       const kind = String(obj(arg).kind ?? arg ?? "") as LinkKind;

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-aria-history/index.ts

@@ -26,6 +26,7 @@ const core = createAriaHistory({
     last7: () => copyParam("ownerAriaHistory.last7", "Last 7 days"),
     last30: () => copyParam("ownerAriaHistory.last30", "Last 30 days"),
     older: () => copyParam("ownerAriaHistory.older", "Older"),
+    today: () => copyParam("ownerAriaHistory.today", "Today"),
   },
 });
 

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-drawer/index.ts

@@ -20,13 +20,23 @@
 import { defineService } from "@himalaya/state";
 import { serializeForAgent } from "@himalaya/agent";
 import { activeScreenFromInput, attentionRow, navRow, withDerived, type DrawerState } from "./logic.js";
+import { fallbackNameFrom, selectedSiteName } from "../_shared/owner-selected-site.js";
 
 /** The shell passes the screen it is showing as worker input, so the drawer can mark
  *  that destination selected the way the declarative drawer does. */
 const hostActiveScreen = () => activeScreenFromInput((globalThis as { himalaya?: { input?: unknown } }).himalaya?.input);
 
+/** Cold-start name from the descriptor's onAppear params (provisioning identity). */
+let fallbackBusinessName = "";
+
+/** "Which site am I on": the business picked on Sites, else the fallback. */
+const currentSiteName = () => selectedSiteName(fallbackBusinessName);
+
 const drawer = defineService<DrawerState, {
-  /** Re-read the active screen from host input (root onAppear). An explicit
+  /** The panel opened (root onAppear): re-read the live site and the active screen.
+   *  `arg.businessName` is the cold-start fallback for the site name. */
+  refresh: (s: DrawerState, arg?: unknown) => DrawerState;
+  /** Re-read the active screen from host input. An explicit
    *  `{ screenId }` wins, for a host that pushes the change instead. */
   syncActive: (s: DrawerState, args?: { screenId?: string }) => DrawerState;
   /** First tap on "Mark all handled": ask before hiding anything. */
@@ -37,7 +47,7 @@ const drawer = defineService<DrawerState, {
   clearAttention: (s: DrawerState) => DrawerState;
 }>("drawer", {
   state: withDerived({
-    siteName: "My Site",
+    siteName: currentSiteName(),
     nav: [
       navRow("drawer_home", "Home", "home", "himi_owner_lite_home"),
       // Between Home and Manage deliberately: analytics answers "how is the
@@ -55,6 +65,15 @@ const drawer = defineService<DrawerState, {
     activeScreenId: hostActiveScreen(),
   }),
   actions: {
+    refresh: (s, arg) => {
+      fallbackBusinessName = fallbackNameFrom(arg, fallbackBusinessName);
+      const screenId = (arg as { screenId?: unknown } | undefined)?.screenId;
+      return snap(withDerived({
+        ...s,
+        siteName: currentSiteName(),
+        activeScreenId: typeof screenId === "string" ? screenId : hostActiveScreen(),
+      }));
+    },
     syncActive: (s, args) => snap(withDerived({
       ...s,
       activeScreenId: typeof args?.screenId === "string" ? args.screenId : hostActiveScreen(),

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

@@ -21,6 +21,8 @@ import { getSiteAnalytics, getSiteTimeZone, localDateRange, localDateOf, localMi
 import { ownerDisplayError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
 import { DEMO_DASHBOARD, DEMO_NOTE, DEMO_TODAY } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam, copyTemplate } from "../_shared/himi-copy.js";
+import { fallbackNameFrom, selectedSiteName } from "../_shared/owner-selected-site.js";
+import { settleBusinessSwitch } from "../_shared/owner-site-pick.js";
 import { formatCurrency } from "../_shared/engine-intl.js";
 import {
   attentionRecords,
@@ -51,6 +53,9 @@ interface SourceState {
 }
 
 interface HomeState {
+  /** The business the header names: the one picked on Sites, else the descriptor's
+   *  build-time fallback. */
+  businessName: string;
   attention: TodayRecord[];
   schedule: TodayRecord[];
   allSchedule: TodayRecord[];
@@ -79,6 +84,10 @@ interface HomeState {
   notLoading: boolean;
   notErrored: boolean;
   hideContent: boolean;
+  /** The retry cards' list is hidden unless the dashboard is ready AND a source failed.
+   *  An empty list still costs its parent stack a gap, which on iOS read as a blank
+   *  band under the header; gating on `hideContent` alone left it mounted. */
+  hideSourceFailures: boolean;
   demoNote: string;
   notDemo: boolean;
 }
@@ -101,11 +110,18 @@ const SOURCE_LABELS: Record<HomeSourceId, string> = {
   reviews: "Reviews", reservations: "Reservations",
 };
 
+/** Cold-start name from the descriptor's onAppear params (provisioning identity). */
+let fallbackBusinessName = "";
+/** Resolved once per load, not per shape: a storage read is a host round-trip, and the
+ *  picked business only changes between loads (the picker is another screen). */
+let currentBusinessName = selectedSiteName("");
+
 function shape(s: Partial<HomeState>): HomeState {
   const status = s.status ?? "ready";
   const isLoading = status === "loading";
   return {
     status,
+    businessName: currentBusinessName,
     attention: s.attention ?? [],
     schedule: s.schedule ?? [],
     allSchedule: s.allSchedule ?? s.schedule ?? [],
@@ -133,6 +149,7 @@ function shape(s: Partial<HomeState>): HomeState {
     notLoading: !isLoading,
     notErrored: status !== "error",
     hideContent: status !== "ready",
+    hideSourceFailures: status !== "ready" || !(s.sourceFailures?.length),
     demoNote: s.demoNote ?? "",
     notDemo: !s.demoNote,
   };
@@ -834,8 +851,19 @@ const svc = defineService<HomeState, {
   })) }),
   actions: {
     load: async (s, arg) => {
+      // FIRST, before anything reads the catalog: a business pick `replace`s onto
+      // Home, and the shell scopes the bridge to the picked business before it
+      // navigates, so this load is the first code that runs on the new site. A Stores
+      // catalog version persisted from the OLD site during that gap is dropped here.
+      settleBusinessSwitch();
       stashCopy(arg);
-      const sources = enabledSourcesFrom(arg) ?? [...HOME_SOURCE_IDS];
+      fallbackBusinessName = fallbackNameFrom(arg, fallbackBusinessName);
+      // Re-read here: Home's root is not remounted when the owner switches business,
+      // and the picker records the selection from a different worker.
+      currentBusinessName = selectedSiteName(fallbackBusinessName);
+      // An argless re-load (the host refreshing a warm root after the owner switches
+      // business) keeps the sources the descriptor enabled rather than widening to all.
+      const sources = enabledSourcesFrom(arg) ?? activeSources;
       return loadDashboard(shape({ ...s, status: "loading" }), sources);
     },
     retry: async (s) => loadDashboard(shape({ ...s, status: "loading" }), activeSources),

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-manage/index.ts

@@ -16,9 +16,13 @@ import { queryOwnerModule } from '../_shared/owner-module-data.js';
 import { OWNER_MODULES, ownerModuleId } from '../_shared/owner-modules.js';
 import { localPreferences } from '../_shared/local-preferences.js';
 import { stashCopy, copyParam, copyTemplate } from '../_shared/himi-copy.js';
+import { fallbackNameFrom, selectedSiteName } from '../_shared/owner-selected-site.js';
 import { DASHBOARD_PATHS, deriveManage, parseAreas, recentAreas, rememberArea, withMetrics, type ManageArea, type Metric } from './logic.js';
 
 interface State {
+  /** The business the header names: the one picked on Sites, else the descriptor's
+   *  build-time fallback. */
+  businessName: string;
   /** `loading` until the descriptor has delivered the areas, then
    *  `ready`. The descriptor keys a FragmentSlot on it whose DEFAULT case is the
    *  skeleton, so an unresolved path (worker not booted yet) is loading too —
@@ -35,6 +39,8 @@ interface State {
   noEmpty: boolean;
   hasRecents: boolean;
   noRecents: boolean;
+  /** True while `sections` is empty — gates the list so an empty one costs no gap. */
+  noSections: boolean;
   isLoading: boolean;
   notLoading: boolean;
   summaryNote: string;
@@ -178,6 +184,11 @@ async function metricFor(metricKey: string): Promise<Metric> {
   }
 }
 
+/** Cold-start name from the descriptor's onAppear params (provisioning identity). */
+let fallbackBusinessName = '';
+/** Resolved per load/refresh, not per derive (a storage read is a host round-trip). */
+let currentBusinessName = selectedSiteName('');
+
 function derive(state: State, areas = state.areas): State {
   const next = deriveManage(
     areas,
@@ -191,7 +202,7 @@ function derive(state: State, areas = state.areas): State {
   // areas arrive — or when this app provisions none at all — there is nothing a
   // filter could have excluded, so "Clear filters" would be a lie.
   const noEmpty = next.noEmpty || state.status !== 'ready' || areas.length === 0;
-  return { ...state, ...next, noEmpty, recents, hasRecents: recents.length > 0, noRecents: recents.length === 0 };
+  return { ...state, ...next, noEmpty, recents, hasRecents: recents.length > 0, noRecents: recents.length === 0, noSections: next.sections.length === 0, businessName: currentBusinessName };
 }
 
 // Loads are not serialized: on a warm reappearance the host's bare refresh and
@@ -261,16 +272,21 @@ const svc = defineService<State, {
   handoff: (s: State, arg?: unknown) => Promise<State>;
 }>('himiOwnerLiteManage', {
   state: {
+    businessName: currentBusinessName,
     status: 'loading',
     areas: [], results: [], sections: [], recents: [], query: '', group: 'all',
     // 'All' is always a valid filter, so the chip row paints from the first frame
     // instead of appearing (and shifting the layout) when the areas arrive.
     groups: [{ id: 'all', label: allLabel() }], summary: '', noEmpty: true,
-    hasRecents: false, noRecents: true, isLoading: true, notLoading: false, summaryNote: '', handoffError: '',
+    hasRecents: false, noRecents: true, noSections: true, isLoading: true, notLoading: false, summaryNote: '', handoffError: '',
   },
   actions: {
     load: async (state, arg) => {
       stashCopy(arg);
+      fallbackBusinessName = fallbackNameFrom(arg, fallbackBusinessName);
+      // Re-read on every load: this worker stays warm across tab switches, and the
+      // picker records the selection from another worker.
+      currentBusinessName = selectedSiteName(fallbackBusinessName);
       // A `load` with no areas comes from the host, not the descriptor: the
       // warm-worker refresh lifecycle calls it bare. Before the areas are known
       // it must not settle (that derived "0 business areas" and painted the
@@ -278,7 +294,7 @@ const svc = defineService<State, {
       if (!('areas' in read(arg))) {
         return state.status === 'ready'
           ? loadMetrics(derive({ ...state, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }))
-          : state;
+          : { ...state, businessName: currentBusinessName };
       }
       const parsed = (() => { try { return JSON.parse(str(arg, 'areas') || '[]'); } catch { return []; } })();
       const areas = parseAreas(parsed);
@@ -286,8 +302,12 @@ const svc = defineService<State, {
     },
     // Refresh re-reads summaries for KNOWN areas. Before the descriptor has
     // delivered them there is nothing to refresh, and settling here would open
-    // the skeleton gate over an empty hub.
-    refresh: async state => state.status !== 'ready' ? state : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' })),
+    // the skeleton gate over an empty hub. The business name is a local read, so
+    // it is re-read either way.
+    refresh: async state => {
+      currentBusinessName = selectedSiteName(fallbackBusinessName);
+      return state.status !== 'ready' ? { ...state, businessName: currentBusinessName } : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }));
+    },
     search: (state, arg) => derive({ ...state, query: str(arg, 'value').slice(0, 256) }),
     filter: (state, arg) => {
       const ids = read(arg).selectedIds;

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-overview/index.ts

@@ -30,6 +30,7 @@ import { searchOrders } from "@himalaya/wix-ecom";
 import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
 import { DEMO_SITES, DEMO_NOTE } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
+import { pickSite, pickedSite } from "../_shared/owner-site-pick.js";
 
 /** Mirrors the Home dashboard's "needs attention" definition, so a number here means the
  *  same thing it means after the owner drills into that business. */
@@ -205,6 +206,7 @@ async function loadRollup(): Promise<OverviewState> {
 const svc = defineService<OverviewState, {
   load: (s: OverviewState, arg?: unknown) => Promise<OverviewState>;
   retry: (s: OverviewState) => Promise<OverviewState>;
+  pick: (s: OverviewState, arg?: unknown) => OverviewState;
 }>("himiOwnerLiteOverview", {
   state: shape({ status: "loading" }),
   actions: {
@@ -213,6 +215,12 @@ const svc = defineService<OverviewState, {
       return loadRollup();
     },
     retry: async () => loadRollup(),
+    // Drilling into one business is the ONLY thing that moves the active business —
+    // the same switch the Sites list makes (scope, name it, reset to Home).
+    pick: (s, arg) => {
+      const { msid, name } = pickedSite(arg);
+      return pickSite(s, msid, name || s.rows.find((r) => r.id === msid)?.name || "");
+    },
   },
 });
 

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-sites/index.ts

@@ -1,18 +1,18 @@
 // Tier-5 bundle: __HIMI_APP_NAME__ — Sites List (multi-site chooser).
 // ACCOUNT-level: `site-list/v2/sites/query` authorizes on the owner wixSession2
 // cookie alone (no per-site signed-instance), so this loads before any business
-// is picked. Each row's `id` IS the site's metaSiteId — the shell's Router reads
-// it as the `business` param and scopes the Wix bridge to it (SiteInstanceStore
-// mints that site's User signed-instance for the management verticals).
+// is picked. Each row's `id` IS the site's metaSiteId — `pick` records the row's
+// name for the chrome and hands the shell a `business`-carrying `replace` onto Home;
+// the shell's Router scopes the Wix bridge to it (SiteInstanceStore mints that site's
+// User signed-instance for the management verticals).
 
 import { defineService } from "@himalaya/state";
 import { querySites, type WixSite } from "@himalaya/wix-site-list";
-import { site } from "@himalaya/wix-platform";
 import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
 import { DEMO_SITES, DEMO_NOTE } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { getAll, upsert, type DbEntity } from "../_shared/owner-local-db.js";
-import { forgetCatalogVersion } from "@himalaya/wix-stores";
+import { pickSite, pickedSite } from "../_shared/owner-site-pick.js";
 
 // Offline-first (data-offline): the owner's last-synced businesses are the
 // READ-THROUGH cache for the `sites` entity — paint them instantly (works
@@ -139,17 +139,16 @@ async function loadList(s: SitesState): Promise<SitesState> {
   }
 }
 
-function msidFrom(arg: unknown): string {
-  return typeof arg === "string"
-    ? arg
-    : String((arg as { business?: string; id?: string })?.business ?? (arg as { id?: string })?.id ?? "");
+/** The picked row's display name: the row passes it, else it is looked up in the list. */
+function nameFor(s: SitesState, msid: string, passed: string): string {
+  return passed || s.allSites.find((r) => r.id === msid)?.name || "";
 }
 
 const svc = defineService<SitesState, {
   load: (s: SitesState, arg?: unknown) => Promise<SitesState>;
   retry: (s: SitesState) => Promise<SitesState>;
   search: (s: SitesState, arg?: unknown) => Promise<SitesState>;
-  pick: (s: SitesState, arg?: unknown) => Promise<SitesState>;
+  pick: (s: SitesState, arg?: unknown) => SitesState;
 }>("himiOwnerLiteSites", {
   state: shape({ status: "loading" }),
   actions: {
@@ -158,27 +157,11 @@ const svc = defineService<SitesState, {
       return loadList(shape({ ...s, status: "loading" }));
     },
     retry: async (s) => loadList(shape({ ...s, status: "loading" })),
-    // SP-1: worker-callable active-site scoping. A row can dispatch this instead of
-    // the declarative `himi.open{business}` param to scope the wixApi bridge to the
-    // picked business via the wix_platform capability (resolves after the mint), then
-    // the shell navigates to Home. Proves the T5-worker → setActiveSite path.
-    pick: async (s, arg) => {
-      const msid = msidFrom(arg);
-      if (msid) {
-        // Scoping the bridge to another business points it at another SITE, which may
-        // run the other Stores catalog. The resolved version is persisted app-wide and
-        // routes WRITES, which have no 428 retry — so it has to be dropped here, not
-        // just on the consumer-side site picker.
-        //
-        // Cleared on BOTH sides of the await: before, in case native remounts us
-        // before it settles; after, because a read interleaving it would re-resolve
-        // against the bridge that has not been re-scoped yet and re-persist the value
-        // we just dropped.
-        forgetCatalogVersion();
-        await site.setActiveSite(msid);
-        forgetCatalogVersion();
-      }
-      return s;
+    // Picking a business (every Sites row dispatches this): record its name for the
+    // chrome, then reset to the Home root; the shell scopes the bridge.
+    pick: (s, arg) => {
+      const { msid, name } = pickedSite(arg);
+      return pickSite(s, msid, nameFor(s, msid, name));
     },
     search: async (s, arg) => {
       const q = typeof arg === "string" ? arg : String((arg as { value?: string; query?: string })?.value ?? (arg as { query?: string })?.query ?? "");

package/templates/gym-fitness/tier5-src/_shared/engine-intl.ts

@@ -48,6 +48,36 @@ const MONTHS_LONG = [
   "July", "August", "September", "October", "November", "December",
 ] as const;
 
+/**
+ * A DateTimeFormat for `timeZone` when one is given and this engine knows it. An unknown or
+ * malformed IANA id is a RangeError in ECMA-402; these helpers never throw, so it degrades to
+ * the device zone rather than killing the screen. Without Intl there is no zone database at all,
+ * and the fallbacks below render in the device zone for the same reason.
+ *
+ * Formatters are memoised per (locale, zone, options): a management page formats several dates
+ * per row, and building a DateTimeFormat (or throwing on a bad zone) each time is not free on
+ * JSC or QuickJS. Only call it where `hasIntl()` holds — every caller does.
+ */
+const FORMATTERS = new Map<string, Intl.DateTimeFormat>();
+function dateFormat(locale: string, options: Intl.DateTimeFormatOptions, timeZone?: string): Intl.DateTimeFormat {
+  const key = `${locale}|${timeZone ?? ""}|${JSON.stringify(options)}`;
+  let formatter = FORMATTERS.get(key);
+  if (!formatter) {
+    if (hasIntl()) {
+      if (timeZone) {
+        try {
+          formatter = new Intl.DateTimeFormat(locale, { ...options, timeZone });
+        } catch {
+          /* unknown zone: device zone below, remembered under this key */
+        }
+      }
+      formatter ??= new Intl.DateTimeFormat(locale, options);
+      FORMATTERS.set(key, formatter);
+    }
+  }
+  return formatter as Intl.DateTimeFormat;
+}
+
 // The four shapes below are not invented — they are the option bags this corpus actually uses,
 // counted across every bundle: "Jan 5, 2026" (33 sites), "Jan 5" (11), "Mon, Jan 5, 3:07 PM" (8)
 // and "Jan 5, 3:07 PM" (4). Naming them means a conversion is a one-line swap rather than a
@@ -55,46 +85,46 @@ const MONTHS_LONG = [
 // ECMA-402 in engine-intl-fallback.test.ts.
 
 /** `{ month: "short", day: "numeric", year: "numeric" }` — "Jan 5, 2026". */
-export function formatDateMedium(date: Date, locale = "en-US"): string {
+export function formatDateMedium(date: Date, locale = "en-US", timeZone?: string): string {
   if (hasIntl()) {
-    return new Intl.DateTimeFormat(locale, { month: "short", day: "numeric", year: "numeric" }).format(date);
+    return dateFormat(locale, { month: "short", day: "numeric", year: "numeric" }, timeZone).format(date);
   }
   return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${date.getFullYear()}`;
 }
 
 /** `{ month: "short", day: "numeric" }` — "Jan 5". */
-export function formatMonthDay(date: Date, locale = "en-US"): string {
+export function formatMonthDay(date: Date, locale = "en-US", timeZone?: string): string {
   if (hasIntl()) {
-    return new Intl.DateTimeFormat(locale, { month: "short", day: "numeric" }).format(date);
+    return dateFormat(locale, { month: "short", day: "numeric" }, timeZone).format(date);
   }
   return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}`;
 }
 
 /** `{ month: "long", day: "numeric" }` — "January 5". */
-export function formatMonthDayLong(date: Date, locale = "en-US"): string {
+export function formatMonthDayLong(date: Date, locale = "en-US", timeZone?: string): string {
   if (hasIntl()) {
-    return new Intl.DateTimeFormat(locale, { month: "long", day: "numeric" }).format(date);
+    return dateFormat(locale, { month: "long", day: "numeric" }, timeZone).format(date);
   }
   return `${MONTHS_LONG[date.getMonth()]} ${date.getDate()}`;
 }
 
 /** `{ weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }`
  *  — "Mon, Jan 5, 3:07 PM". */
-export function formatWeekdayDateTime(date: Date, locale = "en-US"): string {
+export function formatWeekdayDateTime(date: Date, locale = "en-US", timeZone?: string): string {
   if (hasIntl()) {
-    return new Intl.DateTimeFormat(locale, {
+    return dateFormat(locale, {
       weekday: "short", month: "short", day: "numeric", hour: "numeric", minute: "2-digit",
-    }).format(date);
+    }, timeZone).format(date);
   }
   return `${WEEKDAYS_SHORT[date.getDay()]}, ${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${clock12(date)}`;
 }
 
 /** `{ month: "short", day: "numeric", hour: "numeric", minute: "2-digit" }` — "Jan 5, 3:07 PM". */
-export function formatMonthDayTime(date: Date, locale = "en-US"): string {
+export function formatMonthDayTime(date: Date, locale = "en-US", timeZone?: string): string {
   if (hasIntl()) {
-    return new Intl.DateTimeFormat(locale, {
+    return dateFormat(locale, {
       month: "short", day: "numeric", hour: "numeric", minute: "2-digit",
-    }).format(date);
+    }, timeZone).format(date);
   }
   return `${MONTHS_SHORT[date.getMonth()]} ${date.getDate()}, ${clock12(date)}`;
 }
@@ -380,9 +410,9 @@ export function normalizeFormattedPrice(formatted: string): string {
   return `${m[1]}${m[3]}${m[2]}`;
 }
 
-function clockParts(d: Date, locale: string): { time: string; meridiem: string } {
+function clockParts(d: Date, locale: string, timeZone?: string): { time: string; meridiem: string } {
   const full = hasIntl()
-    ? new Intl.DateTimeFormat(locale, { hour: "numeric", minute: "2-digit", hour12: true }).format(d)
+    ? dateFormat(locale, { hour: "numeric", minute: "2-digit", hour12: true }, timeZone).format(d)
     : clock12(d);
   // ICU puts a narrow no-break space before the meridiem; normalize so callers can split on it.
   const clean = full.replace(/[  ]/g, " ");
@@ -391,8 +421,8 @@ function clockParts(d: Date, locale: string): { time: string; meridiem: string }
 }
 
 /** "8:00 PM" — the one clock every customer screen uses (12-hour, en-US shape). */
-export function formatClock(date: Date, locale = "en-US"): string {
-  const { time, meridiem } = clockParts(date, locale);
+export function formatClock(date: Date, locale = "en-US", timeZone?: string): string {
+  const { time, meridiem } = clockParts(date, locale, timeZone);
   return meridiem ? `${time} ${meridiem}` : time;
 }
 
@@ -403,3 +433,14 @@ export function isPastDate(iso: string | undefined | null, now: number = Date.no
   const t = Date.parse(iso);
   return !Number.isNaN(t) && t < now;
 }
+
+/** The calendar day `date` falls on in `timeZone` (device zone when absent, unknown, or when
+ *  the engine has no Intl), as `YYYY-MM-DD`. For "is this today / this year" comparisons. */
+export function calendarDay(date: Date, timeZone?: string): string {
+  if (hasIntl()) {
+    const parts = dateFormat("en-CA", { year: "numeric", month: "2-digit", day: "2-digit" }, timeZone).formatToParts(date);
+    const get = (type: string) => parts.find((p) => p.type === type)?.value ?? "";
+    return `${get("year")}-${get("month")}-${get("day")}`;
+  }
+  return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}