@wix/himalaya-cli 0.1614.0 → 0.1615.0

package/templates/salon-spa/tier5-src/_shared/himi-booking-saved.ts

@@ -0,0 +1,88 @@
+// Saved (favorite) booking services use the host's durable, app-scoped KV, shared by every
+// screen worker — the service detail toggles a row (himi-booking-service `toggleSaved`), the
+// Favorites list reads them (himi-booking-saved). Same model as _shared/himi-store-saved.ts: a
+// failed write must never claim that a save succeeded.
+export interface SavedService {
+  id: string;
+  name: string;
+  /** The price line as the detail showed it ("$250"), kept so the list paints offline. */
+  price: string;
+  /** The duration line ("1 hr"). */
+  duration: string;
+  image: string;
+  category: string;
+  /** A course: the list's Book passes `course` to the time screen, which then refuses a course
+   *  whose record failed to load instead of offering its sessions one by one. */
+  course?: boolean;
+}
+type StorageLike = { getItem(key: string): string | null; setItem(key: string, value: string): void };
+type Host = { himalaya?: { storage?: StorageLike; input?: Record<string, unknown> }; localStorage?: StorageLike };
+const BASE = "himi-booking:saved-services:v1";
+function storage(): StorageLike {
+  const host = globalThis as Host;
+  const kv = host.himalaya?.storage ?? host.localStorage;
+  if (!kv) throw new Error("Saved-service storage is unavailable");
+  return kv;
+}
+const validPart = (value: unknown): value is string => typeof value === "string" && /^[A-Za-z0-9_.:-]{1,128}$/.test(value) && value !== "default";
+/** Saves belong to whoever made them. A signed-in member's live under the host's authenticated
+ *  account + business — the partition collection preferences use, so a second member on the same
+ *  device never sees them; a visitor's live on the device. A member's partition, read for the
+ *  first time, takes the visitor's saves on this device (signing in carries them, like a cart),
+ *  once — the device list is then emptied. */
+function storeKey(kv: StorageLike): string {
+  const input = (globalThis as Host).himalaya?.input;
+  const account = input?.__himiPreferenceAccount, business = input?.__himiPreferenceBusiness;
+  if (!validPart(account) || !validPart(business)) return BASE;
+  const key = `${BASE}.${account}.${encodeURIComponent(business)}`;
+  if (kv.getItem(key) === null) {
+    const visitor = kv.getItem(BASE);
+    if (visitor !== null) {
+      kv.setItem(key, visitor);
+      // Empty the device list only once the member's copy is confirmed: a web host may swallow a
+      // failed write, and clearing then would lose the visitor's saves.
+      if (kv.getItem(key) === visitor) kv.setItem(BASE, "[]");
+    }
+  }
+  return key;
+}
+const str = (value: unknown): string => (typeof value === "string" ? value : "");
+export function readSavedServices(): SavedService[] {
+  const kv = storage();
+  const raw = kv.getItem(storeKey(kv));
+  if (!raw) return [];
+  const parsed: unknown = JSON.parse(raw);
+  if (!Array.isArray(parsed)) throw new Error("Invalid saved-service data");
+  const rows = new Map<string, SavedService>();
+  for (const value of parsed) {
+    if (!value || typeof value !== "object") continue;
+    const row = value as Record<string, unknown>;
+    if (typeof row.id !== "string" || !row.id.trim() || typeof row.name !== "string") continue;
+    rows.set(row.id, { id: row.id, name: row.name, price: str(row.price), duration: str(row.duration), image: str(row.image), category: str(row.category), ...(row.course === true ? { course: true } : {}) });
+  }
+  return [...rows.values()];
+}
+
+export function isServiceSaved(id: string): boolean {
+  return readSavedServices().some(row => row.id === id);
+}
+export function writeSavedServices(rows: SavedService[]): void {
+  const kv = storage();
+  const key = storeKey(kv);
+  const value = JSON.stringify(rows);
+  kv.setItem(key, value);
+  // Web hosts may swallow quota/security errors. Confirm the synchronous write
+  // before displaying success; a missing/mismatched read is a failed save.
+  if (kv.getItem(key) !== value) throw new Error("Saved-service write did not persist");
+}
+/** Save or unsave; returns the new saved state. The newest save is listed first. */
+export function toggleSavedService(service: SavedService): boolean {
+  if (!service.id.trim() || !service.name.trim()) throw new Error("No service to save");
+  const rows = readSavedServices();
+  const saved = !rows.some(row => row.id === service.id);
+  writeSavedServices(saved ? [service, ...rows] : rows.filter(row => row.id !== service.id));
+  return saved;
+}
+export function removeSavedService(id: string): void {
+  writeSavedServices(readSavedServices().filter(row => row.id !== id));
+}

package/templates/salon-spa/tier5-src/_shared/himi-bookings.ts

@@ -0,0 +1,318 @@
+// Shared Wix Bookings shaping for himi workers (branded-lite `bookings`
+// vertical): defensive extraction where the LIVE services payload drifts from
+// the generated client's types. Used by BOTH the services-list worker
+// (himi_services rows) and the service-detail worker so the two screens agree
+// on one shape (the himi-restaurants.ts pattern).
+
+/** Human-readable category name. The live services payload carries `category`
+ *  as a STRUCTURED object (`{ id, name, sortOrder }`) while the generated
+ *  client types it as a string — joined raw it rendered
+ *  "[object Object] · 1 hr · $111" in the services rows (production sweep R3).
+ *  Extract the name member; an id-only/unrecognizable shape yields "" so the
+ *  caller omits the segment instead of stringifying the object. */
+export function categoryName(value: unknown): string {
+  if (typeof value === "string") return value.trim();
+  if (!value || typeof value !== "object") return "";
+  const name = (value as { name?: unknown }).name;
+  return typeof name === "string" ? name.trim() : "";
+}
+
+import { businessTimeZone } from "./app-locale.js";
+import { formatDateMedium, formatMonthDay, zoneOffsetAt } from "./engine-intl.js";
+import { formatServiceMoney, formatServicePrice, serviceCurrency } from "./wix-service-price.js";
+
+const HAS_OFFSET = /(?:Z|[+-]\d{2}:?\d{2})$/i;
+const LOCAL_TIME = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})(?::(\d{2}))?/;
+
+/** The instant (ms) a slot starts. Wix may list a slot's `startDate` as a LOCAL wall time with its
+ *  `timezone` beside it ("2026-11-02T18:30:00" in America/New_York is 23:30Z); a bare `Date.parse`
+ *  would read that in the device's zone. So a local time is placed in the slot's own zone when this
+ *  engine has Intl and knows the zone, and read in the device's zone only when it cannot be. */
+export function slotStartInstant(slot: { startDate?: string; timezone?: unknown }): number {
+  const start = slot.startDate ?? "";
+  if (!start) return NaN;
+  const local = LOCAL_TIME.exec(start);
+  if (HAS_OFFSET.test(start) || !local || typeof slot.timezone !== "string" || !slot.timezone) return Date.parse(start);
+  const wall = Date.UTC(+local[1], +local[2] - 1, +local[3], +local[4], +local[5], +(local[6] ?? 0));
+  const offset = zoneOffsetAt(wall, slot.timezone);
+  if (!Number.isFinite(offset)) return Date.parse(start);
+  // Once more at the corrected instant, so a wall time beside a DST change lands on the right side.
+  const again = zoneOffsetAt(wall - offset, slot.timezone);
+  return wall - (Number.isFinite(again) ? again : offset);
+}
+
+/** `himi_time` reads the next two weeks. A host's `start` past them (an Agenda session weeks
+ *  ahead) is read on its own — that session's local day only, never everything up to it — so it
+ *  can be preselected while each read stays bounded. `undefined` when the start is inside the two
+ *  weeks. */
+export function availabilityBeyond(now: Date, start = ""): { from: Date; until: Date } | undefined {
+  const end = now.getTime() + 14 * 86_400_000;
+  const at = start ? Date.parse(start) : NaN;
+  if (!Number.isFinite(at) || at < end) return undefined;
+  const d = new Date(at);
+  const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  // Never back into the two weeks already read: a slot in both would be listed twice.
+  return { from: new Date(Math.max(dayStart.getTime(), end)), until: new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1) };
+}
+
+/** The slot a host asked to open at (`himi_time` input `start`, an ISO 8601 instant): the id of the
+ *  slot that starts at that same instant, or "" when none does (taken since, or out of the window).
+ *  Compared as instants, so `…T16:30:00Z` finds a slot listed as `…T18:30:00+02:00`, or as a local
+ *  `…T18:30:00` beside `timezone: "Asia/Jerusalem"`. */
+export function slotIdAt(slots: Iterable<[string, { startDate?: string; timezone?: unknown }]>, start: string): string {
+  const at = start ? Date.parse(start) : NaN;
+  if (!Number.isFinite(at)) return "";
+  for (const [id, slot] of slots) {
+    if (slotStartInstant(slot) === at) return id;
+  }
+  return "";
+}
+
+// ---- Courses ----------------------------------------------------------------------
+// One answer for the service screen's course button and the time screen's course booking, so
+// the button never offers a course that the booking step then refuses.
+
+type CoursePolicyShape = {
+  /** `timeZone`: the business's IANA zone, for a session time Wix lists as a bare local wall time. */
+  schedule?: { id?: string; firstSessionStart?: string; lastSessionEnd?: string; timeZone?: string };
+  bookingPolicy?: {
+    bookAfterStartPolicy?: { enabled?: boolean };
+    limitEarlyBookingPolicy?: { enabled?: boolean; earliestBookingInMinutes?: number };
+    limitLateBookingPolicy?: { enabled?: boolean; latestBookingInMinutes?: number };
+  };
+};
+
+/** A bare local wall time placed in `timeZone`, as an instant (ms). NaN when the value is not a bare local
+ *  time, has an impossible calendar day, or the engine does not know the zone. */
+function placedInstant(value: string, timeZone: string | undefined): number {
+  const local = LOCAL_TIME.exec(value);
+  if (HAS_OFFSET.test(value) || !local || !timeZone || !validDate(value)) return NaN;
+  const wall = Date.UTC(+local[1], +local[2] - 1, +local[3], +local[4], +local[5], +(local[6] ?? 0));
+  const offset = zoneOffsetAt(wall, timeZone);
+  if (!Number.isFinite(offset)) return NaN;
+  // Once more at the corrected instant, so a wall time beside a DST change lands on the right side.
+  const again = zoneOffsetAt(wall - offset, timeZone);
+  return wall - (Number.isFinite(again) ? again : offset);
+}
+
+/** The zone that places a course's bare local session times: the schedule's own, else the app's
+ *  provisioned business zone. "" when there is none: a zone is never guessed. */
+const courseZone = (schedule: { timeZone?: string } | undefined): string => schedule?.timeZone || businessTimeZone();
+
+/** The instant (ms) of a course session time, for the "Ended" label. A time with an offset is exact. A
+ *  bare local wall time is the BUSINESS's wall time, so it is placed in its zone — never in the device's,
+ *  which would present another zone's clock as a confirmed instant. No zone, a date-only value, an
+ *  impossible calendar day or an engine that does not know the zone: unknown (NaN). */
+function sessionInstant(value: string, timeZone: string | undefined): number {
+  return HAS_OFFSET.test(value) ? validDate(value)?.getTime() ?? NaN : placedInstant(value, timeZone);
+}
+
+/** The same instant for the booking rules (window, read range): a bare local time the business zone can
+ *  place is placed there, so the list label, the service screen and the time screen agree. Everything else
+ *  keeps the read they always had (`Date.parse`), so an app with no provisioned zone is unchanged. */
+function courseInstant(value: string | undefined, timeZone: string | undefined): number {
+  const text = value ?? "";
+  const placed = placedInstant(text, timeZone);
+  return Number.isFinite(placed) ? placed : Date.parse(text);
+}
+
+/** A completed course, independent of whether bookings are currently allowed. Missing,
+ *  invalid or reversed dates are unknown, never evidence that a course has ended. A session time
+ *  without an offset counts only when the schedule names the business's `timeZone`. */
+export function courseHasEnded(service: CoursePolicyShape, now: number): boolean {
+  const zone = courseZone(service.schedule);
+  const first = sessionInstant(service.schedule?.firstSessionStart ?? "", zone);
+  const last = sessionInstant(service.schedule?.lastSessionEnd ?? "", zone);
+  return Number.isFinite(now) && Number.isFinite(first) && Number.isFinite(last) && first <= last && last <= now;
+}
+
+/** Does this course schedule hold a session time that is a bare local wall time, which only the
+ *  business's zone can place? A caller reads the zone only when this is true. */
+export function courseNeedsZone(schedule: { firstSessionStart?: string; lastSessionEnd?: string } | undefined): boolean {
+  return [schedule?.firstSessionStart, schedule?.lastSessionEnd].some((value) => !!value && !HAS_OFFSET.test(value) && LOCAL_TIME.test(value));
+}
+
+/** Whether the business takes course bookings at `now` (ms): the course has not ended, has not
+ *  started (unless the policy lets people join late), and `now` is inside its booking window —
+ *  which the early and late limits count from the first session. */
+export function courseWindowOpen(service: CoursePolicyShape, now: number): boolean {
+  const zone = courseZone(service.schedule);
+  const first = courseInstant(service.schedule?.firstSessionStart, zone);
+  const last = courseInstant(service.schedule?.lastSessionEnd, zone);
+  if (!Number.isFinite(first) || !Number.isFinite(last) || last <= now) return false;
+  const policy = service.bookingPolicy;
+  if (first < now && policy?.bookAfterStartPolicy?.enabled !== true) return false;
+  const early = policy?.limitEarlyBookingPolicy;
+  if (early?.enabled && typeof early.earliestBookingInMinutes === "number" && now < first - early.earliestBookingInMinutes * 60_000) return false;
+  const late = policy?.limitLateBookingPolicy;
+  if (late?.enabled && typeof late.latestBookingInMinutes === "number" && now > first - late.latestBookingInMinutes * 60_000) return false;
+  return true;
+}
+
+/** How far ahead a course is read: the whole remaining course, up to a year. Both screens read the
+ *  same sessions — from the later of its first session and now — so the service screen never
+ *  offers a course that the booking step then refuses on a session the first did not read. */
+export const COURSE_READ_DAYS = 366;
+const DAY = 86_400_000;
+
+/** The 14-day availability windows covering a course's remaining sessions, and whether they reach
+ *  its last session (`complete`) and start at its first (`fromFirst`, so a count is the whole
+ *  course). Empty when the course has no usable dates or has ended. */
+export function courseReadWindows(service: CoursePolicyShape, now: number, chunkDays = 14): { windows: Array<[number, number]>; complete: boolean; fromFirst: boolean } {
+  const zone = courseZone(service.schedule);
+  const first = courseInstant(service.schedule?.firstSessionStart, zone);
+  const last = courseInstant(service.schedule?.lastSessionEnd, zone);
+  if (!Number.isFinite(first) || !Number.isFinite(last)) return { windows: [], complete: false, fromFirst: false };
+  const from = Math.max(first, now);
+  const courseEnd = last + DAY;
+  const until = Math.min(courseEnd, from + COURSE_READ_DAYS * DAY);
+  const windows: Array<[number, number]> = [];
+  for (let at = from; at < until; at += chunkDays * DAY) windows.push([at, Math.min(until, at + chunkDays * DAY)]);
+  return { windows, complete: courseEnd <= until, fromFirst: from === first };
+}
+
+type CourseEntryShape = { slot?: { startDate?: string; timezone?: unknown }; bookable?: boolean; openSpots?: number };
+
+/** A course across EVERY upcoming session read: a customer books all of them at once, so the
+ *  smallest open count is the course's, and one session that cannot be booked closes it. A start
+ *  is read in the session's own zone (`slotStartInstant`). `found` is false when no upcoming
+ *  session came back: both screens then treat the course as not bookable. So is a course whose
+ *  read did not reach its last session (`readComplete`, from `courseReadWindows`): a session
+ *  past the year read may be full, and the course is booked whole. */
+export function courseSessionsAvailability(entries: readonly CourseEntryShape[], now: number, readComplete = true): { found: boolean; spots: number | undefined; bookable: boolean } {
+  const upcoming = entries.filter((entry) => {
+    const start = entry.slot ? slotStartInstant(entry.slot as { startDate?: string; timezone?: unknown }) : NaN;
+    return Number.isFinite(start) && start >= now;
+  });
+  if (!upcoming.length) return { found: false, spots: undefined, bookable: false };
+  const counts = upcoming.map((entry) => entry.openSpots).filter((n): n is number => typeof n === "number" && Number.isFinite(n) && n >= 0);
+  const spots = counts.length ? Math.min(...counts) : undefined;
+  return { found: true, spots, bookable: readComplete && upcoming.every((entry) => entry.bookable !== false) && spots !== 0 };
+}
+
+// ---- Price, duration and course dates ------------------------------------------------
+// One answer for the services list and the service screen, so a row and the screen it opens
+// say the same price and the same length. Each screen reads its own copy keys: the caller
+// passes a `BookingLabel` reader bound to its prefix ("service." on the service screen,
+// "services." on the list).
+
+/** Reads one copy line by its key suffix ("priceFree", "days"). `values` fills {placeholders}. */
+export type BookingLabel = (key: string, fallback: string, values?: Record<string, string | number>) => string;
+
+type PricedServiceShape = {
+  type?: string;
+  duration?: unknown;
+  payment?: {
+    rateType?: unknown;
+    fixed?: { price?: unknown };
+    varied?: { minPrice?: unknown; defaultPrice?: unknown };
+    custom?: { description?: unknown };
+  };
+  schedule?: {
+    firstSessionStart?: string;
+    lastSessionEnd?: string;
+    availabilityConstraints?: {
+      sessionDurations?: unknown[];
+      durations?: Array<{ minutes?: unknown } | undefined>;
+      durationRange?: {
+        hourOptions?: { minDurationInMinutes?: unknown; maxDurationInMinutes?: unknown };
+        dayOptions?: { minDurationInDays?: unknown; maxDurationInDays?: unknown };
+      };
+    };
+  };
+};
+
+function trimmed(value: unknown): string {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function finiteNumber(value: unknown): number | undefined {
+  if (typeof value === "number") return Number.isFinite(value) ? value : undefined;
+  if (typeof value === "string" && value.trim()) {
+    const n = Number(value);
+    return Number.isNaN(n) ? undefined : n;
+  }
+  return undefined;
+}
+
+export interface ServicePriceLine { text: string; unit: string; isText: boolean }
+
+/** The price line by rate type. FIXED → the price, no cents on a whole amount; VARIED →
+ *  "From {price}"; CUSTOM → the owner's description, no unit; NO_FEE → "Free", no unit. */
+export function servicePriceLine(service: PricedServiceShape, label: BookingLabel): ServicePriceLine {
+  const payment = service.payment ?? {};
+  const rate = trimmed(payment.rateType).toUpperCase();
+  const currency = serviceCurrency(service);
+  const unit = service.type === "COURSE"
+    ? label("unitParticipant", "per participant")
+    : label("unitSession", "per session");
+  if (rate === "NO_FEE") return { text: label("priceFree", "Free"), unit: "", isText: false };
+  if (rate === "CUSTOM") return { text: trimmed(payment.custom?.description), unit: "", isText: true };
+  if (rate === "VARIED") {
+    const from = formatServiceMoney(payment.varied?.minPrice, currency) || formatServiceMoney(payment.varied?.defaultPrice, currency);
+    return { text: from ? label("priceFrom", "From {price}", { price: from }) : "", unit: from ? unit : "", isText: false };
+  }
+  // FIXED, or a legacy payload with no rate type.
+  const text = formatServiceMoney(payment.fixed?.price, currency) || formatServicePrice(service);
+  return { text, unit: text ? unit : "", isText: false };
+}
+
+function minutesText(minutes: number): string {
+  if (minutes < 60) return `${minutes} min`;
+  const hours = Math.floor(minutes / 60);
+  const rest = minutes % 60;
+  return rest ? `${hours} hr ${rest} min` : `${hours} hr`;
+}
+
+/** "45 min", "1 hr 30 min"; a service with several lengths, or a flexible range the
+ *  customer picks from: "30 min - 1 hr", "1 day - 3 days". "" when the record has none. */
+export function serviceDurationText(service: PricedServiceShape, label: BookingLabel): string {
+  const constraints = service.schedule?.availabilityConstraints;
+  const positive = (values: unknown[]) => values.map(finiteNumber).filter((n): n is number => n != null && n > 0);
+  const listed = positive([
+    ...(constraints?.sessionDurations ?? []),
+    ...(constraints?.durations ?? []).map((d) => d?.minutes),
+  ]);
+  const hours = constraints?.durationRange?.hourOptions;
+  const range = positive([hours?.minDurationInMinutes, hours?.maxDurationInMinutes]);
+  const days = constraints?.durationRange?.dayOptions;
+  const dayRange = positive([days?.minDurationInDays, days?.maxDurationInDays]);
+  if (!listed.length && !range.length && dayRange.length) {
+    const dayText = (n: number) => (n === 1 ? label("day", "1 day") : label("days", "{n} days", { n }));
+    const first = Math.min(...dayRange);
+    const last = Math.max(...dayRange);
+    return first === last ? dayText(first) : `${dayText(first)} - ${dayText(last)}`;
+  }
+  const minutes = listed.length ? listed : range.length ? range : positive([service.duration]);
+  if (!minutes.length) return "";
+  const min = Math.min(...minutes);
+  const max = Math.max(...minutes);
+  return min === max ? minutesText(min) : `${minutesText(min)} - ${minutesText(max)}`;
+}
+
+function validDate(value: string | undefined): Date | undefined {
+  if (!value) return undefined;
+  const parts = /^(\d{4})-(\d{2})-(\d{2})(?:T|$)/i.exec(value);
+  if (!parts) return undefined;
+  const year = Number(parts[1]), month = Number(parts[2]) - 1, day = Number(parts[3]);
+  // Date accepts February 30 by rolling into March. Check the stated calendar day first;
+  // setUTCFullYear also preserves years 0–99, which Date.UTC would reinterpret as 1900–1999.
+  const calendar = new Date(0);
+  calendar.setUTCFullYear(year, month, day);
+  if (calendar.getUTCFullYear() !== year || calendar.getUTCMonth() !== month || calendar.getUTCDate() !== day) return undefined;
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? date : undefined;
+}
+
+function shortDate(date: Date, year: boolean): string {
+  return year ? formatDateMedium(date, "en") : formatMonthDay(date, "en");
+}
+
+/** A course's dates, "Nov 3 – Dec 15, 2026" (the year on the first date only when the two
+ *  differ). "" when the record has no first or last session. */
+export function courseDatesText(service: PricedServiceShape): string {
+  const first = validDate(service.schedule?.firstSessionStart);
+  const last = validDate(service.schedule?.lastSessionEnd);
+  if (!first || !last) return "";
+  return `${shortDate(first, first.getFullYear() !== last.getFullYear())} – ${shortDate(last, true)}`;
+}

package/templates/salon-spa/tier5-src/_shared/himi-copy.ts

@@ -0,0 +1,89 @@
+// Copy-as-configuration for WORKER-emitted strings (`himi docs designing-himi-screens`,
+// §"Copy is configuration"): a worker never hardcodes user-facing copy — the
+// descriptor bakes the provisioned copy-pack overrides relevant to this worker
+// into its onAppear action params as a `copy` JSON object (customer strings or
+// source-matched stock translations, computed at descriptor-build time), and the
+// worker reads every user-facing string through `copyParam(key, fallback)`.
+//
+// STASHED (the stashed appear-params idiom, himi-branded-lite-home): the
+// param-carrying onAppear dispatch updates the stash; later arg-less calls
+// (self-kick refreshes, retry buttons, pull-to-refresh) fall back to it, so
+// resolution order can never drop the pack. With no pack the param is absent
+// and every read returns `fallback` verbatim — routing a worker string through
+// copyParam is byte-for-byte behavior-preserving.
+//
+// Pure + Hermes-safe (no host globals, no Node APIs; its only import is the pure `app-locale` sibling): bundled into
+// every worker that emits user-facing copy, and copied verbatim into the
+// generated templates' tier5-src/_shared/.
+
+import { isSingular, setAppLocale, setBusinessTimeZone } from "./app-locale.js";
+
+/** Customer strings override every read; translated stock is valid only for its
+ * original English fallback. Some existing keys serve more than one message. */
+export type CopyPackValue = string | { source: string; translation: string };
+
+let stashedCopy: Record<string, CopyPackValue> = Object.create(null);
+let copyReceived = false;
+
+/** Absorb the `copy` onAppear param (customer strings or stock translation records)
+ *  from an action arg. Call first in every action that can receive onAppear
+ *  params (load/refresh). Non-copy args and malformed packs are ignored — the
+ *  stock fallbacks keep rendering. */
+export function stashCopy(arg: unknown): void {
+  if (!arg || typeof arg !== "object") return;
+  // A param-carrying dispatch names the app language and business zone too (absent: the English house
+  // pattern, and no zone).
+  if ("copy" in arg || "locale" in arg || "businessTimeZone" in arg) {
+    setAppLocale((arg as Record<string, unknown>).locale);
+    setBusinessTimeZone((arg as Record<string, unknown>).businessTimeZone);
+  }
+  const raw = (arg as Record<string, unknown>).copy;
+  if (typeof raw !== "string" || !raw) return;
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+    const next: Record<string, CopyPackValue> = Object.create(null);
+    for (const [key, value] of Object.entries(parsed as Record<string, unknown>)) {
+      if (typeof value === "string") next[key] = value;
+      else if (value && typeof value === "object" && !Array.isArray(value)) {
+        const row = value as Record<string, unknown>;
+        if (typeof row.source === "string" && typeof row.translation === "string") {
+          next[key] = { source: row.source, translation: row.translation };
+        }
+      }
+    }
+    stashedCopy = next;
+    copyReceived = true;
+  } catch {
+    // Malformed pack param — keep the stock copy rather than dying mid-action.
+  }
+}
+
+/** The provisioned override for `key`, or `fallback` (the stock copy). An optional
+ *  restored label survives only until a current copy pack arrives. */
+export function copyParam(key: string, fallback: string, restoredFallback = fallback): string {
+  const value = stashedCopy[key];
+  // A disk-restored row may paint before onAppear supplies its copy pack. Keep its
+  // last label only before a pack arrives; even an empty current pack selects stock copy.
+  if (value === undefined) return copyReceived ? fallback : restoredFallback;
+  if (typeof value === "string") return value !== "" ? value : fallback;
+  return value?.source === fallback && value.translation !== "" ? value.translation : fallback;
+}
+
+/** Interpolate `{name}` placeholders in a (possibly overridden) template:
+ *  `copyTemplate("plans.joinOnSite", "…join {name}.", { name })`. Unknown
+ *  placeholders resolve to "" so a typo'd override degrades, never crashes. */
+export function copyTemplate(key: string, fallback: string, values: Record<string, string | number>): string {
+  return copyParam(key, fallback).replace(/\{([A-Za-z0-9_]+)\}/g, (_all, name: string) =>
+    name in values ? String(values[name]) : "",
+  );
+}
+
+/** The small ICU plural form used by Bookings spot counts. The provisioned copy may
+ *  translate both branches without adding a second key for the singular. */
+export function copyPlural(key: string, fallback: string, count: number): string {
+  const pattern = copyParam(key, fallback);
+  const match = /^\{n, plural, one \{([^{}]*)\} other \{([^{}]*)\}\}$/.exec(pattern);
+  if (!match) return copyTemplate(key, fallback, { n: count });
+  return (isSingular(count) ? match[1] : match[2])!.replace(/#/g, String(count));
+}

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

@@ -0,0 +1,7 @@
+// Graduated to the SDK (SP-3): the store display helpers + v3 product query now live in
+// @himalaya/wix-stores. This thin re-export keeps existing bundle imports working; new
+// code should import from "@himalaya/wix-stores" directly.
+// Relative so node (tests importing worker sources) resolves it too — the bare
+// "@himalaya/wix-stores" name exists only in the esbuild alias map / the off-repo
+// umbrella. gen-templates.mts rewrites this back to @himalaya/wix-stores off-repo.
+export * from "@himalaya/wix-stores";

package/templates/salon-spa/tier5-src/_shared/himi-text.ts

@@ -0,0 +1,24 @@
+// Shared display-text helpers for himi cards: trim catalog artifacts from titles and
+// derive up-to-two-letter placeholder initials so same-first-letter lists still vary.
+
+/** Trim trailing artifact markers (stray asterisks / footnote daggers) and whitespace
+ *  that leak from test/seed catalogs, without touching interior punctuation. Falls back
+ *  to the original when trimming would empty the string. */
+export function cleanTitle(value?: string): string {
+  const raw = (value ?? "").trim();
+  const cleaned = raw.replace(/[\s*†‡]+$/u, "").trim();
+  return cleaned || raw;
+}
+
+/** Up to two significant initials for a placeholder avatar. Two-plus words → first
+ *  letter of the first two; a single word → its first two alphanumerics. Keeps a list
+ *  of similar names (e.g. many "Booking…") from collapsing to one identical glyph. */
+export function initials(value?: string): string {
+  const words = (value ?? "").trim().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return "#";
+  if (words.length === 1) {
+    const alnum = words[0].replace(/[^\p{L}\p{N}]/gu, "");
+    return (alnum.slice(0, 2) || "#").toUpperCase();
+  }
+  return ((words[0][0] ?? "") + (words[1][0] ?? "")).toUpperCase();
+}

package/templates/salon-spa/tier5-src/_shared/host-events.ts

@@ -0,0 +1,66 @@
+// Host events — what a member screen tells the app hosting it about something the member did
+// (a booking confirmed or cancelled), so a host such as Symphony can say so in its chat and refresh
+// what it shows.
+//
+// A worker dispatches `host.event` with `{ type, ...fields }` (string values only: a dispatch carries
+// one string params map). An embed (`HimalayaEmbed`) hands it to the host's `onAction` as an action
+// with that id; anywhere else nothing handles it and it is dropped. It is a notice, never a request:
+// the host owns what happens next, and the worker never waits on it or depends on its answer.
+//
+// The contract (hosts parse exactly this — Symphony's `PlaceHostEvent`):
+//   type         booking.created | booking.cancelled | plan.used
+//   serviceName  the class / service title (bookings)      planName   the plan's name (plan.used)
+//   start, end   ISO 8601 instants WITH an offset (`Z` or `+02:00`); a local time is left out
+//   remaining    sessions left on the plan, when known (a whole number)
+//   bookingId, serviceId, planId   when known
+
+import { dispatch } from "@himalaya/dispatch";
+
+export const HOST_EVENT_ACTION_ID = "host.event";
+
+/** The events a member screen reports. */
+export type HostEventType = "booking.created" | "booking.cancelled" | "plan.used";
+
+export interface HostEventFields {
+  bookingId?: string;
+  serviceId?: string;
+  serviceName?: string;
+  planId?: string;
+  planName?: string;
+  start?: string;
+  end?: string;
+  remaining?: number | string;
+}
+
+const WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})$/i;
+
+/** [value] when it is an ISO 8601 instant that names its offset, else "". A slot's LOCAL wall time
+ *  ("2026-11-02T18:30:00") would be read in the host's zone, i.e. a wrong hour, so it is left out. */
+export function hostEventInstant(value: unknown): string {
+  return typeof value === "string" && WITH_OFFSET.test(value) && Number.isFinite(Date.parse(value)) ? value : "";
+}
+
+/** The `host.event` params for [type] and [fields]: unset and empty fields are left out, times
+ *  without an offset are left out, and `remaining` is a whole number ≥ 0 or nothing. */
+export function hostEventParams(type: HostEventType, fields: HostEventFields = {}): Record<string, string> {
+  const params: Record<string, string> = { type };
+  for (const [key, value] of Object.entries(fields)) {
+    let out = "";
+    if (key === "start" || key === "end") out = hostEventInstant(value);
+    else if (key === "remaining") {
+      const n = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN;
+      out = Number.isInteger(n) && n >= 0 ? String(n) : "";
+    } else if (typeof value === "string") out = value.trim();
+    if (out) params[key] = out;
+  }
+  return params;
+}
+
+/** Tell the host about [type]. Never throws: a host that does not listen must not break the screen. */
+export async function emitHostEvent(type: HostEventType, fields: HostEventFields = {}): Promise<void> {
+  try {
+    await dispatch(HOST_EVENT_ACTION_ID, hostEventParams(type, fields));
+  } catch {
+    // Not embedded, or the host has no handler: nothing to tell.
+  }
+}