@wix/himalaya-cli 0.1209.0 → 0.1211.0

package/templates/portfolio-creative-owner/tier5-src/_shared/owner-module-data.ts

@@ -13,9 +13,11 @@ import { queryGiftCards, getGiftCard } from '@himalaya/wix-gift-cards';
 import { queryDonationCampaigns, getDonationCampaign } from '@himalaya/wix-donations';
 import { query as queryBadges, get as getBadge } from '@himalaya/wix-badges';
 import { wixMediaUrl } from '@himalaya/wix-media';
+import { getSiteTimeZone } from '@himalaya/wix-analytics';
 import { type OwnerModuleId } from './owner-modules.js';
 import { type CollectionPage } from './collection-query.js';
-import { copyParam } from './himi-copy.js';
+import { copyParam, copyTemplate } from './himi-copy.js';
+import { calendarDay, formatDateMedium, formatMonthDay, formatWeekdayDateTime } from './engine-intl.js';
 import { eligibleOwnerOperations } from './owner-operations.js';
 
 export interface OwnerRecord {
@@ -33,91 +35,144 @@ const join = (...values: string[]) => values.filter(Boolean).join(' · ');
 const name = (value: unknown, first: string, last: string) => [field(value, first), field(value, last)].filter(Boolean).join(' ');
 const yesNo = (value: unknown) => typeof value === 'boolean' ? value ? 'Yes' : 'No' : '';
 const LIMIT = 50;
+
+/** The site's IANA zone, resolved once per worker. Wix hands every date here as a UTC instant;
+ *  formatting it in the viewer's device zone (or leaving it raw) shows an owner outside UTC the
+ *  wrong hour and sometimes the wrong day. A failed or unset lookup degrades to the
+ *  device zone — a zone is garnish on a date, never a reason to fail the collection. The
+ *  answer, failure included, is kept for the worker's life: a role that cannot read site
+ *  properties would otherwise re-send the failing request for every page a search walks. */
+let zoneLookup: Promise<string | undefined> | undefined;
+function siteZone(): Promise<string | undefined> {
+  // `Promise.resolve().then` so a bridge that throws synchronously is caught here too.
+  zoneLookup ??= Promise.resolve().then(getSiteTimeZone).catch(() => undefined);
+  return zoneLookup;
+}
+
+/** A Wix date value as an instant. A calendar date with no time ("2026-11-07") is a DAY, not an
+ *  instant: it is built at local midnight and formatted with no zone, so it never shifts across
+ *  one — including on engines without Intl, where a zone could not be applied anyway. */
+function ownerInstant(value: string): { date: Date; dayOnly: boolean } | undefined {
+  if (!value) return undefined;
+  const day = /^(\d{4})-(\d\d)-(\d\d)$/.exec(value);
+  if (day) return { date: new Date(Number(day[1]), Number(day[2]) - 1, Number(day[3])), dayOnly: true };
+  const ms = /^\d{13}$/.test(value) ? Number(value) : Date.parse(value);
+  return Number.isFinite(ms) ? { date: new Date(ms), dayOnly: false } : undefined;
+}
+/** Has the instant (or, for a calendar date, the whole day) passed? */
+function ownerPast(value: string, now = Date.now()): boolean {
+  const parsed = ownerInstant(value);
+  if (!parsed) return false;
+  const { date, dayOnly } = parsed;
+  return (dayOnly ? new Date(date.getFullYear(), date.getMonth(), date.getDate() + 1).getTime() : date.getTime()) <= now;
+}
+
+type DateStyle = 'date' | 'dateTime' | 'short';
+/** A Wix date as owner copy, through the shared engine-intl shapes: `date` "Jan 5, 2026",
+ *  `dateTime` "Mon, Jan 5, 3:07 PM", `short` "Jan 5" (with the year when it is not this year).
+ *  A value that is not a date at all is kept as Wix sent it. */
+function ownerDate(value: string, zone: string | undefined, style: DateStyle = 'date'): string {
+  if (!value) return '';
+  const parsed = ownerInstant(value);
+  if (!parsed) return value;
+  const { date } = parsed, tz = parsed.dayOnly ? undefined : zone;
+  if (style === 'dateTime') return formatWeekdayDateTime(date, undefined, tz);
+  if (style === 'short' && calendarDay(date, tz).slice(0, 4) === calendarDay(new Date(), tz).slice(0, 4)) return formatMonthDay(date, undefined, tz);
+  return formatDateMedium(date, undefined, tz);
+}
 function offsetOf(cursor: string): number {
   if (cursor && !/^\d{1,9}$/.test(cursor)) throw new Error('Invalid collection cursor. Refresh this view.');
   return Number(cursor || 0);
 }
-function page(module: OwnerModuleId, rows: unknown[], nextCursor: string, total?: number, complete?: boolean): CollectionPage<OwnerRecord> {
-  return { items: rows.map(row => ownerRecord(module, row)), nextCursor, total, ...(complete === undefined ? {} : { complete }) };
+function page(rows: unknown[], nextCursor: string, total?: number, complete?: boolean): CollectionPage<unknown> {
+  return { items: rows, nextCursor, total, ...(complete === undefined ? {} : { complete }) };
 }
-function offsetPage(module: OwnerModuleId, rows: unknown[], offset: number, metadata: unknown) {
+function offsetPage(rows: unknown[], offset: number, metadata: unknown) {
   const total = at(metadata, 'total');
   const more = rows.length > 0 && (typeof total === 'number' ? offset + rows.length < total : rows.length === LIMIT);
-  return page(module, rows, more ? String(offset + rows.length) : '', typeof total === 'number' ? total : undefined);
+  return page(rows, more ? String(offset + rows.length) : '', typeof total === 'number' ? total : undefined);
 }
 
 /** Domain query shapes stay here, shared by list and detail workers. Unsupported
  * server name queries remain explicitly labelled searches of loaded records. */
 export async function queryOwnerModule(module: OwnerModuleId, cursor = ''): Promise<CollectionPage<OwnerRecord>> {
+  // The zone lookup runs beside the query, not after it: the two are independent, and serial
+  // they would double the time to a first paint.
+  const [raw, zone] = await Promise.all([queryRawOwnerModule(module, cursor), siteZone()]);
+  return { ...raw, items: raw.items.map(row => ownerRecord(module, row, zone)) };
+}
+
+async function queryRawOwnerModule(module: OwnerModuleId, cursor: string): Promise<CollectionPage<unknown>> {
   const cursorPaging = { limit: LIMIT, ...(cursor ? { cursor } : {}) };
   switch (module) {
     case 'invoices': {
       const offset = offsetOf(cursor), r = await queryInvoices({ query: { paging: { limit: LIMIT, offset } } });
-      return offsetPage(module, r.invoices ?? [], offset, r.pagingMetadata);
+      return offsetPage(r.invoices ?? [], offset, r.pagingMetadata);
     }
     case 'coupons': {
       const offset = offsetOf(cursor), r = await queryCoupons({ paging: { limit: LIMIT, offset } });
-      return offsetPage(module, r.coupons ?? [], offset, r.metadata);
+      return offsetPage(r.coupons ?? [], offset, r.metadata);
     }
     case 'giftCards': {
       const r = await queryGiftCards({ query: { cursorPaging, sort: [{ fieldName: 'createdDate', order: 'DESC' }] } });
-      return page(module, r.giftCards ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.giftCards ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'contacts': {
       const offset = offsetOf(cursor), r = await queryContacts({ query: { paging: { limit: LIMIT, offset } } });
-      return offsetPage(module, r.contacts ?? [], offset, r.pagingMetadata);
+      return offsetPage(r.contacts ?? [], offset, r.pagingMetadata);
     }
     case 'members': {
       const offset = offsetOf(cursor), r = await queryMembers({ query: { paging: { limit: LIMIT, offset } } });
-      return offsetPage(module, r.members ?? [], offset, r.metadata);
+      return offsetPage(r.members ?? [], offset, r.metadata);
     }
     case 'groups': {
       const offset = offsetOf(cursor), r = await queryGroups({ paging: { limit: LIMIT, offset } });
-      return offsetPage(module, r.groups ?? [], offset, r.metaData);
+      return offsetPage(r.groups ?? [], offset, r.metaData);
     }
     case 'reviews': {
       const r = await queryReviews({ cursorPaging, sort: [{ fieldName: 'createdDate', order: 'DESC' }] }, true);
-      return page(module, r.reviews ?? r.results ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.reviews ?? r.results ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'programs': {
       const r = await queryPrograms({ cursorPaging });
-      return page(module, r.programs ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.programs ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'badges': {
       const r = await queryBadges({ query: { cursorPaging } });
-      return page(module, r.badges ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.badges ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'reservations': {
       const r = await queryReservations({ cursorPaging, sort: [{ fieldName: 'details.startDate', order: 'ASC' }] });
-      return page(module, r.reservations ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.reservations ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'portfolio': {
       const r = await listProjects(LIMIT, cursor || undefined);
-      return page(module, r.projects ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.projects ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'donationCampaigns': {
       const r = await queryDonationCampaigns({ query: { cursorPaging, sort: [{ fieldName: 'updatedDate', order: 'DESC' }] } });
-      return page(module, r.donationCampaigns ?? [], r.pagingMetadata?.cursors?.next ?? '');
+      return page(r.donationCampaigns ?? [], r.pagingMetadata?.cursors?.next ?? '');
     }
     case 'forms': {
       // This collection is Wix Forms. Booking/event registration forms belong
       // to their respective operational records, rather than a mixed union
       // that silently drops namespaces when one permission check fails.
       const offset = offsetOf(cursor), r = await queryForms({ filter: { namespace: 'wix.form_app.form' }, paging: { limit: LIMIT, offset } });
-      return offsetPage(module, r.forms ?? [], offset, r.metaData);
+      return offsetPage(r.forms ?? [], offset, r.metaData);
     }
     case 'plans': {
       const r = await listPlans();
-      return page(module, r.plans ?? [], '', r.pagingMetadata?.total, false);
+      return page(r.plans ?? [], '', r.pagingMetadata?.total, false);
     }
     case 'subscriptions': {
       const r = await listPlanOrders();
-      return page(module, r.orders ?? [], '', r.pagingMetadata?.total, false);
+      return page(r.orders ?? [], '', r.pagingMetadata?.total, false);
     }
   }
 }
 
-export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
+export function ownerRecord(module: OwnerModuleId, raw: unknown, zone?: string): OwnerRecord {
+  const when = (path: string, style?: DateStyle) => ownerDate(field(raw, path), zone, style);
   const id = field(raw, 'id');
   if (!id) throw new Error('Wix returned a record without an identity. Refresh this view.');
   let title = '', subtitle = '', image = '', statusLabel = '';
@@ -127,7 +182,7 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
       title = field(raw, 'specification.name') || field(raw, 'displayData.name');
       subtitle = field(raw, 'specification.code');
       statusLabel = at(raw, 'expired') === true ? 'Expired' : at(raw, 'specification.active') === true ? 'Active' : 'Inactive';
-      details = [['Code', subtitle], ['Uses', field(raw, 'numberOfUsages')], ['Offer', words(field(raw, 'specification.type'))], ['Expires', field(raw, 'specification.expirationTime')]];
+      details = [['Code', subtitle], ['Uses', field(raw, 'numberOfUsages')], ['Offer', words(field(raw, 'specification.type'))], ['Expires', when('specification.expirationTime')]];
       break;
     case 'giftCards': {
       const suffix = field(raw, 'codeSuffix');
@@ -147,7 +202,7 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
         ['Initial value', field(raw, 'initialValue.formattedAmount') || join(field(raw, 'initialValue.amount'), field(raw, 'currency'))],
         ['Recipient', recipient],
         ['Order number', field(raw, 'orderInfo.orderNumber')],
-        ['Expires', expires],
+        ['Expires', when('expirationDate')],
         ['Source', words(field(raw, 'source'))],
       ];
       break;
@@ -156,7 +211,7 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
       title = field(raw, 'number') ? `#${field(raw, 'number')}` : field(raw, 'title');
       subtitle = field(raw, 'customerInfo.contactDetails.fullName') || name(raw, 'customerInfo.contactDetails.firstName', 'customerInfo.contactDetails.lastName') || field(raw, 'customerInfo.contactDetails.email');
       statusLabel = words(field(raw, 'status'));
-      details = [['Customer', subtitle], ['Total', join(field(raw, 'totals.total'), field(raw, 'currency'))], ['Due', field(raw, 'dueDate')]];
+      details = [['Customer', subtitle], ['Total', join(field(raw, 'totals.total'), field(raw, 'currency'))], ['Due', when('dueDate')]];
       break;
     case 'contacts':
       title = name(raw, 'info.name.first', 'info.name.last') || field(raw, 'primaryInfo.email');
@@ -167,12 +222,12 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
     case 'members':
       title = field(raw, 'profile.nickname') || name(raw, 'contact.firstName', 'contact.lastName') || field(raw, 'loginEmail');
       subtitle = field(raw, 'loginEmail'); image = field(raw, 'profile.photo.url'); statusLabel = words(field(raw, 'status'));
-      details = [['Email', subtitle], ['Last login', field(raw, 'lastLoginDate')]];
+      details = [['Email', subtitle], ['Last login', when('lastLoginDate')]];
       break;
     case 'groups':
       title = field(raw, 'name'); subtitle = field(raw, 'description') || field(raw, 'teaser');
       image = field(raw, 'coverImage.imageInfo.url'); statusLabel = words(field(raw, 'privacyStatus'));
-      details = [['Members', field(raw, 'memberCount') || field(raw, 'membersCount')], ['Last activity', field(raw, 'lastActivityDate')]];
+      details = [['Members', field(raw, 'memberCount') || field(raw, 'membersCount')], ['Last activity', when('lastActivityDate')]];
       break;
     case 'reviews':
       title = field(raw, 'content.title'); subtitle = field(raw, 'content.body'); statusLabel = words(field(raw, 'moderation.moderationStatus'));
@@ -184,8 +239,14 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
       details = [['Price', join(field(raw, 'pricing.price.value'), field(raw, 'pricing.price.currency'))], ['Free trial days', field(raw, 'pricing.freeTrialDays')]];
       break;
     case 'subscriptions':
-      title = field(raw, 'planName'); subtitle = field(raw, 'buyer.memberId'); statusLabel = words(field(raw, 'status'));
-      details = [['Member ID', subtitle], ['Started', field(raw, 'startDate')], ['Ends', field(raw, 'endDate')], ['Payment', words(field(raw, 'lastPaymentStatus'))]];
+      // The buyer is only a member UUID here — not something an owner can read — so the
+      // row says when the plan started instead of echoing an internal id.
+      title = field(raw, 'planName'); statusLabel = words(field(raw, 'status'));
+      {
+        const started = when('startDate', 'short');
+        subtitle = started ? copyTemplate('ownerModules.startedOn', 'Started {date}', { date: started }) : '';
+      }
+      details = [['Started', when('startDate')], ['Ends', when('endDate')], ['Payment', words(field(raw, 'lastPaymentStatus'))]];
       break;
     case 'programs':
       title = field(raw, 'description.title') || field(raw, 'details.title') || field(raw, 'name');
@@ -203,13 +264,14 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
       break;
     }
     case 'reservations':
-      title = name(raw, 'reservee.firstName', 'reservee.lastName'); subtitle = field(raw, 'details.startDate'); statusLabel = words(field(raw, 'status'));
+      title = name(raw, 'reservee.firstName', 'reservee.lastName'); subtitle = when('details.startDate', 'dateTime'); statusLabel = words(field(raw, 'status'));
       details = [['Arrival', subtitle], ['Party size', field(raw, 'details.partySize')], ['Email', field(raw, 'reservee.email')], ['Phone', field(raw, 'reservee.phone')]];
       break;
     case 'forms':
-      title = field(raw, 'name'); subtitle = field(raw, 'namespace');
+      // The list is filtered to one namespace (`wix.form_app.form`), so the namespace is an
+      // internal constant, not information — it never reaches copy.
+      title = field(raw, 'name') || copyParam('ownerModules.untitledForm', 'Untitled form');
       statusLabel = typeof at(raw, 'enabled') === 'boolean' ? at(raw, 'enabled') ? 'Enabled' : 'Disabled' : '';
-      details = [['Namespace', subtitle]];
       break;
     case 'portfolio':
       title = field(raw, 'title'); subtitle = field(raw, 'description'); image = portfolioCoverRef(at(raw, 'coverImage') as WixMediaImage | string | undefined);
@@ -217,20 +279,25 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
       break;
     case 'donationCampaigns':
       title = field(raw, 'name');
-      subtitle = join(field(raw, 'campaignGoal.targetAmount.formattedAmount'), field(raw, 'campaignGoal.endDate'));
+      {
+        const end = when('campaignGoal.endDate', 'short');
+        subtitle = join(field(raw, 'campaignGoal.targetAmount.formattedAmount'), !end ? ''
+          : ownerPast(field(raw, 'campaignGoal.endDate')) ? copyTemplate('ownerModules.endedOn', 'ended {date}', { date: end })
+          : copyTemplate('ownerModules.endsOn', 'ends {date}', { date: end }));
+      }
       image = field(raw, 'coverImage');
       statusLabel = at(raw, 'archived') === true ? 'Archived' : words(field(raw, 'status'));
       details = [
         ['Goal', field(raw, 'campaignGoal.targetAmount.formattedAmount') || field(raw, 'campaignGoal.targetAmount.amount')],
-        ['End date', field(raw, 'campaignGoal.endDate')],
+        ['End date', when('campaignGoal.endDate')],
         ['Frequencies', Array.isArray(at(raw, 'donationFrequencies')) ? (at(raw, 'donationFrequencies') as unknown[]).map(String).join(', ') : ''],
         ['Custom amount', yesNo(at(raw, 'customAmountEnabled'))],
       ];
       break;
   }
   details.push(
-    ['Created', field(raw, 'createdDate') || field(raw, 'dateCreated') || field(raw, 'createDate')],
-    ['Updated', field(raw, 'updatedDate') || field(raw, 'updateDate')],
+    ['Created', when('createdDate') || when('dateCreated') || when('createDate')],
+    ['Updated', when('updatedDate') || when('updateDate')],
   );
   return { id, moduleId: module, title: title || copyParam('ownerModules.untitled', 'Untitled record'), subtitle, image: wixMediaUrl(image), statusLabel,
     detailScreenId: `himi_owner_lite_record_${module}`,
@@ -240,6 +307,7 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown): OwnerRecord {
 
 export async function getOwnerRecord(module: OwnerModuleId, id: string): Promise<OwnerRecord> {
   if (!/^[A-Za-z0-9_.:-]{1,128}$/.test(id)) throw new Error('This record link is invalid. Return to the collection.');
+  const zone = siteZone(); // started now, beside the record fetch; it never rejects
   let raw: unknown;
   switch (module) {
     case 'coupons': raw = (await getCoupon(id)).coupon; break;
@@ -270,13 +338,13 @@ export async function getOwnerRecord(module: OwnerModuleId, id: string): Promise
         seen.add(next); cursor = next;
       }
       if (!raw) throw new Error('This project could not be located. Open the portfolio in Wix to check its availability.');
-      const record = ownerRecord(module, raw);
+      const record = ownerRecord(module, raw, await zone);
       const media = await listProjectItems(id, 100);
       return { ...record, fields: [...record.fields, { id: 'media', label: 'Loaded media items', value: String(media.items?.length ?? 0) }] };
     }
     case 'donationCampaigns': raw = (await getDonationCampaign(id)).donationCampaign; break;
   }
-  const record = ownerRecord(module, raw);
+  const record = ownerRecord(module, raw, await zone);
   if (record.id !== id) throw new Error('The returned record does not match this link. Refresh the collection.');
   return record;
 }

package/templates/portfolio-creative-owner/tier5-src/_shared/owner-selected-site.ts

@@ -0,0 +1,103 @@
+// The business the owner is managing RIGHT NOW, shared by every __HIMI_APP_NAME__ worker.
+//
+// Home, Manage, Account and the drawer used to name the business from the build-time
+// `provisioning.json` (`identity.businessName`), so after picking another site on the
+// Sites list the chrome still named the provisioning one — three different names for
+// "the current business" in one session, none of them the site actually picked.
+//
+// The picker (`owner-site-pick.ts`) is the one place that knows both the id and the
+// display name of the business being switched to, so it records them here; every
+// other worker reads them back. The channel is `himalaya.storage` — the app-scoped KV
+// every worker of the app shares on every host (UserDefaults / SharedPreferences / one
+// localStorage namespace) and that needs no capability.
+//
+// ONE key, not one per owner: the host only tells a worker who the owner is once a
+// business is scoped, so the picker (which runs before that) and the screens after it
+// would otherwise land on different keys. The owner is recorded INSIDE the entry
+// instead, and an entry written for a different owner is never shown.
+//
+// The build-time name is only ever the cold-start fallback, passed in by the
+// descriptor: a worker never hardcodes it.
+
+import { initials } from "./himi-text.js";
+
+type StorageLike = { getItem(key: string): string | null; setItem(key: string, value: string): void };
+type Host = typeof globalThis & { himalaya?: { storage?: StorageLike; input?: Record<string, unknown> } };
+
+export interface SelectedSite {
+  id: string;
+  name: string;
+}
+
+const KEY = "himi.ownerLite.selectedSite.v1";
+
+function host(): Host["himalaya"] {
+  return (globalThis as Host).himalaya;
+}
+
+function inputString(key: string): string {
+  const v = host()?.input?.[key];
+  return typeof v === "string" && v !== "default" ? v.trim() : "";
+}
+
+/** The business the owner last picked, or null when none has been picked, the host
+ *  has no storage, or the entry does not apply to this worker. Never throws. */
+export function readSelectedSite(): SelectedSite | null {
+  try {
+    const raw = host()?.storage?.getItem(KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw) as Partial<SelectedSite> & { account?: unknown };
+    const id = typeof parsed?.id === "string" ? parsed.id.trim() : "";
+    const name = typeof parsed?.name === "string" ? parsed.name.trim() : "";
+    if (!id || !name) return null;
+    // Another owner's pick on a shared device is never this owner's business. Fail
+    // CLOSED: an owner-tagged entry is shown only to a worker that knows it IS that
+    // owner. A worker that cannot tell who the owner is (the account-level flow before
+    // a business is scoped, or a host that cannot supply the identity) gets the
+    // fallback, never a name that may be another owner's.
+    const account = typeof parsed.account === "string" ? parsed.account : "";
+    const me = inputString("__himiPreferenceAccount");
+    if (account && account !== me) return null;
+    // An entry the picker wrote before the host knew the owner is CLAIMED by the first
+    // worker that does know it, so from then on no other owner on the device reads it.
+    if (!account && me) host()?.storage?.setItem(KEY, JSON.stringify({ id, name, account: me }));
+    // A screen opened FOR a specific business (a deep link or push carrying
+    // `business`) names that business's data; a name recorded for another one would
+    // sit over the wrong numbers, so it falls back instead.
+    const opened = inputString("business");
+    if (opened && opened !== id) return null;
+    return { id, name };
+  } catch {
+    return null; // a corrupt entry reads as "nothing picked", never as a crash
+  }
+}
+
+/** Record the business the owner just picked. Best-effort: a host without storage
+ *  simply keeps showing the fallback. */
+export function rememberSelectedSite(site: SelectedSite): void {
+  const id = site.id.trim();
+  const name = site.name.trim();
+  if (!id || !name) return;
+  const account = inputString("__himiPreferenceAccount");
+  try {
+    host()?.storage?.setItem(KEY, JSON.stringify(account ? { id, name, account } : { id, name }));
+  } catch {
+    // Quota / storage disabled: the chrome falls back to the build-time name.
+  }
+}
+
+/** Display name for "the current business": the picked one, else `fallback`. */
+export function selectedSiteName(fallback: string): string {
+  return readSelectedSite()?.name || fallback;
+}
+
+/** Badge letters for a business name ("Riverbend Market" → "RM"); Unicode-aware. */
+export function siteInitials(name: string): string {
+  return initials(name);
+}
+
+/** The fallback name a descriptor passes in its `onAppear` params (`businessName`). */
+export function fallbackNameFrom(arg: unknown, current = ""): string {
+  const v = (arg as { businessName?: unknown } | undefined)?.businessName;
+  return typeof v === "string" && v.trim() ? v.trim() : current;
+}

package/templates/portfolio-creative-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/portfolio-creative-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/portfolio-creative-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/portfolio-creative-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(),