@wix/himalaya-cli 0.1525.0 → 0.1527.0

package/templates/yoga-studio/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/yoga-studio/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/yoga-studio/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/yoga-studio/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/yoga-studio/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/yoga-studio/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/yoga-studio/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/yoga-studio/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.

package/templates/yoga-studio-owner/tier5-src/_shared/collection-service.ts

@@ -1,3 +1,4 @@
+import { withOnlineWrites } from './online-actions.js';
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
 import { COLLECTIONS, COLLECTION_CHROME_MIN_ITEMS, initialCollection, normalizeCollection, projectCollection, collectionId, collectionActionsLabel, type CollectionRow } from './collection-contract.js';
 import { localPreferences, type PreferenceRuntime } from './local-preferences.js';
@@ -331,6 +332,8 @@ export function decorateCollection(name: string, def: { state: State; actions?:
  * reducer and reads the private controller snapshot, never an SDUI payload. */
 export function defineBackendCollection<S extends object, Row extends object>(name: string, options: {
   register?: typeof register;
+  /** Explicit mutation preflight; unrelated collection services keep their current reducers. */
+  onlineWrites?: boolean;
   /** Revalidate already opened pages on navigation return; explicit refresh resets. */
   restorePagesOnLoad?: boolean;
   /** The load action's argument (onAppear params beyond `copy`), before the query runs — for a
@@ -350,7 +353,8 @@ export function defineBackendCollection<S extends object, Row extends object>(na
     controller: controller as unknown as BackendCollection['controller'],
     apply: (state, page) => options.apply(state as S, page as unknown as CollectionQueryState<Row>) as State,
   });
-  const handle = (options.register ?? register)(name, definition);
+  const registerService = options.onlineWrites ? withOnlineWrites(options.register ?? register, ['confirmCancel', 'confirmOperation', 'retryOperation', 'commitWrite'], { messageFields: ['actionMessage'] }) : (options.register ?? register);
+  const handle = registerService(name, definition);
   // Registration restored the state a cold boot saved: the page it showed is this run's, before the first load. Only
   // when the service's own rows came back with it: a bundle that keeps them out of the restore (its `notHydrated`)
   // starts its first load as before, never from rows it chose not to restore. Rows that came back empty are the

package/templates/yoga-studio-owner/tier5-src/_shared/online-actions.ts

@@ -0,0 +1,76 @@
+import { connectivity, defineService as register, type ServiceDefinition } from '@himalaya/state';
+
+// Template generation enables this behavior only in the selected two starter families.
+export const offlineWritesEnabled = false;
+
+export const offlineWriteMessage = 'You’re offline. Connect to save this change, then submit it again.';
+
+/** The guard runs before the reducer: entered values survive and no optimistic
+ * changes, success state, or queued writes can occur. It never submits on reconnect. */
+export function offlineWriteState<S extends object>(state: S): S {
+  const next: Record<string, unknown> = { ...state, error: offlineWriteMessage, message: offlineWriteMessage };
+  for (const key of ['saving', 'isSaving', 'submitting', 'isSubmitting', 'adding', 'added', 'bookingInFlight']) {
+    if (key in next) next[key] = false;
+  }
+  for (const key of ['savedMessage', 'successMessage']) {
+    if (key in next) next[key] = '';
+  }
+  // A saved/favourited item is business state, not a submission-success flag.
+  return next as S;
+}
+
+interface OfflineWriteOptions<S> {
+  derive?: (state: S) => S;
+  /** Exempt only non-mutating branches of a registered action. */
+  requiresConnectivity?: (action: string, state: S, argument?: unknown) => boolean;
+  messageFields?: readonly string[] | ((action: string) => readonly string[]);
+  draftFields?: readonly string[] | Readonly<Record<string, string>>;
+  secretFields?: readonly string[];
+}
+
+export function withOnlineWrites<S extends object>(registerService: typeof register, names: readonly string[], options: OfflineWriteOptions<S> = {}): typeof register {
+  if (!offlineWritesEnabled) return registerService;
+  return ((name: string, definition: ServiceDefinition<Record<string, unknown>>) => {
+    let currentState: (() => Record<string, unknown>) | undefined;
+    const handle = registerService(name, {
+      ...definition,
+      notHydrated: [...new Set([...(definition.notHydrated ?? []), ...(options.secretFields ?? [])])],
+      actions: Object.fromEntries(Object.entries(definition.actions ?? {}).map(([action, reduce]) => [action,
+        (state: Record<string, unknown>, ...args: never[]) => {
+          if (!names.includes(action)) return reduce(state, ...args);
+          if (options.requiresConnectivity?.(action, state as S, args[0]) === false) return reduce(state, ...args);
+          const fields = typeof options.messageFields === 'function' ? options.messageFields(action) : options.messageFields ?? ['message'];
+          if (connectivity().online) {
+            let cleared = false;
+            for (const field of ['error', 'message', ...fields]) {
+              if (state[field] === offlineWriteMessage) { state[field] = ''; cleared = true; }
+            }
+            // Keep the runtime's state object: reducers may mutate it and return undefined.
+            const result = reduce(state, ...args);
+            if (!cleared) return result;
+            // Publish cleared feedback even for a void reducer. An async completion must
+            // keep any newer state published by another action while it was awaiting.
+            const finish = (next: Record<string, unknown> | undefined) => next === undefined ? currentState?.() ?? state : next;
+            return result && typeof (result as Promise<unknown>).then === 'function'
+              ? Promise.resolve(result).then(finish)
+              : finish(result as Record<string, unknown> | undefined);
+          }
+          const draft = { ...state };
+          const argument = args[0] as Record<string, unknown> | undefined;
+          const draftFields = options.draftFields ?? [];
+          const entries = Array.isArray(draftFields) ? draftFields.map(key => [key, key]) : Object.entries(draftFields);
+          for (const [key, source] of entries) {
+            if (argument && key in state && typeof argument[source] === typeof state[key]) draft[key] = argument[source];
+          }
+          for (const key of options.secretFields ?? []) draft[key] = '';
+          const feedback = Object.fromEntries(fields.map(key => [key, offlineWriteMessage]));
+          let next = { ...offlineWriteState(draft), ...feedback };
+          if (options.derive) next = options.derive(next as S) as Record<string, unknown>;
+          return { ...next, ...feedback };
+        },
+      ])),
+    });
+    if (typeof handle.getState === 'function') currentState = () => handle.getState();
+    return handle;
+  }) as typeof register;
+}