@wix/himalaya-cli 0.1378.0 → 0.1380.0

package/templates/branded-lite/himalaya.content.json

@@ -4,6 +4,12 @@
     "himi_account": {
       "displayName": "Profile"
     },
+    "himi_address": {
+      "displayName": "Address"
+    },
+    "himi_addresses": {
+      "displayName": "Addresses"
+    },
     "himi_app_info": {
       "displayName": "App Info"
     },
@@ -247,6 +253,9 @@
     "himi_view_profile": {
       "displayName": "View Profile"
     },
+    "himi_wallet": {
+      "displayName": "Wallet"
+    },
     "himi_whats_new": {
       "displayName": "Whats New"
     }

package/templates/branded-lite/tier5-src/_shared/branded-lite-hosted.ts

@@ -65,6 +65,8 @@ export const VERTICAL_ROOT_SCREENS: Readonly<Record<string, readonly string[]>>
  *  (`brandedLiteScreenOwners`, checked by the app's hosted-mode tests), so a screen added
  *  to a vertical without being listed here fails the build. */
 export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLiteVertical[]>> = {
+  himi_address: ["restaurants", "store"],
+  himi_addresses: ["restaurants", "store"],
   himi_badge: ["badges"],
   himi_badges: ["badges"],
   himi_blog: ["blog"],
@@ -127,6 +129,7 @@ export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLi
   himi_video: ["videos"],
   himi_video_channel: ["videos"],
   himi_videos: ["videos"],
+  himi_wallet: ["bookings", "plans", "restaurants", "store"],
 };
 
 /** The templated (`<prefix>[_/]<id>`) detail routes each vertical owns, pinned the same way. */

package/templates/branded-lite/tier5-src/_shared/member-access.ts

@@ -36,3 +36,17 @@ export async function assertMemberAccess(member: MemberAccess): Promise<void> {
 export function memberAccessDenied(error: unknown): boolean {
   return (error as { name?: string } | null)?.name === "MemberAccessChanged" || /(?:HTTP\s*(?:401|403)|READ_ORDER_FORBIDDEN|permission denied|forbidden)/i.test(String(error));
 }
+
+/** Did this write fail because the member changed (signed out, or another account)? Then
+ *  the screen reloads for whoever is signed in now. A 401/403 for the SAME member is only a
+ *  failed write: the caller keeps what the member typed and says so. */
+export async function memberChanged(member: MemberAccess | undefined, error: unknown): Promise<boolean> {
+  if ((error as { name?: string } | null)?.name === "MemberAccessChanged") return true;
+  if (!member || !memberAccessDenied(error)) return false;
+  try {
+    await assertMemberAccess(member);
+    return false;
+  } catch {
+    return true;
+  }
+}

package/templates/branded-lite/tier5-src/_shared/member-account-routes.ts

@@ -0,0 +1,43 @@
+// Can this host reach the member account routes My Addresses and My Wallet need?
+//
+// Both are served OFF www.wixapis.com (the address book on ecom.wix.com, saved cards on
+// the member's own site), so only a native runtime whose WixApiCapability pins them can
+// call them: HimalayaCore 1.4.0 and later. The web bridges refuse absolute URLs, and a
+// hosted app (Spaces) signs its calls with a capability pinned to www.wixapis.com. Saved
+// cards also need the shell to have bound its own site (app_info `memberSiteBound`): a
+// multi-app host such as Himi Player binds none, so its wallet route has no host. The
+// Account screen hides a link whose route is unreachable, and the screen says so instead
+// of failing a load.
+import { get as getAppInfo } from "@himalaya/app-info";
+import { isHostedWorker } from "./hosted-checkout.js";
+
+/** The HimalayaCore version whose WixApiCapability pins these routes. Checked here, at run
+ *  time: the screens declare no `minBinaryVersion`, because a release takes its highest
+ *  screen floor as its own and would then refuse every older binary. */
+export const MEMBER_ACCOUNT_ROUTES_MIN_BINARY = "1.4.0";
+
+function atLeast(version: string, floor: string): boolean {
+  const parts = (v: string) => v.split("-")[0].split(".").map((p) => Number.parseInt(p, 10) || 0);
+  const a = parts(version), b = parts(floor);
+  for (let i = 0; i < Math.max(a.length, b.length); i++) {
+    const x = a[i] ?? 0, y = b[i] ?? 0;
+    if (x !== y) return x > y;
+  }
+  return true;
+}
+
+export interface MemberAccountRoutes {
+  /** The address book on ecom.wix.com (My Addresses). */
+  addresses: boolean;
+  /** Saved cards on the member's own site (My Wallet). */
+  wallet: boolean;
+}
+
+export async function memberAccountRoutes(): Promise<MemberAccountRoutes> {
+  if (isHostedWorker()) return { addresses: false, wallet: false };
+  const info = await getAppInfo().catch(() => undefined);
+  if (!info) return { addresses: false, wallet: false };
+  const native = info.platform === "ios" || info.platform === "android" || info.platform === "macos";
+  const addresses = native && atLeast(info.binaryVersion ?? "", MEMBER_ACCOUNT_ROUTES_MIN_BINARY);
+  return { addresses, wallet: addresses && info.memberSiteBound === true };
+}

package/templates/branded-lite/tier5-src/_shared/member-address.ts

@@ -0,0 +1,129 @@
+// A saved member address (@himalaya/wix-ecom WixMemberAddress) as display lines, and the
+// editor's field values → the address the service accepts. Shared by the My Addresses
+// list (himi-branded-lite-addresses) and its editor (himi-branded-lite-address).
+//
+// Pure + Hermes-safe: no host globals, no Node APIs.
+import type { WixMemberAddress } from "@himalaya/wix-ecom";
+
+/** ISO-3166-2 `US-NY` → `NY` for display; anything else unchanged. */
+function shortSubdivision(subdivision: string, country: string): string {
+  return country && subdivision.toUpperCase().startsWith(`${country.toUpperCase()}-`)
+    ? subdivision.slice(country.length + 1)
+    : subdivision;
+}
+
+function join(parts: Array<string | undefined>, separator: string): string {
+  return parts.map((part) => (part ?? "").trim()).filter(Boolean).join(separator);
+}
+
+/** The recipient line and the postal lines, one per line, as the site's page shows them. */
+export function memberAddressLines(address: WixMemberAddress): { name: string; lines: string } {
+  const country = address.country?.trim() ?? "";
+  const street = address.addressLine1?.trim()
+    || join([address.street?.number, address.street?.name, address.street?.apt], " ");
+  const name = join([address.fullName?.firstName, address.fullName?.lastName], " ");
+  const lines = join([
+    address.company,
+    street,
+    address.addressLine2,
+    join([address.city, shortSubdivision(address.subdivision?.trim() ?? "", country), address.zipCode], ", "),
+    country.toUpperCase(),
+  ], "\n");
+  return { name, lines };
+}
+
+/** The editor's text fields, as typed. */
+export interface MemberAddressText {
+  firstName: string;
+  lastName: string;
+  company: string;
+  addressLine1: string;
+  addressLine2: string;
+  city: string;
+  subdivision: string;
+  zipCode: string;
+  country: string;
+  phoneNumber: string;
+}
+
+/** The text fields, plus where the saved address keeps its street line. Checkout can save
+ *  it as a structured `street` instead of `addressLine1`; the service will not clear a
+ *  street once set, so a save writes the line back to every form the address already has. */
+export interface MemberAddressFields extends MemberAddressText {
+  savedStreet: boolean;
+  savedAddressLine1: boolean;
+}
+
+export const EMPTY_ADDRESS_FIELDS: MemberAddressFields = {
+  firstName: "", lastName: "", company: "", addressLine1: "", addressLine2: "",
+  city: "", subdivision: "", zipCode: "", country: "", phoneNumber: "",
+  savedStreet: false, savedAddressLine1: false,
+};
+
+/** A saved address → the editor's fields. A street-only address (no addressLine1)
+ *  is shown as one line, so saving it keeps what the member saw. */
+export function addressFields(address: WixMemberAddress): MemberAddressFields {
+  const country = address.country?.trim().toUpperCase() ?? "";
+  const street = join([address.street?.number, address.street?.name, address.street?.apt], " ");
+  return {
+    firstName: address.fullName?.firstName ?? "",
+    lastName: address.fullName?.lastName ?? "",
+    company: address.company ?? "",
+    addressLine1: address.addressLine1?.trim() || street,
+    addressLine2: address.addressLine2 ?? "",
+    city: address.city ?? "",
+    subdivision: shortSubdivision(address.subdivision?.trim() ?? "", country),
+    zipCode: address.zipCode ?? "",
+    country,
+    phoneNumber: address.phoneNumber ?? "",
+    savedStreet: !!street,
+    savedAddressLine1: !!address.addressLine1?.trim(),
+  };
+}
+
+/** The required fields the member left empty, in form order. */
+export function missingAddressFields(fields: MemberAddressText): Array<keyof MemberAddressText> {
+  const required: Array<keyof MemberAddressText> = ["firstName", "lastName", "addressLine1", "city", "country"];
+  return required.filter((key) => !fields[key].trim());
+}
+
+/** A 2-letter ISO-3166 country code, upper-cased; "" when the input is not one. */
+export function normalizeCountry(value: string): string {
+  const code = value.trim().toUpperCase();
+  return /^[A-Z]{2}$/.test(code) ? code : "";
+}
+
+/** A region CODE becomes ISO-3166-2 (`ny` + `US` → `US-NY`, `us-ca` → `US-CA`), the form
+ *  checkout reads; a region NAME stays as typed. The service validates neither: it stores
+ *  whatever it is sent (verified live), so this is the only place the shape is decided.
+ *  Only a 1-2 character entry is taken as a bare code: three letters are as often a name
+ *  ("Goa", "Mie", "Ain") as a code, so a 3-character code is kept only when typed in full
+ *  (`AU-NSW`). */
+function normalizeSubdivision(value: string, country: string): string {
+  const typed = value.trim();
+  const code = typed.toUpperCase();
+  if (country && /^[A-Z0-9]{1,2}$/.test(code)) return `${country}-${code}`;
+  if (/^[A-Z]{2}-[A-Z0-9]{1,3}$/.test(code)) return code;
+  return typed;
+}
+
+/** The fields → the address body. Every editable field is sent (an empty one clears
+ *  it on update). The street line goes to each form the saved address has — the whole
+ *  line in `street.name` for a structured street (verified live: the service keeps an
+ *  empty number and apt) — and to `addressLine1` for a new address. */
+export function addressFromFields(fields: MemberAddressFields): WixMemberAddress {
+  const country = normalizeCountry(fields.country);
+  const line = fields.addressLine1.trim();
+  return {
+    fullName: { firstName: fields.firstName.trim(), lastName: fields.lastName.trim() },
+    company: fields.company.trim(),
+    ...(fields.savedStreet ? { street: { name: line, number: "", apt: "" } } : {}),
+    ...(fields.savedAddressLine1 || !fields.savedStreet ? { addressLine1: line } : {}),
+    addressLine2: fields.addressLine2.trim(),
+    city: fields.city.trim(),
+    subdivision: normalizeSubdivision(fields.subdivision, country),
+    zipCode: fields.zipCode.trim(),
+    country,
+    phoneNumber: fields.phoneNumber.trim(),
+  };
+}

package/templates/branded-lite/tier5-src/_shared/saved-card.ts

@@ -0,0 +1,20 @@
+// A saved card's network from its BIN (the first 4-6 digits Wix returns with a saved
+// payment method), for My Wallet's row titles. Wix returns the network only as a brand
+// GUID, so this is the readable name. Brand names are not copy.
+//
+// Pure + Hermes-safe: no host globals, no Node APIs.
+
+/** The card network from its BIN, for the row title. Brand names are not copy. */
+export function cardBrand(bin: string): string {
+  const d = bin.replace(/\D/g, "");
+  const n = (len: number) => Number(d.slice(0, len));
+  if (!d) return "";
+  if (d.startsWith("4")) return "Visa";
+  if ((n(2) >= 51 && n(2) <= 55) || (n(4) >= 2221 && n(4) <= 2720)) return "Mastercard";
+  if (d.startsWith("34") || d.startsWith("37")) return "American Express";
+  if (d.startsWith("6011") || d.startsWith("65") || (n(3) >= 644 && n(3) <= 649)) return "Discover";
+  if (d.startsWith("35")) return "JCB";
+  if (d.startsWith("36") || d.startsWith("38") || (n(3) >= 300 && n(3) <= 305)) return "Diners Club";
+  if (d.startsWith("62")) return "UnionPay";
+  return "";
+}

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

@@ -0,0 +1,223 @@
+// 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 {
+  createMemberAddress,
+  deleteMemberAddress,
+  getMemberAddress,
+  updateMemberAddress,
+} from "@himalaya/wix-ecom";
+import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { strOf } from "../_shared/himi-account.js";
+import { assertMemberAccess, memberAccess, memberAccessDenied, memberChanged, type MemberAccess } from "../_shared/member-access.js";
+import {
+  addressFields,
+  addressFromFields,
+  EMPTY_ADDRESS_FIELDS,
+  missingAddressFields,
+  normalizeCountry,
+  type MemberAddressFields,
+  type MemberAddressText,
+} from "../_shared/member-address.js";
+import { memberAccountRoutes } from "../_shared/member-account-routes.js";
+
+interface State extends MemberAddressFields {
+  status: "loading" | "ready" | "error" | "notFound";
+  id: string;
+  title: string;
+  needsSignIn: boolean;
+  /** This host cannot reach the address book (web, a hosted app): say so, load nothing. */
+  unavailable: boolean;
+  noUnavailable: boolean;
+  makeDefault: boolean;
+  /** Already the default: no toggle, it cannot be un-set from here. */
+  isDefault: boolean;
+  message: string;
+  confirmingRemove: boolean;
+  isLoading: boolean;
+  notLoading: boolean;
+  notErrored: boolean;
+  noSignIn: boolean;
+  hideForm: boolean;
+  hideDefaultToggle: boolean;
+  hideRemove: boolean;
+  hideRemoveConfirm: boolean;
+  hideNotFound: boolean;
+}
+
+const FIELD_LABELS: Record<keyof MemberAddressText, [string, string]> = {
+  firstName: ["address.firstNameLabel", "First name"],
+  lastName: ["address.lastNameLabel", "Last name"],
+  company: ["address.companyLabel", "Company"],
+  addressLine1: ["address.line1Label", "Address"],
+  addressLine2: ["address.line2Label", "Apartment, suite, etc."],
+  city: ["address.cityLabel", "City"],
+  subdivision: ["address.subdivisionLabel", "State / region"],
+  zipCode: ["address.zipLabel", "ZIP / postal code"],
+  country: ["address.countryLabel", "Country code"],
+  phoneNumber: ["address.phoneLabel", "Phone"],
+};
+
+let member: MemberAccess | undefined;
+let busy = false;
+
+function inputId(): string {
+  const input = (globalThis as { himalaya?: { input?: { id?: unknown } } }).himalaya?.input;
+  return typeof input?.id === "string" ? input.id.trim() : "";
+}
+
+function derive(state: State): State {
+  const ready = state.status === "ready" && !state.unavailable;
+  return {
+    ...state,
+    noUnavailable: !state.unavailable,
+    title: state.id ? copyParam("address.editTitle", "Edit address") : copyParam("address.addTitle", "Add address"),
+    isLoading: state.status === "loading",
+    notLoading: state.status !== "loading",
+    notErrored: state.status !== "error",
+    noSignIn: !ready || !state.needsSignIn,
+    hideForm: !ready || state.needsSignIn,
+    hideDefaultToggle: !ready || state.needsSignIn || state.isDefault,
+    hideRemove: !ready || state.needsSignIn || !state.id || state.confirmingRemove,
+    hideRemoveConfirm: !ready || !state.confirmingRemove,
+    hideNotFound: state.status !== "notFound",
+  };
+}
+
+const INITIAL: State = derive({
+  ...EMPTY_ADDRESS_FIELDS,
+  status: "loading", id: "", title: "", needsSignIn: false, unavailable: false, noUnavailable: true, makeDefault: false, isDefault: false,
+  message: "", confirmingRemove: false, isLoading: true, notLoading: false, notErrored: true,
+  noSignIn: true, hideForm: true, hideDefaultToggle: true, hideRemove: true, hideRemoveConfirm: true, hideNotFound: true,
+});
+
+function isNotFound(error: unknown): boolean {
+  return /cant_find_address_by_id|HTTP 404/.test(String((error as { message?: unknown } | null)?.message ?? error));
+}
+
+async function load(_state: State, arg?: unknown): Promise<State> {
+  stashCopy(arg);
+  const id = inputId();
+  const base: State = { ...INITIAL, id };
+  if (!(await memberAccountRoutes()).addresses) return derive({ ...base, status: "ready", unavailable: true });
+  try {
+    member = await memberAccess();
+    if (!member.email) return derive({ ...base, status: "ready", needsSignIn: true });
+    if (!id) return derive({ ...base, status: "ready" });
+    const response = await getMemberAddress(id);
+    await assertMemberAccess(member);
+    if (!response.address) return derive({ ...base, status: "notFound" });
+    return derive({ ...base, ...addressFields(response.address), status: "ready", isDefault: response.isDefaultAddress === true });
+  } catch (error) {
+    if (isNotFound(error)) return derive({ ...base, status: "notFound" });
+    return derive({
+      ...base,
+      status: "error",
+      message: memberAccessDenied(error)
+        ? copyParam("addresses.accessErrorText", "Your addresses are unavailable for this account. Try signing in again.")
+        : copyParam("address.loadErrorText", "This address could not be loaded."),
+    });
+  }
+}
+
+function setter(field: keyof MemberAddressFields) {
+  return (state: State, arg?: unknown): State => derive({ ...state, [field]: strOf(arg), message: "" });
+}
+
+function validation(state: State): string {
+  const missing = missingAddressFields(state);
+  if (missing.length) {
+    const names = missing.map((key) => copyParam(FIELD_LABELS[key][0], FIELD_LABELS[key][1])).join(", ");
+    return `${copyParam("address.missingPrefix", "Fill in:")} ${names}`;
+  }
+  if (!normalizeCountry(state.country)) {
+    return copyParam("address.countryInvalid", "Enter the country as a 2-letter code, like US or GB.");
+  }
+  return "";
+}
+
+async function save(state: State): Promise<State> {
+  if (busy || state.status !== "ready" || state.needsSignIn || !member?.email) return state;
+  const invalid = validation(state);
+  if (invalid) return derive({ ...state, message: invalid });
+  busy = true;
+  try {
+    await assertMemberAccess(member);
+    const address = addressFromFields(state);
+    const setAsDefault = state.makeDefault && !state.isDefault;
+    if (state.id) await updateMemberAddress(state.id, address, { setAsDefault });
+    else await createMemberAddress(address, { setAsDefault });
+    return navigate(derive({ ...state, message: "" }), { presentation: "back" });
+  } catch (error) {
+    if (await memberChanged(member, error)) return load(state);
+    if (state.id && isNotFound(error)) return derive({ ...state, status: "notFound" });
+    return derive({ ...state, message: copyParam("address.saveFailed", "The address could not be saved. Try again.") });
+  } finally {
+    busy = false;
+  }
+}
+
+async function remove(state: State): Promise<State> {
+  if (busy || !state.id || !state.confirmingRemove || !member?.email) return state;
+  busy = true;
+  try {
+    await assertMemberAccess(member);
+    await deleteMemberAddress(state.id);
+    return navigate(derive({ ...state, confirmingRemove: false }), { presentation: "back" });
+  } catch (error) {
+    if (await memberChanged(member, error)) return load(state);
+    if (isNotFound(error)) return navigate(derive(state), { presentation: "back" });
+    return derive({ ...state, message: copyParam("addresses.removeFailed", "The address could not be removed. Try again.") });
+  } finally {
+    busy = false;
+  }
+}
+
+const svc = defineService<State, {
+  load: (state: State, arg?: unknown) => Promise<State>;
+  retry: (state: State) => Promise<State>;
+  setFirstName: (state: State, arg?: unknown) => State;
+  setLastName: (state: State, arg?: unknown) => State;
+  setCompany: (state: State, arg?: unknown) => State;
+  setAddressLine1: (state: State, arg?: unknown) => State;
+  setAddressLine2: (state: State, arg?: unknown) => State;
+  setCity: (state: State, arg?: unknown) => State;
+  setSubdivision: (state: State, arg?: unknown) => State;
+  setZipCode: (state: State, arg?: unknown) => State;
+  setCountry: (state: State, arg?: unknown) => State;
+  setPhoneNumber: (state: State, arg?: unknown) => State;
+  setMakeDefault: (state: State, arg?: unknown) => State;
+  save: (state: State) => Promise<State>;
+  askRemove: (state: State) => State;
+  keep: (state: State) => State;
+  remove: (state: State) => Promise<State>;
+}>("himiBrandedAddress", {
+  state: INITIAL,
+  actions: {
+    load,
+    retry: (state) => load(state),
+    setFirstName: setter("firstName"),
+    setLastName: setter("lastName"),
+    setCompany: setter("company"),
+    setAddressLine1: setter("addressLine1"),
+    setAddressLine2: setter("addressLine2"),
+    setCity: setter("city"),
+    setSubdivision: setter("subdivision"),
+    setZipCode: setter("zipCode"),
+    setCountry: setter("country"),
+    setPhoneNumber: setter("phoneNumber"),
+    setMakeDefault: (state, arg) => {
+      const value = (arg as { value?: unknown } | null)?.value ?? arg;
+      return derive({ ...state, makeDefault: value === true || value === "true" });
+    },
+    save,
+    askRemove: (state) => (state.id ? derive({ ...state, confirmingRemove: true, message: "" }) : state),
+    keep: (state) => derive({ ...state, confirmingRemove: false }),
+    remove,
+  },
+});
+
+export { svc };

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

@@ -0,0 +1,202 @@
+// 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 {
+  deleteMemberAddress,
+  listMemberAddresses,
+  setDefaultMemberAddress,
+  type WixMemberAddress,
+} from "@himalaya/wix-ecom";
+import { copyParam, stashCopy } from "../_shared/himi-copy.js";
+import { assertMemberAccess, memberAccess, memberAccessDenied, memberChanged, type MemberAccess } from "../_shared/member-access.js";
+import { memberAddressLines } from "../_shared/member-address.js";
+import { memberAccountRoutes } from "../_shared/member-account-routes.js";
+
+interface AddressRow {
+  id: string;
+  name: string;
+  lines: string;
+  phone: string;
+  isDefault: boolean;
+  notDefault: boolean;
+  confirming: boolean;
+  notConfirming: boolean;
+  /** The row's actions (edit / set default / remove) while no remove is being confirmed. */
+  hideActions: boolean;
+}
+
+interface State {
+  status: "loading" | "ready" | "error";
+  rows: AddressRow[];
+  message: string;
+  errorText: string;
+  needsSignIn: boolean;
+  /** This host cannot reach the address book (web, a hosted app): say so, load nothing. */
+  unavailable: boolean;
+  noUnavailable: boolean;
+  isLoading: boolean;
+  notLoading: boolean;
+  notErrored: boolean;
+  noSignIn: boolean;
+  hideList: boolean;
+  noEmpty: boolean;
+  /** The Add button: hidden for a guest and while loading or errored. */
+  hideAdd: boolean;
+}
+
+let member: MemberAccess | undefined;
+let addresses: WixMemberAddress[] = [];
+let defaultId = "";
+let confirmId = "";
+let busy = false;
+
+function rowOf(address: WixMemberAddress): AddressRow {
+  const id = address.id ?? "";
+  const { name, lines } = memberAddressLines(address);
+  const isDefault = id === defaultId;
+  const confirming = id === confirmId;
+  return {
+    id,
+    name: name || copyParam("addresses.unnamedLabel", "Saved address"),
+    lines,
+    phone: address.phoneNumber?.trim() ?? "",
+    isDefault,
+    notDefault: !isDefault,
+    confirming,
+    notConfirming: !confirming,
+    hideActions: confirming,
+  };
+}
+
+function derive(state: State): State {
+  // The default address leads, like the site's own page.
+  const ordered = [...addresses].sort((a, b) => Number(b.id === defaultId) - Number(a.id === defaultId));
+  const rows = state.status === "ready" ? ordered.filter((a) => !!a.id).map(rowOf) : [];
+  const ready = state.status === "ready" && !state.unavailable;
+  return {
+    ...state,
+    rows,
+    noUnavailable: !state.unavailable,
+    isLoading: state.status === "loading",
+    notLoading: state.status !== "loading",
+    notErrored: state.status !== "error",
+    noSignIn: !ready || !state.needsSignIn,
+    hideList: !ready || state.needsSignIn || rows.length === 0,
+    noEmpty: !ready || state.needsSignIn || rows.length > 0,
+    hideAdd: !ready || state.needsSignIn,
+  };
+}
+
+const INITIAL: State = derive({
+  status: "loading", rows: [], message: "", errorText: "", needsSignIn: false, unavailable: false, noUnavailable: true,
+  isLoading: true, notLoading: false, notErrored: true, noSignIn: true, hideList: true, noEmpty: true, hideAdd: true,
+});
+
+async function load(state: State, arg?: unknown): Promise<State> {
+  stashCopy(arg);
+  confirmId = "";
+  if (!(await memberAccountRoutes()).addresses) {
+    addresses = [];
+    return derive({ ...state, status: "ready", unavailable: true, needsSignIn: false, message: "", errorText: "" });
+  }
+  try {
+    member = await memberAccess();
+    if (!member.email) {
+      addresses = [];
+      return derive({ ...state, status: "ready", unavailable: false, needsSignIn: true, message: "", errorText: "" });
+    }
+    const response = await listMemberAddresses();
+    await assertMemberAccess(member);
+    addresses = response.addresses ?? [];
+    defaultId = response.defaultAddressId ?? "";
+    // A fresh load drops the last write's confirmation; write() sets it again after this.
+    return derive({ ...state, status: "ready", unavailable: false, needsSignIn: false, message: "", errorText: "" });
+  } catch (error) {
+    addresses = [];
+    return derive({
+      ...state,
+      status: "error",
+      unavailable: false,
+      message: "",
+      errorText: memberAccessDenied(error)
+        ? copyParam("addresses.accessErrorText", "Your addresses are unavailable for this account. Try signing in again.")
+        : copyParam("addresses.loadErrorText", "Your addresses could not be loaded."),
+    });
+  }
+}
+
+function argId(arg: unknown): string {
+  const id = (arg as { id?: unknown } | null)?.id;
+  return typeof id === "string" ? id : "";
+}
+
+/** Run one write for the signed-in member, then re-read the book. A changed or lost
+ *  identity reloads instead of writing for whoever signed in since. */
+async function write(state: State, run: () => Promise<unknown>, done: string, failed: string): Promise<State> {
+  if (busy || !member?.email) return state;
+  busy = true;
+  try {
+    await assertMemberAccess(member);
+    await run();
+    const next = await load(state);
+    return next.status === "ready" ? { ...next, message: done } : next;
+  } catch (error) {
+    if (await memberChanged(member, error)) return load(state);
+    return derive({ ...state, message: failed });
+  } finally {
+    busy = false;
+  }
+}
+
+const svc = defineService<State, {
+  load: (state: State, arg?: unknown) => Promise<State>;
+  retry: (state: State) => Promise<State>;
+  add: (state: State) => State;
+  edit: (state: State, arg?: unknown) => State;
+  setDefault: (state: State, arg?: unknown) => Promise<State>;
+  askRemove: (state: State, arg?: unknown) => State;
+  keep: (state: State) => State;
+  remove: (state: State, arg?: unknown) => Promise<State>;
+}>("himiBrandedAddresses", {
+  state: INITIAL,
+  actions: {
+    load,
+    retry: (state) => load(derive({ ...state, status: "loading", message: "" })),
+    add: (state) => navigate({ ...state, message: "" }, { screenId: "himi_address" }),
+    edit: (state, arg) => {
+      const id = argId(arg);
+      return addresses.some((a) => a.id === id) ? navigate({ ...state, message: "" }, { screenId: "himi_address", args: { id } }) : state;
+    },
+    setDefault: (state, arg) => {
+      const id = argId(arg);
+      if (!id || id === defaultId || !addresses.some((a) => a.id === id)) return Promise.resolve(state);
+      return write(state, () => setDefaultMemberAddress(id),
+        copyParam("addresses.defaultDone", "Default address updated."),
+        copyParam("addresses.defaultFailed", "The default address could not be changed. Try again."));
+    },
+    askRemove: (state, arg) => {
+      const id = argId(arg);
+      if (!addresses.some((a) => a.id === id)) return state;
+      confirmId = id;
+      return derive({ ...state, message: "" });
+    },
+    keep: (state) => {
+      confirmId = "";
+      return derive(state);
+    },
+    remove: (state, arg) => {
+      // Only the address the member is confirming — a stale row tap removes nothing.
+      const id = argId(arg);
+      if (!id || id !== confirmId) return Promise.resolve(state);
+      return write(state, () => deleteMemberAddress(id),
+        copyParam("addresses.removeDone", "Address removed."),
+        copyParam("addresses.removeFailed", "The address could not be removed. Try again."));
+    },
+  },
+});
+
+export { svc };