@wix/himalaya-cli 0.1613.0 → 0.1615.0

package/templates/yoga-studio/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/yoga-studio/tier5-src/himi-booking-service/index.ts

@@ -22,6 +22,7 @@ import { wixMediaUrl, WIX_DETAIL_IMAGE, WIX_LIST_IMAGE } from "@himalaya/wix-med
 import { formatClock, formatDateMedium, formatMonthDay } from "../_shared/engine-intl.js";
 import { descriptionBody } from "../_shared/rich-body.js";
 import { openRichLink } from "../_shared/rich-content-link.js";
+import { isServiceSaved, toggleSavedService } from "../_shared/himi-booking-saved.js";
 
 // Offline-first (data-offline): the service detail is a public read-through. On a
 // fetch failure we fall back to the last-synced row for this service written by
@@ -182,6 +183,13 @@ interface S {
   sessionMessageOk: boolean;
   sessionMessageFailed: boolean;
   noSessionMessage: boolean;
+  // ---- Favorites (the heart an app adds with withServiceSaveToggle; _shared/himi-booking-saved.ts) ----
+  saved: boolean;
+  notSaved: boolean;
+  /** The heart's spoken label: what a tap does now. */
+  saveLabel: string;
+  /** "" unless the last save or unsave failed. */
+  saveMessage: string;
 }
 
 function inputId(): string {
@@ -790,6 +798,10 @@ function derive(s: S): S {
     // Change Time opens the time screen, which cannot book a service closed to online booking.
     noChangeTime: (control !== "book" && control !== "waitlist" && control !== "closed") || !s.bookableOnline,
     noSessionMessage: !s.sessionMessage,
+    notSaved: !s.saved,
+    saveLabel: s.saved
+      ? copyParam("service.unsaveLabel", "Remove from favorites")
+      : copyParam("service.saveLabel", "Save to favorites"),
     notBookableOnline: !s.bookableOnline,
     noAbout: !s.about && !s.aboutJson,
     noPolicy: s.policyLines.length === 0,
@@ -866,9 +878,16 @@ function withService(s: S, service: WixService): S {
     // WS-C — canonical param-less target; the descriptor's choose-time CTA
     // binds the separate `id` state field as a first-class nav param.
     timeScreenId: "himi_time",
+    saved: savedNow(serviceId),
   });
 }
 
+/** Whether the service is a favorite. Unreadable storage reads as not saved: the heart is a
+ *  convenience and never holds the screen back. */
+function savedNow(id: string): boolean {
+  try { return !!id && isServiceSaved(id); } catch { return false; }
+}
+
 /** The service record: with staff details when this token may read them, else without. */
 async function fetchService(id: string): Promise<WixService | undefined> {
   try {
@@ -897,9 +916,10 @@ const svc = defineService<S, {
   book: (s: S) => S;
   changeTime: (s: S) => S;
   joinWaitlist: (s: S, arg?: unknown) => Promise<S>;
+  toggleSaved: (s: S) => S;
 }>("himiBookingService", {
   // A join's outcome belongs to that visit: a cold start must not replay it from saved state.
-  notHydrated: ["sessionMessage", "sessionMessageOk", "sessionMessageFailed", "noSessionMessage"],
+  notHydrated: ["sessionMessage", "sessionMessageOk", "sessionMessageFailed", "noSessionMessage", "saveMessage"],
   state: derive({
     status: "loading",
     id,
@@ -1005,6 +1025,10 @@ const svc = defineService<S, {
     noChangeTime: true,
     ...NO_SESSION_MESSAGE,
     noSessionMessage: true,
+    saved: false,
+    notSaved: true,
+    saveLabel: "",
+    saveMessage: "",
   }),
   actions: {
     load: async (s, arg) => {
@@ -1012,14 +1036,16 @@ const svc = defineService<S, {
       rememberSignIn(arg);
       if (!s.id) return derive({ ...s, status: "ready", errored: true });
       // A new view: a join's outcome from before is not news when the screen shows again.
-      const start = { ...s, policyExpanded: false, scheduleExpanded: false, ...NO_SESSION_MESSAGE };
+      const start = { ...s, policyExpanded: false, scheduleExpanded: false, saveMessage: "", ...NO_SESSION_MESSAGE };
       try {
         const service = await fetchService(s.id);
         if (!service) return withSession(derive({ ...start, status: "ready" }), undefined);
         loadedService = service;
         // The session the Agenda row opened on, read beside the service-wide availability.
         const [shown, sel] = await Promise.all([withGroupAvailability(withService(start, service), service), readSessionBounded(service)]);
-        return withSession(shown, sel);
+        // The heart is read again after the waits (the session read takes up to 10 s): a toggle
+        // tapped meanwhile wrote storage, and the snapshot taken before would undo it.
+        return withSession({ ...shown, saved: savedNow(s.id) }, sel);
       } catch {
         // Offline: paint from the last-synced services cache (written by the list
         // worker) before falling back to the error state. The cache holds the name,
@@ -1038,6 +1064,7 @@ const svc = defineService<S, {
             category: String(cached.category ?? ""),
             images: image ? [{ url: image, alt: name }] : [],
             timeScreenId: `himi_time_${s.id}`,
+            saved: savedNow(s.id),
           }, undefined);
         }
         return withSession({ ...start, status: "ready", errored: true, name: "" }, undefined);
@@ -1056,6 +1083,26 @@ const svc = defineService<S, {
     },
     togglePolicy: (s) => derive({ ...s, policyExpanded: !s.policyExpanded }),
     toggleSchedule: (s) => derive({ ...s, scheduleExpanded: !s.scheduleExpanded }),
+    // The heart: save or unsave this service on the device (the member's own list once signed
+    // in). The row keeps what the Favorites list shows offline; a failed write says so and never
+    // shows the heart as saved.
+    toggleSaved: (s) => {
+      if (!s.id || !s.hasService || s.errored) return s;
+      try {
+        const saved = toggleSavedService({
+          id: s.id,
+          name: s.name,
+          price: s.priceIsText ? "" : s.priceText,
+          duration: s.durationText,
+          image: s.image,
+          category: s.category,
+          ...(s.isCourse ? { course: true } : {}),
+        });
+        return derive({ ...s, saved, saveMessage: "" });
+      } catch {
+        return derive({ ...s, saved: savedNow(s.id), saveMessage: copyParam("service.saveError", "Could not update your favorites. Try again.") });
+      }
+    },
     // The footer button opens the time screen for the loaded service. A worker directive,
     // not a `himi.open` with a `$service:` id param: the iOS and Android sticky footers
     // dispatch their taps without resolving `$service:` params, so the id never arrived.

package/templates/yoga-studio/tier5-src/himi-booking-services/index.ts

@@ -3,7 +3,8 @@
 // Visitors browse every Wix Bookings service of the site, grouped by category under a small
 // title, in the business's own order (the order of the site's Book Online page). The category
 // chips are anchors, not filters: a tap scrolls the list to its category's title, and the chip
-// of the category at the top of the list lights up while the member scrolls. A name search
+// of the category at the top of the list lights up while the member scrolls. Opened with a
+// `category` nav param (a category tile), the list starts at that category. A name search
 // keeps the grouping. With two or more locations a pin limits the list to the services offered
 // at one location; the choice is shared with the Agenda and Choose Time screens. Each row
 // carries what the service record has: photo, name, tagline, a Class or Course tag, and
@@ -449,10 +450,57 @@ let activeCategory = "";
 let activeChosen = false;
 let scrollTarget = "";
 let jumps = 0;
+/** This worker run's own mark on its jump values. A renderer remembers the value it last jumped
+ *  for, and a screen restored from an earlier visit can bring that memory back: a value that
+ *  repeats across runs ("cat:x|1") would then be taken as done. Not in the state, so the boot
+ *  state (which a release hashes) does not change with the clock. */
+const RUN = Date.now().toString(36);
 let quietUntil = 0;
 /** How long a jump the worker asked for takes to settle: a top-row report inside it is the jump's
  *  own (the renderers suppress those, this is the belt to their braces). */
 const JUMP_SETTLE_MS = 900;
+/** The category this list was opened on (the `category` nav param: a category's Wix id, its
+ *  `name:<name>` key, or its name), e.g. from a category tile. Its chip lights and the list jumps
+ *  to its title once that group shows, and once more when this run's live page lands. After that
+ *  — or as soon as the member scrolls or taps a chip — the member leads.
+ *
+ *  Armed by the screen's own `load` (its onAppear), never by the boot request: the iOS and
+ *  Android lists act on a jump that CHANGES while they are on screen (a chip tap), and drop one
+ *  that is already in the state when they mount. The second jump is for a screen restored from
+ *  its last visit: the host puts back that visit's scroll position after the first one. */
+let pendingCategory = "";
+let bootLoad = true;
+/** This run's own live read has landed (a restored snapshot's rows do not count). */
+let liveLanded = false;
+let jumpedFromCache = false;
+/** The `category` param the list last started at, and that visit's `categoryActivation` (a
+ *  nonce a category tap sends, so a second tap on the SAME category is a new visit too). */
+let openedFor = "";
+let openedActivation = "";
+function inputParam(key: "category" | "categoryActivation"): string {
+  const value = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.[key];
+  return typeof value === "string" ? value.trim().slice(0, 200) : "";
+}
+const inputCategory = (): string => inputParam("category");
+/** Read on every `load`, not once at boot: a pooled worker is handed the next screen's input just
+ *  before its `load` runs (the web host keeps one services worker for every push). The same param
+ *  again is the screen coming back (a pop, a refresh), which keeps the member's place. */
+function armCategory(): boolean {
+  const next = inputCategory();
+  const activation = inputParam("categoryActivation");
+  if (next === openedFor && activation === openedActivation) return false;
+  openedFor = next;
+  openedActivation = activation;
+  pendingCategory = next;
+  jumpedFromCache = false;
+  // A new visit is a new run for a pooled worker: the last visit's live page is not this one's,
+  // so the jump that waits for "this run's live read" waits for the read this load starts.
+  liveLanded = false;
+  // An open with no category ("See all") starts at the top: the last visit's lit chip and its
+  // jump do not carry over to it.
+  if (!next) { activeCategory = ""; activeChosen = false; scrollTarget = ""; }
+  return true;
+}
 
 // ---- Location ------------------------------------------------------------------------
 /** The member's choice (shared with Agenda and Choose Time through the on-device store). */
@@ -500,6 +548,17 @@ function display(s: S): S {
     ...section.rows.map((row) => ({ ...row, isSection: false, notSection: true, sectionTitle: "" })),
   ]);
   const chips = titled && sections.length >= 2 ? sections.map((section) => ({ id: section.id, label: section.title })) : [];
+  const live = liveLanded && !loading;
+  if (pendingCategory && chips.length && (live || !jumpedFromCache)) {
+    const opened = chips.find((chip) => chip.id === sectionIdOf(pendingCategory) || chip.label === pendingCategory);
+    if (opened) {
+      activeCategory = opened.id;
+      activeChosen = true;
+      scrollTarget = `${opened.id}|${RUN}.${++jumps}`;
+      quietUntil = Date.now() + JUMP_SETTLE_MS;
+      if (live) pendingCategory = ""; else jumpedFromCache = true;
+    }
+  }
   // No chips (a reload in flight, a single group): the lit chip waits for the list to come back.
   if (chips.length && (!activeChosen || !chips.some((chip) => chip.id === activeCategory))) activeCategory = chips[0]!.id;
   const target = scrollTarget.split("|")[0];
@@ -553,9 +612,15 @@ const svc = defineBackendCollection<S, Row>("himiBookingServices", {
   register: registerServices,
   restorePagesOnLoad: true,
   onLoad() {
+    let reset: { query: string } | undefined;
+    if (bootLoad) bootLoad = false;
+    // A new visit at a category drops a search the member left on this list: a saved "massage"
+    // would hide the category the tile opened, and its jump would never land.
+    else if (armCategory() && pendingCategory) reset = { query: "" };
     // Copy is stashed before this hook. Repaint restored labels immediately, even
     // when the background query holds the old page through a slow or failed read.
     (svc as unknown as { normalizeRestored?: () => unknown }).normalizeRestored?.();
+    return reset;
   },
   state: { status: "loading", query: "", all: [], results: [], listRows: [], emptyText: "", countLabel: "", errored: false,
     notErrored: true, isLoading: true, notLoading: false, hasResults: false, noEmpty: true,
@@ -639,9 +704,10 @@ const svc = defineBackendCollection<S, Row>("himiBookingServices", {
         ?? ((p as { args?: { selectedIds?: unknown } } | undefined)?.args?.selectedIds);
       const picked = Array.isArray(ids) && typeof ids[0] === "string" ? ids[0] : activeCategory;
       if (!(s.categoryChips ?? []).some((chip) => chip.id === picked)) return s;
+      pendingCategory = "";
       activeCategory = picked;
       activeChosen = true;
-      scrollTarget = `${picked}|${++jumps}`;
+      scrollTarget = `${picked}|${RUN}.${++jumps}`;
       quietUntil = Date.now() + JUMP_SETTLE_MS;
       return display(s);
     },
@@ -653,6 +719,7 @@ const svc = defineBackendCollection<S, Row>("himiBookingServices", {
       if (!rows.some((row) => !row.isSection)) return s;
       const section = sectionOfRow(rows, argOf(p, "id"));
       if (!section || !(s.categoryChips ?? []).some((chip) => chip.id === section)) return s;
+      pendingCategory = "";
       activeCategory = section;
       activeChosen = true;
       // The member has moved on from the last jump: a re-render never scrolls back to it.
@@ -688,7 +755,7 @@ const svc = defineBackendCollection<S, Row>("himiBookingServices", {
     // Ended label the restored row for the same course showed, until a current pack replaces it.
     const shown = new Map((restoredEndedBridge && Array.isArray(s.results) ? s.results : []).map((row) => [row.id, row.endedText]));
     const rows = page.items.map((item) => withRowDefaults(item, shown.get(item.id)));
-    if (page.metadata?.fromCache === false && !loading && !errored) restoredEndedBridge = false;
+    if (page.metadata?.fromCache === false && !loading && !errored) { restoredEndedBridge = false; liveLanded = true; }
     const filtered = page.criteria.filter.startsWith("value:");
     const hasQuery = !!page.criteria.query.trim();
     // The menu offers every location of the whole catalog: a settled live read replaces it, the

package/templates/yoga-studio/tier5-src/himi-booking-time/index.ts

@@ -326,6 +326,9 @@ function inputId(): string {
  *  not just the first, because the boot load and the screen's own `load` can overlap. */
 /** Counts the customer's picks. A load that sees it move ran while they picked a time. */
 let selectionRevision = 0;
+// Each guest tap that asks the session first: only the newest answers, so two quick taps whose
+// reads come back out of order never pick the older time or open a second sign-in.
+let sessionTaps = 0;
 
 let pendingStart = (() => {
   const start = (globalThis as { himalaya?: { input?: { start?: unknown } } }).himalaya?.input?.start;
@@ -958,12 +961,13 @@ let dayRevision = 0;
 /** True while "Check Next Availability" searches; a second tap waits for the first. */
 let checkingNextLock = false;
 
-/** `{ slotId, signInScreenId }` from a pill tap (or a bare slot id). */
-function tapped(arg: unknown): { slotId: string; signInScreenId: string } {
-  if (typeof arg === "string") return { slotId: arg, signInScreenId: "" };
-  const a = (arg ?? {}) as { slotId?: unknown; id?: unknown; signInScreenId?: unknown };
+/** `{ slotId, signInScreenId, signInPresentation }` from a pill tap (or a bare slot id). */
+function tapped(arg: unknown): { slotId: string; signInScreenId: string; signInPresentation: "" | "sheet" | "full_screen" } {
+  if (typeof arg === "string") return { slotId: arg, signInScreenId: "", signInPresentation: "" };
+  const a = (arg ?? {}) as { slotId?: unknown; id?: unknown; signInScreenId?: unknown; signInPresentation?: unknown };
   const slotId = typeof a.slotId === "string" ? a.slotId : typeof a.id === "string" ? a.id : "";
-  return { slotId, signInScreenId: typeof a.signInScreenId === "string" ? a.signInScreenId : "" };
+  const presentation = a.signInPresentation === "sheet" || a.signInPresentation === "full_screen" ? a.signInPresentation : "";
+  return { slotId, signInScreenId: typeof a.signInScreenId === "string" ? a.signInScreenId : "", signInPresentation: presentation };
 }
 
 /** Select a bookable time, as a tap does: the pick-storage rules and the selection revision. */
@@ -1304,12 +1308,40 @@ const svc = defineService<S, {
     // taps it again. Where the regular checkout is not allowed, the tap selects the time for the
     // in-app purchase button.
     pickSlot: async (s, arg): Promise<S | undefined> => {
-      const { slotId, signInScreenId } = tapped(arg);
+      const { slotId, signInScreenId, signInPresentation } = tapped(arg);
       if (bookingLock || s.bookingInFlight || !allRows.some((row) => row.id === slotId && row.selectable)) return derive(s);
       const selected = selectSlotIn(s, slotId);
-      if (!s.isMember) {
+      // A modal sign-in leaves this screen in place: a host need not run its onAppear when the
+      // sheet closes, and the reload that refreshes `isMember` can still be running. So ask the
+      // session before opening the sheet again, or a member's tap would only reopen it. Only the
+      // session's own identity counts here, never getMyData: that can still answer with a stale
+      // site or owner profile for a visitor. A member found here gets the pick and the "tap again"
+      // note, as after a reload, and books on the next tap: that tap passes the booking lock and
+      // the offline guard with the member state, which this await would let a second tap skip.
+      if (!selected.isMember && signInScreenId && signInPresentation) {
+        const mine = ++sessionTaps;
+        const email = await signedInEmail();
+        if (mine !== sessionTaps) return undefined;
+        // From the state as it is NOW: a reload may have landed during the await. The pick
+        // stays only while that time is still bookable.
+        const now = svc.getState?.() ?? s;
+        const open = allRows.some((row) => row.id === slotId && row.selectable);
+        if (email) {
+          return derive({ ...(open ? selectSlotIn(now, slotId) : now), isMember: true, identityLine: email, email,
+            message: open ? copyParam("time.signedInTapAgain", "Signed in. Tap the time again to book it.") : "" });
+        }
+        // Still a guest: the sign-in opens over the newest state; a time gone meanwhile opens nothing.
+        if (!open) return derive(now);
+        return navigate(selectSlotIn(now, slotId), { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", intent: "book", modal: "1" } });
+      }
+      if (!selected.isMember) {
         // Branded Lite opens its sign-in screen; other apps show the sign-in card on this screen.
-        return signInScreenId ? navigate(selected, { screenId: signInScreenId, args: { mode: "signin", intent: "book" } }) : selected;
+        // With a presentation it opens as a modal (`modal`: the sign-in worker closes it after a
+        // sign-in), and this screen loads again under it with the guest's pick kept.
+        if (!signInScreenId) return selected;
+        return navigate(selected, signInPresentation
+          ? { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", intent: "book", modal: "1" } }
+          : { screenId: signInScreenId, args: { mode: "signin", intent: "book" } });
       }
       const regular = regularCheckoutAllowed || applePurchase.usesRegularPlatform();
       if (!regular && !waitlistIds.has(slotId)) {

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

@@ -650,6 +650,9 @@ async function settled(next: S | undefined): Promise<S | undefined> {
 
 /** How the app opens its sign-in screen, from the appear params ("" = push). */
 let signInPresentation: "" | "sheet" | "full_screen" = "";
+/** The app's sign-in screen (`signInScreenId` appear param): Branded Lite's `himi_sign_in` by
+ *  default; an app with no such screen names its own (salon-spa: the Profile tab, `himi_account`). */
+let signInScreenId = "himi_sign_in";
 
 const svc = defineService<S, {
   load: (s: S, p?: unknown) => Promise<S | undefined>;
@@ -678,6 +681,8 @@ const svc = defineService<S, {
       stashCopy(p);
       const presentation = argOf(p, "signInPresentation");
       if (presentation === "sheet" || presentation === "full_screen") signInPresentation = presentation;
+      const signInScreen = argOf(p, "signInScreenId");
+      if (/^[a-z][a-z0-9_]{0,63}$/.test(signInScreen)) signInScreenId = signInScreen;
       const fw = Number(argOf(p, "firstWeekday") || s.firstWeekday);
       const today = dayKey(new Date());
       // First appearance: open on this week. A re-appearance keeps the member's place and
@@ -878,8 +883,8 @@ const svc = defineService<S, {
           busy = false;
           // As a modal it only closes, and this screen loads again (its re-appearance reload).
           return navigate(s, signInPresentation
-            ? { screenId: "himi_sign_in", presentation: signInPresentation, args: { mode: "signin", modal: "1" } }
-            : { screenId: "himi_sign_in", args: { mode: "signin", returnScreenId: "himi_agenda" } });
+            ? { screenId: signInScreenId, presentation: signInPresentation, args: { mode: "signin", modal: "1" } }
+            : { screenId: signInScreenId, args: { mode: "signin", returnScreenId: "himi_agenda" } });
         }
         const name = await memberName();
         const current = await memberAccess().catch(() => undefined);