@wix/himalaya-cli 0.1525.0 → 0.1527.0

package/templates/branded-lite/tier5-src/himi-branded-lite-address/index.ts

@@ -1,9 +1,10 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: Branded Lite — add / edit one saved address (himi_address).
 //
 // No `id` nav param → a new address; `?id=` → that address, prefilled. Save writes it
 // to the member's address book (@himalaya/wix-ecom) and goes back to My Addresses,
 // which reloads on appear. Edit also offers Remove, behind an in-screen confirm.
-import { defineService, navigate } from "@himalaya/state";
+import { defineService as registerService, navigate } from "@himalaya/state";
 import {
   createMemberAddress,
   deleteMemberAddress,
@@ -176,6 +177,7 @@ async function remove(state: State): Promise<State> {
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["save", "remove"], { derive });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   retry: (state: State) => Promise<State>;

package/templates/branded-lite/tier5-src/himi-branded-lite-addresses/index.ts

@@ -1,10 +1,11 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: Branded Lite — My Addresses (the member's saved address book).
 //
 // The same book the site's Members Area "My Addresses" page and checkout use
 // (addresses-web, see @himalaya/wix-ecom listMemberAddresses). A member sees every
 // saved address, picks the default, and removes one after an in-screen confirm;
 // add/edit open himi_address. A guest gets the shared member gate.
-import { defineService, navigate } from "@himalaya/state";
+import { defineService as registerService, navigate } from "@himalaya/state";
 import {
   deleteMemberAddress,
   listMemberAddresses,
@@ -152,6 +153,7 @@ async function write(state: State, run: () => Promise<unknown>, done: string, fa
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["setDefault", "remove"], { derive });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   retry: (state: State) => Promise<State>;

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

@@ -598,6 +598,9 @@ function initial(): S {
   };
 }
 
+/** How the app opens its sign-in screen, from the appear params ("" = push). */
+let signInPresentation: "" | "sheet" | "full_screen" = "";
+
 const svc = defineService<S, {
   load: (s: S, p?: unknown) => Promise<S | undefined>;
   retry: (s: S) => Promise<S | undefined>;
@@ -614,6 +617,8 @@ const svc = defineService<S, {
   actions: {
     load: async (s, p) => {
       stashCopy(p);
+      const presentation = argOf(p, "signInPresentation");
+      if (presentation === "sheet" || presentation === "full_screen") signInPresentation = presentation;
       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
@@ -739,7 +744,10 @@ const svc = defineService<S, {
         const before = await memberAccess().catch(() => undefined);
         if (!before?.email) {
           busy = false;
-          return navigate(s, { screenId: "himi_sign_in", args: { mode: "signin", returnScreenId: "himi_agenda" } });
+          // 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" } });
         }
         const name = await memberName();
         const current = await memberAccess().catch(() => undefined);

package/templates/branded-lite/tier5-src/himi-branded-lite-cart/index.ts

@@ -1,3 +1,5 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
+import { defineService as registerState } from "@himalaya/state";
 import { getStoreProduct } from "../_shared/himi-store.js";
 import { iapPriceCopy } from "../_shared/iap-worker.js";
 import { withIapPresentation } from "../_shared/iap-presentation.js";
@@ -378,6 +380,7 @@ function couponDetails(result: unknown): { id: string; code: string } {
 
 let cartPricing: IapCommerce;
 const defineService = withIapPresentation<State>({
+  register: withOnlineWrites(registerState, ["remove", "increment", "decrement", "checkout", "beginPromo", "applyPromo", "removePromo"], { derive, messageFields: action => action.includes("Promo") ? ["promoError"] : ["checkoutHint"] }),
   onCreate: commerce => { cartPricing = commerce; },
   prefix: "cart", transientKeys: ["items", "subtotal", "promoBusy"], contentActions: ["load", "remove", "increment", "decrement"],
   items: state => state.items.flatMap(row => row.catalogReference?.catalogItemId ? [{ reference: { kind: "storesProduct", id: row.catalogReference.catalogItemId }, commerceDisplayPrice: row.commerceTotal ?? row.total }] : []),

package/templates/branded-lite/tier5-src/himi-branded-lite-feed/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: himi-branded-lite — community activity feed (design §4.5).
 //
 // The feed rides the Wix Groups social feed: a feed item lives in a group
@@ -9,7 +10,7 @@
 // worker's signed-in flags (the himi_group join-button pattern) and the
 // sign-in card routes to himi_account — never a dead tap.
 // Four-state (loading / error / rows / empty) like the sibling branded workers.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import {
   createFeedItem,
   listFeedItems,
@@ -301,6 +302,7 @@ async function loadFeed(state: State): Promise<State> {
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["post", "react"], { derive, draftFields: { draft: "message" } });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   filter: (state: State, arg?: unknown) => State;

package/templates/branded-lite/tier5-src/himi-branded-lite-group/index.ts

@@ -1,4 +1,5 @@
-import { defineService } from "@himalaya/state";
+import { withOnlineWrites } from "../_shared/online-actions.js";
+import { defineService as registerService } from "@himalaya/state";
 import { getGroup, joinGroup, leaveGroup, queryMembers as queryGroupMembers, type WixGroup } from "@himalaya/wix-groups";
 import { getMember } from "@himalaya/wix-members";
 import { signedInEmail } from "../_shared/himi-account";
@@ -159,6 +160,7 @@ const initial: State = {
   hideContent: true,
 };
 
+const defineService = withOnlineWrites(registerService, ["join","leave"]);
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   join: (state: State) => Promise<State>;

package/templates/branded-lite/tier5-src/himi-branded-lite-notifications/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // himi-branded-lite-notifications — reads the member's notifications via Members Feed Viewer (queryNotifications).
 // a failed query is an error with Retry (or Sign in when Wix refuses the
 // visitor) and an empty one is a real empty state — never sample rows presented as
@@ -5,7 +6,7 @@
 // (_shared/branded-load-state.ts).
 // mark-one-read / mark-all-read stay wired: they update state optimistically and
 // best-effort the real write (a no-op on sample rows).
-import { defineService } from "../_shared/collection-service.js";
+import { defineService as registerService } from "../_shared/collection-service.js";
 import { LOADING, loaded, loadFailed, type LoadCopy, type LoadFlags } from "../_shared/branded-load-state.js";
 import { queryNotifications, markRead, markAllRead, type MfvNotification } from "@himalaya/wix-members-feed-viewer";
 
@@ -22,7 +23,7 @@ interface Row {
   dest: string;
 }
 interface S extends LoadFlags {
-  items: Row[]; emptyText: string;
+  items: Row[]; emptyText: string; actionMessage: string;
   isMock: boolean; notMock: boolean;
   /** #2849 — hiddenWhen() hides on TRUE, so these are inverted: the empty-state banner
    *  shows only when the site really has none, and the unavailable one only when the
@@ -100,17 +101,18 @@ const COPY: LoadCopy<Row> = {
   sample: () => MOCK.map((r) => ({ ...r })),
 };
 
+const defineService = withOnlineWrites(registerService, ["markOneRead","markAll"], { messageFields: ["actionMessage"] });
 const svc = defineService<S, {
   load: (s: S) => Promise<S>;
   markOneRead: (s: S, id: string) => Promise<S>;
   markAll: (s: S) => Promise<S>;
 }>("himiBrandedNotifications", {
-  state: { ...LOADING, items: [], emptyText: "" },
+  state: { ...LOADING, items: [], emptyText: "", actionMessage: "" },
   actions: {
     load: async (s) => {
       try {
         const items = (await queryNotifications(25)).map(norm);
-        return { ...s, ...loaded("items", items, COPY) };
+        return { ...s, ...loaded("items", items, COPY), actionMessage: "" };
       } catch (err) {
         return { ...s, ...loadFailed("items", err, COPY) };
       }

package/templates/branded-lite/tier5-src/himi-branded-lite-notifsettings/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // himi-branded-lite-notifsettings — reads the site's notification topics + the member's preferences.
 // a failed query is an error with Retry (or Sign in when Wix refuses the
 // visitor) and an empty one is a real empty state — never sample rows presented as
@@ -5,7 +6,7 @@
 // (_shared/branded-load-state.ts).
 // any exist. INTERACTIVE: tapping a row toggles that topic On/Off — optimistic +
 // best-effort upsertMyNotificationPreferences (a no-op on sample rows).
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import { withEmptyFlags } from "../_shared/empty-flags.js";
 import { LOADING, loaded, loadFailed, type LoadCopy, type LoadFlags } from "../_shared/branded-load-state.js";
 import {
@@ -31,7 +32,7 @@ interface Row { id: string; name: string; subtitle: string; note: string; on: bo
   /** Inverse of `locked` (hiddenWhen hides on TRUE) and the plain On/Off a locked row shows. */
   notLocked: boolean; stateLabel: string }
 interface S extends LoadFlags {
-  topics: Row[]; emptyText: string;
+  topics: Row[]; emptyText: string; actionMessage: string;
   isMock: boolean; notMock: boolean; /** #2849 — hiddenWhen() hides on TRUE, so these are inverted: the empty-state banner
    *  shows only when the site really has none, and the unavailable one only when the
    *  query failed. A failed query must never render the sentence that claims the
@@ -91,11 +92,12 @@ const COPY: LoadCopy<Row> = {
   sample: () => MOCK.map((r) => ({ ...r })),
 };
 
+const defineService = withOnlineWrites(registerService, ["toggle"], { messageFields: ["actionMessage"] });
 const svc = defineService<S, {
   load: (s: S) => Promise<S>;
   toggle: (s: S, p?: { id?: string; value?: unknown }) => Promise<S>;
 }>("himiBrandedNotifSettings", withEmptyFlags({
-  state: { ...LOADING, topics: [], emptyText: "" },
+  state: { ...LOADING, topics: [], emptyText: "", actionMessage: "" },
   actions: {
     load: async (s) => {
       try {
@@ -105,7 +107,7 @@ const svc = defineService<S, {
         ]);
         const prefs = readPreferences(prefsRes);
         const topics = readTopics(topicsRes).map((t) => norm(t, prefs));
-        return { ...s, ...loaded("topics", topics, COPY) };
+        return { ...s, ...loaded("topics", topics, COPY), actionMessage: "" };
       } catch (err) {
         return { ...s, ...loadFailed("topics", err, COPY) };
       }

package/templates/branded-lite/tier5-src/himi-branded-lite-order/index.ts

@@ -1,7 +1,8 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 import { createIapCommerce, classifyCart } from "@himalaya/iap-checkout";
 import { getStoreProduct } from "../_shared/himi-store.js";
 import { iapPriceCopy } from "../_shared/iap-worker.js";
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import { orderMember, assertOrderMember, ownedOrderCache, orderAccessDenied, orderAccessChanged, type OrderMember } from "../_shared/member-orders.js";
 import { addToCurrentCart, getOrder, searchOrders, type WixOrder } from "@himalaya/wix-ecom";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
@@ -313,6 +314,7 @@ async function load(state: State, arg?: unknown): Promise<State | undefined> {
 const FOLLOW_TTL_SECONDS = 24 * 60 * 60;
 
 const reorderPricing = createIapCommerce();
+const defineService = withOnlineWrites(registerService, ["reorder", "follow", "unfollow"], { derive, messageFields: action => action === "reorder" ? ["reorderMessage"] : ["liveNote"] });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State | undefined>;
   retry: (state: State) => Promise<State | undefined>;

package/templates/branded-lite/tier5-src/himi-branded-lite-place-summary/index.ts

@@ -9,7 +9,7 @@
 // `load` is both the onAppear action and what an embed controller's `refresh()` runs (arg-less:
 // the stashed appear params keep the verticals and the copy pack), so a host that hears
 // `booking.created` / `booking.cancelled` re-reads the summary without a remount.
-import { defineService } from "@himalaya/state";
+import { defineService, navigate } from "@himalaya/state";
 import { listMyPlanOrders, type WixPlanOrder } from "@himalaya/wix-pricing-plans";
 import { fetchMemberBookings, type MemberBookingRow } from "../_shared/member-bookings.js";
 import { memberAccess, assertMemberAccess, memberAccessDenied, type MemberAccess } from "../_shared/member-access.js";
@@ -52,6 +52,7 @@ const PLANS_SCREEN = "himi_plans";
 const SIGN_IN_SCREEN = "himi_sign_in";
 
 let stashedVerticals: string[] | null = null;
+let signInPresentation: "sheet" | "full_screen" | undefined;
 let generation = 0;
 
 function appearVerticals(arg: unknown): string[] {
@@ -190,6 +191,8 @@ async function read(arg: unknown, again = true): Promise<PlaceSummaryState> {
  *  write back over the newer result. */
 async function load(_s: PlaceSummaryState, arg?: unknown): Promise<PlaceSummaryState | undefined> {
   stashCopy(arg);
+  const presentation = arg && typeof arg === "object" ? (arg as Record<string, unknown>).signInPresentation : undefined;
+  if (presentation === "sheet" || presentation === "full_screen") signInPresentation = presentation;
   const mine = ++generation;
   const next = await read(arg);
   return mine === generation ? next : undefined;
@@ -198,11 +201,19 @@ async function load(_s: PlaceSummaryState, arg?: unknown): Promise<PlaceSummaryS
 const svc = defineService<PlaceSummaryState, {
   load: (s: PlaceSummaryState, arg?: unknown) => Promise<PlaceSummaryState | undefined>;
   retry: (s: PlaceSummaryState) => Promise<PlaceSummaryState | undefined>;
+  openCta: (s: PlaceSummaryState) => PlaceSummaryState;
 }>("himiPlaceSummary", {
   state: BLANK,
   actions: {
     load,
     retry: (s) => load(s),
+    openCta: (s) => {
+      if (s.hideCta || !s.ctaScreenId) return s;
+      // No return path: the tile is embedded, so the form closes over its host.
+      return navigate(s, s.ctaScreenId === SIGN_IN_SCREEN && signInPresentation
+        ? { screenId: SIGN_IN_SCREEN, presentation: signInPresentation, args: { mode: "signin", modal: "1" } }
+        : { screenId: s.ctaScreenId, args: { mode: s.ctaMode } });
+    },
   },
 });
 export { svc };

package/templates/branded-lite/tier5-src/himi-branded-lite-plans/index.ts

@@ -1,4 +1,6 @@
-import { defineService } from "../_shared/collection-service.js";
+import { offlineWriteMessage, offlineWritesEnabled, withOnlineWrites } from "../_shared/online-actions.js";
+import { connectivity } from "@himalaya/state";
+import { defineService as registerService } from "../_shared/collection-service.js";
 import { createOnlineOrder, listPublicPlans, type WixPlan } from "@himalaya/wix-pricing-plans";
 import { createRedirectSession } from "@himalaya/wix-redirects";
 import { open as openUrl } from "@himalaya/open-url";
@@ -252,6 +254,8 @@ async function regularJoinMessage(row: PlanRow, reference: { kind: string; id: s
     }
     return copyTemplate("plans.joinOnSiteMessage", "Memberships are purchased on the website — visit the site to join {name}.", { name: row.name });
   }
+  // A link may fail to open. Its fallback becomes a write and needs its own preflight.
+  if (offlineWritesEnabled && !connectivity().online) return offlineWriteMessage;
   try {
     const created = await createOnlineOrder(row.id);
     const snapshotId = created.purchaseFlowId;
@@ -291,6 +295,14 @@ async function regularJoinMessage(row: PlanRow, reference: { kind: string; id: s
   return copyTemplate("plans.joinOnSiteMessage", "Memberships are purchased on the website — visit the site to join {name}.", { name: row.name });
 }
 
+const defineService = withOnlineWrites(registerService, ["join"], {
+  messageFields: ["actionMessage"],
+  requiresConnectivity: (_action, state: State, arg) => {
+    const row = state.rows.find(candidate => candidate.id === idOf(arg));
+    if (!row || commerce.purchaseFields({ kind: "pricingPlan", id: row.id }, iapPurchaseCopy("plans")).appleRoute) return true;
+    return !row.joinUrl && !(isHostedWorker() && !row.free);
+  },
+});
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State | undefined>;
   pricingPublish: (state: State) => State;

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

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: himi-branded-lite — single online-program detail (design §3.5
 // `programs` vertical, screen full-potential pass).
 //
@@ -19,7 +20,7 @@
 // reads every program as `disabled` and keeps Enrol on its own commerce. An Apple-routed program
 // offers Get access in place of Enrol and sells only through the shared checkout, never through the
 // Wix payment rail.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import {
   getProgram,
   joinProgram,
@@ -386,6 +387,7 @@ type Actions = {
   iapPoll: (state: State) => Promise<undefined>;
 };
 
+const defineService = withOnlineWrites(registerService, ["enroll","buy"], { derive, messageFields: ["actionMessage"] });
 const svc = defineService<State, Actions>("himiBrandedProgram", {
   state: INITIAL_STATE,
   notHydrated: [...PRICING_NOT_HYDRATED],

package/templates/branded-lite/tier5-src/himi-branded-lite-reservations/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // himi-branded-lite-reservations — branded-lite "My Reservations" worker. Reads
 // the member's real Wix Table Reservations (queryReservations). A failed query is an
 // error with Retry (or Sign in when Wix refuses the visitor), an empty one is a real
@@ -11,7 +12,7 @@
 // flat grid it replaced repeated "Fri, Aug 8 · 7:30 PM" on every card because
 // no row knew what day the row above it was on. `Agenda` owns the day headers
 // and the time column, so a row carries only what is actually per-reservation.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import { LOADING, loaded, loadFailed, type LoadCopy, type LoadFlags } from "../_shared/branded-load-state.js";
 import { queryReservations, cancelReservation, type WixReservation } from "@himalaya/wix-table-reservations";
 import { type CalendarEvent } from "@himalaya/time";
@@ -21,7 +22,7 @@ interface S extends LoadFlags {
   reservations: Row[];
   /** The Agenda wire shape, derived from `reservations` on every transition. */
   events: CalendarEvent[];
-  emptyText: string;
+  emptyText: string; actionMessage: string;
   isMock: boolean; notMock: boolean; /** #2849 — hiddenWhen() hides on TRUE, so these are inverted: the empty-state banner
    *  shows only when the site really has none, and the unavailable one only when the
    *  query failed. A failed query must never render the sentence that claims the
@@ -144,11 +145,12 @@ function tappedId(p: unknown): string {
   return "";
 }
 
+const defineService = withOnlineWrites(registerService, ["cancel"], { messageFields: ["actionMessage"] });
 const svc = defineService<S, {
   load: (s: S) => Promise<S>;
   cancel: (s: S, p?: unknown) => Promise<S>;
 }>("himiBrandedReservations", {
-  state: { ...LOADING, reservations: [], events: [], emptyText: "" },
+  state: { ...LOADING, reservations: [], events: [], emptyText: "", actionMessage: "" },
   actions: {
     load: async (s) => {
       try {
@@ -156,7 +158,7 @@ const svc = defineService<S, {
         // to hand it chronological order rather than newest-first.
         const r = await queryReservations({ cursorPaging: { limit: 20 }, sort: [{ fieldName: "details.startDate", order: "ASC" }] });
         const reservations = (r.reservations ?? []).map(norm);
-        return settle(s, loaded("reservations", reservations, COPY));
+        return settle({ ...s, actionMessage: "" }, loaded("reservations", reservations, COPY));
       } catch (err) {
         return settle(s, loadFailed("reservations", err, COPY));
       }

package/templates/branded-lite/tier5-src/himi-branded-lite-reserve/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: himi-branded-lite — reservation request form (design §4.4).
 //
 // The visitor rung of Wix Table Reservations, per the REST sample flow:
@@ -19,7 +20,7 @@
 // on a Tuesday the restaurant is shut. A day strip over a bookable-times run is
 // how every real reservation flow asks the question, and both presets ride
 // FilterChips, so they render on all seven surfaces with no proto change.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import {
   createHeldReservation,
   listReservationLocations,
@@ -255,6 +256,7 @@ async function load(state: State, arg?: unknown): Promise<State> {
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["submit"], { derive });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   setPartySize: (state: State, arg?: unknown) => State;

package/templates/branded-lite/tier5-src/himi-branded-lite-wallet/index.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from "../_shared/online-actions.js";
 // Tier-5 bundle: Branded Lite — My Wallet (the member's saved payment methods).
 //
 // The cards a member chose to save at checkout, read from Wix Payments on the member's
@@ -5,7 +6,7 @@
 // page, a member can make one the default for checkout or remove one — there is no
 // "add a card" here: a card is saved while paying. Only the last four digits, the
 // expiry and the cardholder name ever reach the app.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import {
   deleteSavedPaymentMethod,
   listMySavedPaymentMethods,
@@ -173,6 +174,7 @@ async function write(state: State, run: () => Promise<unknown>, done: string, fa
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["setPrimary", "remove"], { derive });
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   retry: (state: State) => Promise<State>;

package/templates/branded-lite/tier5-src/himi-events-detail/index.ts

@@ -1,6 +1,7 @@
 // Tier-5 bundle: himi-events — event detail.
 import { formatCurrency } from "../_shared/engine-intl.js";
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
+import { withOnlineWrites } from "../_shared/online-actions.js";
 import { createEvent, getPermissionStatus, requestPermission } from "@himalaya/calendar";
 import { open } from "@himalaya/open-url";
 import { share as shareSheet } from "@himalaya/share";
@@ -431,6 +432,12 @@ async function enrichRegistration(id: string, e: WixEvent): Promise<WixEvent> {
   }
 }
 
+const defineService = withOnlineWrites(registerService, ["buyApple", "openRegistration"], {
+  derive,
+  messageFields: ["actionMessage"],
+  requiresConnectivity: (action, state) => action !== "openRegistration"
+    || (state.registrationKind === "tickets" && !!state.id && !isHostedWorker()),
+});
 const svc = defineService<S, {
   load: (s: S, arg?: unknown) => Promise<S | undefined>;
   openMap: (s: S) => Promise<S>;

package/templates/branded-lite/tier5-src/himi-events-rsvp/index.ts

@@ -1,5 +1,6 @@
+import { withOnlineWrites, offlineWritesEnabled } from "../_shared/online-actions.js";
 // Tier-5 bundle: himi-events — member RSVP flow.
-import { defineService } from "@himalaya/state";
+import { defineService as registerService } from "@himalaya/state";
 import { dispatch } from "@himalaya/dispatch";
 import { createRsvp, getEvent, type WixEvent } from "@himalaya/wix-events";
 import { displayName, getMyData, type WixMyData } from "@himalaya/wix-users";
@@ -125,6 +126,7 @@ function contactName(dataLine: string): { first: string; last: string } {
   return { first: parts[0], last: parts.slice(1).join(" ") };
 }
 
+const defineService = withOnlineWrites(registerService, ["rsvp", "signIn"], { derive, secretFields: ["password"] });
 const svc = defineService<S, {
   load: (s: S, arg?: unknown) => Promise<S>;
   setEmail: (s: S, arg?: unknown) => S;
@@ -202,16 +204,17 @@ const svc = defineService<S, {
       // Optimistic local write — the RSVP row lands in the cache before the Wix POST.
       const rsvpRow = (id: string): DbEntity => ({ id, eventId: s.id, firstName: name.first, lastName: name.last, email: guestEmail, status: "YES", title: s.title });
       const localId = s.id;
-      await cachePut(rsvpRow(localId));
+      if (!offlineWritesEnabled) await cachePut(rsvpRow(localId));
       try {
         const res = await createRsvp(s.id, name.first, name.last, guestEmail, "YES");
         // Reconcile the optimistic local id with the server-assigned rsvp id.
         const serverId = res.rsvp?.id;
-        if (serverId && serverId !== localId) { await cacheDrop(localId); await cachePut(rsvpRow(serverId)); }
+        if (offlineWritesEnabled) await cachePut(rsvpRow(serverId || localId));
+        else if (serverId && serverId !== localId) { await cacheDrop(localId); await cachePut(rsvpRow(serverId)); }
         rememberRsvp(s.id);
         return derive({ ...s, successMessage: copyParam("rsvp.successMessage", "You are going. Added to My Events."), message: "" });
       } catch (e) {
-        if (isBridgeUnavailable(e)) {
+        if (!offlineWritesEnabled && isBridgeUnavailable(e)) {
           // Offline / no bridge: the optimistic cache row already shows; queue the
           // write to replay (WriteQueue, idempotent) when connectivity returns.
           await queueWrite("tier5.himiEventsRsvp.rsvp", { id: s.id, firstName: name.first, lastName: name.last, email: guestEmail, status: "YES" });

package/templates/branded-lite/tier5-src/himi-store-account/index.ts

@@ -26,6 +26,10 @@ interface AuthRouteInput {
   returnScreenId?: string;
   returnId?: string;
   returnChannelId?: string;
+  /** Standalone sign-in only: "1" when it was opened as a modal (sheet / cover). */
+  modal?: string;
+  /** Modal only: the tab whose stack the return screen opens on once the modal closes. */
+  returnTab?: string;
 }
 
 // The screen's boot input survives refresh; consuming it must survive too.
@@ -61,6 +65,12 @@ function authIntentFromArg(arg: unknown, prev: Pick<S, "authIntent" | "authConte
   };
 }
 
+/** How the standalone form leaves. A modal is closed: on web `back` pops the tab's stack,
+ *  not the modal. A pushed form goes back. */
+function leaveNav(): "dismiss" | "back" {
+  return routeInput().modal === "1" ? "dismiss" : "back";
+}
+
 /** Where a successful sign-in returns to, or null. Never Account itself — that would
  *  only push a second copy of the screen the member is already on. */
 function resumeTarget(s: Pick<S, "returnScreenId" | "returnId" | "returnChannelId">): { screenId: string; args?: Record<string, string> } | null {
@@ -78,11 +88,26 @@ function resumeTarget(s: Pick<S, "returnScreenId" | "returnId" | "returnChannelI
  *  On the standalone sign-in screen the target is pushed, not a `replace`: on iOS and
  *  Android `replace` resets the stack to its root, which would drop the screens the
  *  visitor came through. Back from the target shows the form again, and the form sends a
- *  member back on appear (settle). With no target the form goes back. */
+ *  member back on appear (settle). With no target the form goes back.
+ *
+ *  A modal form closes. A target pushed from here would open inside the modal (iOS, Android)
+ *  or under it (web), so a modal that names a `returnTab` hands the target to that tab: the
+ *  host closes the modal, then pushes it on that tab's stack (Account's member rows). A host
+ *  showing no such tab (a drawer, a narrow Mac window) drops that request whole, modal and
+ *  all, so the modal is also dismissed directly: it always closes, and the row opens where
+ *  the tab exists. With no `returnTab` it only closes, and the screen under it loads again —
+ *  the screen that opened the modal is the return target. */
 function resumeAfterAuth(next: S): S {
   const target = resumeTarget(next);
   if (!next.isMember) return next;
-  if (!target) return next.standalone ? navigate(next, { presentation: "back" }) : next;
+  const tab = routeInput().modal === "1" ? routeInput().returnTab ?? "" : "";
+  if (target && tab && next.standalone) {
+    routeInputConsumed = true;
+    void dispatch("himi.open", { presentation: "dismiss" });
+    const cleared = derive({ ...next, authIntent: "", authContextName: "", returnScreenId: "", returnId: "", returnChannelId: "" });
+    return navigate(cleared, target.args ? { tab, screenId: target.screenId, args: target.args } : { tab, screenId: target.screenId });
+  }
+  if (!target || routeInput().modal === "1") return next.standalone ? navigate(next, { presentation: leaveNav() }) : next;
   routeInputConsumed = true;
   const cleared = derive({ ...next, authIntent: "", authContextName: "", returnScreenId: "", returnId: "", returnChannelId: "" });
   return navigate(cleared, target);
@@ -96,11 +121,31 @@ function forwardToSignIn(next: S): S {
   if (!next.authIntent && !next.returnScreenId) return next;
   routeInputConsumed = true;
   const args: Record<string, string> = { mode: "signin" };
-  for (const key of ["authIntent", "authContextName", "returnScreenId", "returnId", "returnChannelId"] as const) {
-    if (next[key]) args[key === "authIntent" ? "intent" : key === "authContextName" ? "contextName" : key] = next[key];
+  for (const key of ["authIntent", "authContextName"] as const) {
+    if (next[key]) args[key === "authIntent" ? "intent" : "contextName"] = next[key];
+  }
+  return openSignIn(derive({ ...next, authIntent: "", authContextName: "", returnScreenId: "", returnId: "", returnChannelId: "" }),
+    args, resumeTarget(next));
+}
+
+/** Account sends a guest to the standalone sign-in screen, with `after`, the member screen to
+ *  open once signed in. With a `signInPresentation` appear param it opens as that modal, and
+ *  `after` goes on Account's own tab (`signInReturnTab`) when the modal closes; pushed, the form
+ *  pushes `after` itself (resumeAfterAuth). */
+function openSignIn(next: S, args: Record<string, string>, after: { screenId: string; args?: Record<string, string> } | null): S {
+  const screenId = next.signInScreen || "himi_sign_in";
+  const presentation = signInPresentationRequested;
+  const back: Record<string, string> = {};
+  if (after) {
+    back.returnScreenId = after.screenId;
+    if (after.args?.id) back.returnId = after.args.id;
+    if (after.args?.channelId) back.returnChannelId = after.args.channelId;
   }
-  return navigate(derive({ ...next, authIntent: "", authContextName: "", returnScreenId: "", returnId: "", returnChannelId: "" }),
-    { screenId: next.signInScreen, args });
+  if (!presentation) return navigate(next, { screenId, args: { ...args, ...back } });
+  const modalArgs: Record<string, string> = { ...args, modal: "1" };
+  // With no tab to open it on, a modal has no way to the member screen: it only closes.
+  if (after && signInReturnTabRequested) Object.assign(modalArgs, back, { returnTab: signInReturnTabRequested });
+  return navigate(next, { screenId, presentation, args: modalArgs });
 }
 
 /** After a load: the standalone sign-in screen sends a member back (a stale link, or a
@@ -128,8 +173,11 @@ function settle(next: S, arg: unknown, latest = true): S {
     // The appear refresh returns `_nav`, which every host applies — binaries from before
     // worker nav dispatch included. Only an arg-less load, whose result iOS
     // discards, dispatches.
-    if (strField(arg, "standalone") === "1") return navigate(cleared, { presentation: "back" });
-    void dispatch("himi.open", { presentation: "back" });
+    if (strField(arg, "standalone") === "1") return navigate(cleared, { presentation: leaveNav() });
+    // Not from a modal: nothing pushed over it comes back to it, and on iOS the closing modal's
+    // own screen reloads here once, after it has asked to close — a late dismiss would close
+    // whatever modal is open by then.
+    if (routeInput().modal !== "1") void dispatch("himi.open", { presentation: leaveNav() });
     return cleared;
   }
   // Account forwards only on an appear refresh: the boot `load()` has no params and its
@@ -180,6 +228,10 @@ let appliedSeq = 0;
 // The appear params belong to the worker session too, like the two flags above: a probe
 // dropped because the visitor typed must not take them with it.
 let signInScreenRequested = "";
+/** Account only: how it opens the standalone sign-in screen ("" = push). */
+let signInPresentationRequested: "" | "sheet" | "full_screen" = "";
+/** Account only: its tab, where a member screen opens after a modal sign-in. */
+let signInReturnTabRequested = "";
 let standaloneRequested = false;
 let pollIdentityRequested = false;
 // Bumped by every mode switch, so a dropped probe never puts back a mode the visitor left.
@@ -210,6 +262,9 @@ function appearConfig(s: S, arg: unknown): AppearConfig {
     passwordDraft = "";
   }
   signInScreenRequested ||= strField(arg, "signInScreen") || s.signInScreen;
+  const presentation = strField(arg, "signInPresentation");
+  if (presentation === "sheet" || presentation === "full_screen") signInPresentationRequested = presentation;
+  signInReturnTabRequested ||= strField(arg, "signInReturnTab");
   // Only the sign-in screen's route carries `mode`, so it marks the form from the boot load on.
   standaloneRequested ||= s.standalone || appearing || (!routeInputConsumed && !!routeInput().mode);
   pollIdentityRequested ||= s.pollIdentity || strField(arg, "pollIdentity") === "1";
@@ -676,6 +731,7 @@ const svc = defineService<S, {
   signOut: (s: S) => Promise<S>;
   sync: (s: S) => Promise<S | undefined>;
   openMember: (s: S, arg?: unknown) => Promise<S>;
+  leave: (s: S) => S;
   restorePublish: (s: S) => S;
   iapRestore: (s: S) => Promise<undefined>;
 }>("himiStoreAccount", {
@@ -756,7 +812,8 @@ const svc = defineService<S, {
       return "next" in r ? r.next : undefined;
     },
     // A row to a member-only screen shows to a guest too. A member opens it; a guest signs
-    // in first and the sign-in screen replaces itself with it, so Back returns here.
+    // in first, and the sign-in screen then opens the row's screen — as a modal, by closing
+    // and pushing it on this tab (openSignIn) — so Back returns here either way.
     openMember: async (s, arg): Promise<S> => {
       const screenId = strField(arg, "screenId");
       if (!screenId) return s;
@@ -764,8 +821,10 @@ const svc = defineService<S, {
       // From the state as it is now: a probe may have landed during the identity read.
       const now = svc.getState();
       if (member) return navigate(now, { screenId });
-      return navigate(now, { screenId: now.signInScreen || "himi_sign_in", args: { mode: "signin", returnScreenId: screenId } });
+      return openSignIn(now, { mode: "signin" }, { screenId });
     },
+    // The standalone form's Continue: leaves the form the way it was opened.
+    leave: (s) => navigate(s, { presentation: leaveNav() }),
     // Typing means any focus request was delivered: clear the tokens (safe while mounted, since
     // bumpToken never repeats), so a visit rarely ends — and a pooled form rarely reopens —
     // holding one.