@wix/himalaya-cli 0.1497.0 → 0.1499.0

package/templates/yoga-studio-owner/tier5-src/_shared/owner-today-rollup.ts

@@ -0,0 +1,307 @@
+// The owner's Today ROLLUP — one glance over every business, for the Home Screen widget that
+// summarises them all (himi-owner-lite-today-rollup). Pure: the worker reads, this shapes.
+//
+// What an owner with several businesses wants from the Home Screen is not each business in turn
+// but the day as a whole — how many bookings, how many orders waiting, what came in — and which
+// business is carrying it. So the frame is totals across the businesses that were read, plus the
+// busiest one by name.
+//
+// A business that could not be read is LEFT OUT of the totals and said so ("1 business not
+// counted"), never counted as zero: a total that silently drops a business reads as a quiet day.
+// Only when no business could be read is the frame an error, which the phone does not publish —
+// the last good frame stays.
+
+import { formatCurrency } from "./engine-intl.js";
+
+type Rec = Record<string, unknown>;
+
+/** A glance, not a list: a count at the cap reads as "50+". Per business and per read. */
+export const ROLLUP_LIMIT = 50;
+/** Bounds the fan-out: three reads per business, concurrently. An owner past it sees a note. */
+export const ROLLUP_MAX_SITES = 25;
+
+export const ROLLUP_COPY = {
+  signedOut: "Sign in to Owner to see today",
+  error: "Open Owner to refresh",
+  noSites: "No businesses on this account yet",
+  nothing: "Open Owner to see your businesses",
+  quiet: "All quiet across your businesses",
+} as const;
+
+/** One vertical's read for one business: its rows, "absent" when the vertical cannot exist for
+ *  this owner (not installed, no permission, not in this build), or null when the read failed. */
+export type VerticalRead = Rec[] | "absent" | null;
+
+export interface SiteReads {
+  id: string;
+  name: string;
+  /** CONFIRMED bookings starting today (local day). */
+  bookings: VerticalRead;
+  /** Orders needing attention (the Home dashboard's filter). */
+  orders: VerticalRead;
+  /** PAID orders created today — the revenue so far. */
+  sales: VerticalRead;
+}
+
+export interface RollupSite {
+  id: string;
+  name: string;
+  bookings: number;
+  orders: number;
+}
+
+export interface RollupState {
+  status: "loading" | "ready" | "error" | "signedOut";
+  /** Businesses the host (or the account) listed, after the cap. */
+  siteCount: number;
+  /** Of those, the ones whose reads all answered. Totals are over these only. */
+  countedCount: number;
+  /** "Today · 3 businesses", or "Today · <name>" for an owner with one. */
+  header: string;
+  bookingsValue: string;
+  /** "bookings today" / "booking today". */
+  bookingsLabel: string;
+  ordersValue: string;
+  /** "orders to handle" / "order to handle". */
+  ordersLabel: string;
+  /** "$1,240.50", "$1,240.50+" at a read cap, "—" with no sales or sales in more than one currency. */
+  revenueValue: string;
+  /** "revenue so far", "no sales yet", or "revenue in 2 currencies". */
+  revenueLabel: string;
+  /** The small widget's labels, short enough for a 2×2 at body size: "bookings", "to handle",
+   *  "so far" / "no sales yet" / "2 currencies". */
+  bookingsShort: string;
+  ordersShort: string;
+  revenueShort: string;
+  hideBookings: boolean;
+  hideOrders: boolean;
+  hideRevenue: boolean;
+  /** "Busiest: Riverbend Studio", the quiet line when nothing is happening, "" for one business. */
+  busiestLine: string;
+  hideBusiest: boolean;
+  /** The small widget's two-line form of it: "Busiest" over the name, or "All quiet" alone. */
+  busiestCaption: string;
+  busiestName: string;
+  hideBusiestName: boolean;
+  /** Compact counts for the small widget: "12 bookings · 5 orders". */
+  countsShort: string;
+  /** "1 business not counted", "Showing 25 of 30 businesses", or "". */
+  note: string;
+  hideNote: boolean;
+  /** One-line state copy for a degrade or an owner with no businesses. Hides the stats. */
+  message: string;
+  hideMessage: boolean;
+  /** True when `message` replaces the stats. */
+  hideStats: boolean;
+  /** Epoch SECONDS: the next local midnight, when "today" stops being true. */
+  validUntil: number;
+  sites: RollupSite[];
+}
+
+export interface Verticals {
+  bookings: boolean;
+  store: boolean;
+}
+
+function capped(n: number, atCap: boolean): string {
+  return atCap ? `${ROLLUP_LIMIT}+` : String(n);
+}
+
+function plural(n: number, one: string, many: string): string {
+  return n === 1 ? one : many;
+}
+
+function rows(read: VerticalRead): Rec[] {
+  return Array.isArray(read) ? read : [];
+}
+
+function str(r: unknown, path: string): string {
+  let v: unknown = r;
+  for (const k of path.split(".")) v = v && typeof v === "object" ? (v as Rec)[k] : undefined;
+  return typeof v === "string" ? v : typeof v === "number" ? String(v) : "";
+}
+
+function sameLocalDay(a: Date, b: Date): boolean {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+
+/** Local midnight at the start of `now`'s day, and the next one. */
+export function dayBounds(now: Date): { start: Date; end: Date } {
+  return {
+    start: new Date(now.getFullYear(), now.getMonth(), now.getDate()),
+    end: new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1),
+  };
+}
+
+// Re-filtered even though the queries filter: a server (or a fixture) that returns a cancelled
+// booking, yesterday's order or an unpaid sale must not reach a number the owner reads as fact.
+function bookingsToday(read: VerticalRead, now: Date): Rec[] {
+  return rows(read).filter((b) => str(b, "id") && str(b, "status").toUpperCase() === "CONFIRMED"
+    && sameLocalDay(new Date(str(b, "startDate") || str(b, "bookedEntity.slot.startDate")), now));
+}
+
+function ordersToHandle(read: VerticalRead): Rec[] {
+  return rows(read).filter((o) => {
+    if (!str(o, "id") || ["CANCELED", "CANCELLED"].includes(str(o, "status").toUpperCase())) return false;
+    const payment = str(o, "paymentStatus").toUpperCase();
+    const fulfillment = str(o, "fulfillmentStatus").toUpperCase();
+    return payment === "NOT_PAID" || payment === "PARTIALLY_PAID"
+      || (payment === "PAID" && (fulfillment === "NOT_FULFILLED" || fulfillment === "PARTIALLY_FULFILLED"));
+  });
+}
+
+function salesToday(read: VerticalRead, now: Date): Rec[] {
+  return rows(read).filter((o) => str(o, "id") && str(o, "paymentStatus").toUpperCase() === "PAID"
+    && !["CANCELED", "CANCELLED"].includes(str(o, "status").toUpperCase())
+    && sameLocalDay(new Date(str(o, "createdDate")), now));
+}
+
+/** A sale's total and currency. Summed as numbers and rounded once, when formatted. A total the
+ *  API did not send is skipped, never read as 0. */
+function saleTotal(o: Rec): { amount: number; currency: string } | null {
+  const amount = Number(str(o, "priceSummary.total.amount"));
+  const currency = (str(o, "currency") || str(o, "priceSummary.total.currency")).trim().toUpperCase();
+  return Number.isFinite(amount) && str(o, "priceSummary.total.amount") !== "" && currency ? { amount, currency } : null;
+}
+
+/** Pure: the frame for what was read across the businesses. `now` is injectable for tests. */
+export function shapeRollup(reads: SiteReads[], now: Date, verticals: Verticals, listed = reads.length): RollupState {
+  const validUntil = Math.floor(dayBounds(now).end.getTime() / 1000);
+  const base = { siteCount: reads.length, validUntil };
+  if (reads.length === 0) return message("ready", ROLLUP_COPY.noSites, base);
+
+  // A business is counted only when every read it needs answered (rows or "absent").
+  const counted = reads.filter((r) => r.bookings !== null && r.orders !== null && r.sales !== null);
+  if (counted.length === 0) return message("error", ROLLUP_COPY.error, base);
+
+  // Said on every frame that has businesses, the one-line ones included: a frame that drops a
+  // business, or stops at the cap, must say so whatever else it shows.
+  const skipped = reads.length - counted.length;
+  const note = skipped > 0
+    ? `${skipped} ${plural(skipped, "business", "businesses")} not counted`
+    : listed > reads.length ? `Showing ${reads.length} of ${listed} businesses` : "";
+
+  const hasBookings = verticals.bookings && counted.some((r) => r.bookings !== "absent");
+  const hasStore = verticals.store && counted.some((r) => r.orders !== "absent");
+  if (!hasBookings && !hasStore) return message("ready", ROLLUP_COPY.nothing, { ...base, countedCount: counted.length, note });
+
+  let bookingsCapped = false;
+  let ordersCapped = false;
+  let salesCapped = false;
+  const revenue = new Map<string, number>();
+  const sites: RollupSite[] = counted.map((r) => {
+    const b = bookingsToday(r.bookings, now);
+    const o = ordersToHandle(r.orders);
+    const sold = salesToday(r.sales, now);
+    bookingsCapped ||= rows(r.bookings).length >= ROLLUP_LIMIT;
+    ordersCapped ||= rows(r.orders).length >= ROLLUP_LIMIT;
+    salesCapped ||= rows(r.sales).length >= ROLLUP_LIMIT;
+    for (const sale of sold) {
+      const t = saleTotal(sale);
+      if (t) revenue.set(t.currency, (revenue.get(t.currency) ?? 0) + t.amount);
+    }
+    return { id: r.id, name: r.name, bookings: b.length, orders: o.length };
+  });
+
+  const bookings = sites.reduce((n, s) => n + s.bookings, 0);
+  const orders = sites.reduce((n, s) => n + s.orders, 0);
+  const currencies = [...revenue.keys()];
+  let revenueValue = "—";
+  let revenueLabel = "revenue so far";
+  let revenueShort = "so far";
+  if (currencies.length === 1) {
+    revenueValue = `${formatCurrency(revenue.get(currencies[0]) ?? 0, currencies[0])}${salesCapped ? "+" : ""}`;
+  } else if (currencies.length === 0) {
+    revenueLabel = "no sales yet";
+    revenueShort = "no sales yet";
+  } else {
+    // Adding dollars to shekels is not a number anyone can use; say what the day holds instead.
+    revenueLabel = `revenue in ${currencies.length} currencies`;
+    revenueShort = `${currencies.length} currencies`;
+  }
+
+  // The busiest business is the one carrying the most of today. Ties go to the host's order (the
+  // order the owner sees their businesses in), so the name does not flicker between refreshes.
+  const busiest = sites.reduce<RollupSite | undefined>((best, s) =>
+    !best || s.bookings + s.orders > best.bookings + best.orders ? s : best, undefined);
+  const quiet = bookings === 0 && orders === 0;
+  const busiestLine = reads.length === 1 ? "" : quiet ? ROLLUP_COPY.quiet : `Busiest: ${busiest?.name ?? ""}`;
+  const busiestName = reads.length === 1 || quiet ? "" : busiest?.name ?? "";
+
+
+  const shortParts = [
+    ...(hasBookings ? [`${capped(bookings, bookingsCapped)} ${plural(bookings, "booking", "bookings")}`] : []),
+    ...(hasStore ? [`${capped(orders, ordersCapped)} ${plural(orders, "order", "orders")}`] : []),
+  ];
+  return {
+    status: "ready",
+    ...base,
+    countedCount: counted.length,
+    header: reads.length === 1 ? `Today · ${reads[0].name}` : `Today · ${reads.length} businesses`,
+    bookingsValue: capped(bookings, bookingsCapped),
+    bookingsLabel: `${plural(bookings, "booking", "bookings")} today`,
+    ordersValue: capped(orders, ordersCapped),
+    ordersLabel: `${plural(orders, "order", "orders")} to handle`,
+    revenueValue,
+    revenueLabel,
+    bookingsShort: plural(bookings, "booking", "bookings"),
+    ordersShort: "to handle",
+    revenueShort,
+    hideBookings: !hasBookings,
+    hideOrders: !hasStore,
+    hideRevenue: !hasStore,
+    busiestLine,
+    hideBusiest: !busiestLine,
+    busiestCaption: !busiestLine ? "" : quiet ? "All quiet" : "Busiest",
+    busiestName,
+    hideBusiestName: !busiestName,
+    countsShort: shortParts.join(" · "),
+    note,
+    hideNote: !note,
+    message: "",
+    hideMessage: true,
+    hideStats: false,
+    sites,
+  };
+}
+
+/** A one-line frame: no stats, no business names (after a sign-out they may be someone else's). */
+export function message(
+  status: RollupState["status"],
+  text: string,
+  base: { siteCount?: number; countedCount?: number; validUntil?: number; note?: string } = {},
+): RollupState {
+  return {
+    status,
+    siteCount: base.siteCount ?? 0,
+    countedCount: base.countedCount ?? 0,
+    header: "Today",
+    bookingsValue: "",
+    bookingsLabel: "",
+    ordersValue: "",
+    ordersLabel: "",
+    revenueValue: "",
+    revenueLabel: "",
+    bookingsShort: "",
+    ordersShort: "",
+    revenueShort: "",
+    hideBookings: true,
+    hideOrders: true,
+    hideRevenue: true,
+    busiestLine: "",
+    hideBusiest: true,
+    busiestCaption: "",
+    busiestName: "",
+    hideBusiestName: true,
+    countsShort: "",
+    note: base.note ?? "",
+    hideNote: !base.note,
+    message: text,
+    hideMessage: !text,
+    hideStats: true,
+    // A fixed 0 for the initial and degrade frames: the template contract forbids a worker's
+    // initial state from reading the clock (and the baked services hash would vary by timezone).
+    validUntil: base.validUntil ?? 0,
+    sites: [],
+  };
+}

package/templates/yoga-studio-owner/tier5-src/_shared/owner-widget-reads.ts

@@ -0,0 +1,23 @@
+// How an owner widget worker reads a failed Wix call: a sign-out, a section that cannot exist for
+// this owner, or an ordinary error. Shared by the Today widget (one business) and the Today rollup
+// (every business the host lists), so the two never disagree about what hides a section.
+
+/** No usable owner session behind the bridge (the bridge refusing, or a 401). A transient
+ *  5xx is an ordinary error, not a sign-out — and a 403 is a missing PERMISSION for one
+ *  vertical (a collaborator whose role lacks Bookings), not a sign-out either. */
+export function isSignedOut(e: unknown): boolean {
+  const text = String((e as Error)?.message ?? e);
+  return /^HTTP 401\b/.test(text) || /wixApi not enabled|session unavailable|not signed in|webwix_bridge/i.test(text);
+}
+
+/** This section cannot exist for this owner: the vertical is not installed on the site (its
+ *  API answers 428, or 404 for the route), or the owner's role may not read it (403). Hides
+ *  that one section; every other failure is an error for the whole frame.
+ *
+ *  Read from the LEADING status only — the bridges format a failure as `HTTP <status>: <body>`
+ *  or `HTTP <status> [<code>]: <message>` — never from anywhere in the message: a transient
+ *  `HTTP 503: {"message":"upstream returned 404"}` must stay an error, not hide the section. */
+export function isSectionUnavailable(e: unknown): boolean {
+  const text = String((e as Error)?.message ?? e);
+  return /^HTTP (?:403|404|428)\b/.test(text) || /^HTTP \d{3} \[(?:FAILED_PRECONDITION|PERMISSION_DENIED)\]/.test(text);
+}

package/templates/yoga-studio-owner/tier5-src/himi-owner-lite-today/index.ts

@@ -18,6 +18,9 @@ import { queryBookings } from "@himalaya/wix-bookings";
 import { searchOrders } from "@himalaya/wix-ecom";
 import { ownerOrderAttentionFilter } from "../_shared/owner-order-attention.js";
 import { readSelectedSite } from "../_shared/owner-selected-site.js";
+import { isSectionUnavailable, isSignedOut } from "../_shared/owner-widget-reads.js";
+
+export { isSectionUnavailable, isSignedOut };
 
 type Rec = Record<string, unknown>;
 
@@ -215,27 +218,12 @@ export function degraded(status: "error" | "signedOut" | "loading", siteName: st
   return { ...base, status, message, hideMessage: !message, validUntil: 0 };
 }
 
-/** No usable owner session behind the bridge (the bridge refusing, or a 401). A transient
- *  5xx is an ordinary error, not a sign-out — and a 403 is a missing PERMISSION for one
- *  vertical (a collaborator whose role lacks Bookings), not a sign-out either. */
-export function isSignedOut(e: unknown): boolean {
-  const text = String((e as Error)?.message ?? e);
-  return /^HTTP 401\b/.test(text) || /wixApi not enabled|session unavailable|not signed in|webwix_bridge/i.test(text);
-}
-
-/** This section cannot exist for this owner: the vertical is not installed on the site (its
- *  API answers 428, or 404 for the route), or the owner's role may not read it (403). Hides
- *  that one section; every other failure is an error for the whole frame.
- *
- *  Read from the LEADING status only — the bridges format a failure as `HTTP <status>: <body>`
- *  or `HTTP <status> [<code>]: <message>` — never from anywhere in the message: a transient
- *  `HTTP 503: {"message":"upstream returned 404"}` must stay an error, not hide the section. */
-export function isSectionUnavailable(e: unknown): boolean {
-  const text = String((e as Error)?.message ?? e);
-  return /^HTTP (?:403|404|428)\b/.test(text) || /^HTTP \d{3} \[(?:FAILED_PRECONDITION|PERMISSION_DENIED)\]/.test(text);
-}
-
+/** The business this frame is about. An embedding host that publishes this widget once per
+ *  business names each one in its input (`siteName`): there, the app's selected-site storage is
+ *  whichever business the owner last opened, not the one this frame was read for. */
 function siteName(): string {
+  const hosted = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.siteName;
+  if (typeof hosted === "string" && hosted.trim()) return hosted.trim();
   return readSelectedSite()?.name ?? "";
 }
 

package/templates/yoga-studio-owner/tier5-src/himi-owner-lite-today-rollup/index.ts

@@ -0,0 +1,121 @@
+// Tier-5 bundle: __HIMI_APP_NAME__ — TODAY ROLLUP. The worker behind the Home Screen widget that sums
+// up EVERY business the owner owns: today's bookings, the orders waiting, the revenue so far, and
+// the busiest business by name. The per-business widget is himi-owner-lite-today.
+//
+// Like that worker it runs headlessly on the phone (or in an embedding host's
+// `HimalayaEmbedSurfaces.publishWidgets`), and the widget only ever draws the frozen result.
+//
+// It reads each business with `site.forSite(msid)`, as the owner overview does, so the active
+// business never moves. Embedded, the host names the businesses (`hostOwnedSites`, answered by a
+// data source that conforms to `HimalayaOwnedSitesDataSource`) and signs each call for the one it
+// names; standalone, the account lists them (`querySites`). Read-only: a widget never writes.
+
+import { defineService } from "@himalaya/state";
+import { querySites, type WixSite } from "@himalaya/wix-site-list";
+import { site } from "@himalaya/wix-platform";
+import { queryBookings } from "@himalaya/wix-bookings";
+import { searchOrders } from "@himalaya/wix-ecom";
+import { ownerOrderAttentionFilter } from "../_shared/owner-order-attention.js";
+import { hostOwnedSites } from "../_shared/owner-hosted-sites.js";
+import { isSectionUnavailable, isSignedOut } from "../_shared/owner-widget-reads.js";
+import {
+  ROLLUP_COPY, ROLLUP_LIMIT, ROLLUP_MAX_SITES, dayBounds, message, shapeRollup,
+  type RollupState, type SiteReads, type VerticalRead, type Verticals,
+} from "../_shared/owner-today-rollup.js";
+
+export type { RollupState };
+
+/** The build's verticals from the descriptor's baked `input.verticals` ("bookings,store"). A
+ *  descriptor without one reads both. */
+export function buildVerticals(): Verticals {
+  const raw = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.verticals;
+  if (typeof raw !== "string") return { bookings: true, store: true };
+  const set = new Set(raw.split(",").map((v) => v.trim()));
+  return { bookings: set.has("bookings"), store: set.has("store") };
+}
+
+/** Rung 1: the host's list when embedded, else the account's own. */
+async function listBusinesses(): Promise<Array<{ id: string; name: string }>> {
+  const hosted = await hostOwnedSites();
+  if (hosted) return hosted.map((h) => ({ id: h.id, name: h.name || "Business" }));
+  const res = await querySites({ query: { cursorPaging: { limit: 100 } } });
+  return (res.sites ?? [])
+    .filter((r: WixSite) => r?.id)
+    .map((r: WixSite) => ({ id: r.id || "", name: r.displayName || (r as { name?: string }).name || "Business" }));
+}
+
+/** Thrown through `Promise.all` when any read finds the owner signed out. */
+const SIGNED_OUT = { signedOut: true } as const;
+
+/** One vertical, one business. A section that cannot exist is "absent"; a sign-out stops the
+ *  whole read (the frame must not keep any business's numbers); anything else is null. */
+async function vertical(enabled: boolean, key: string, read: () => Promise<unknown>): Promise<VerticalRead> {
+  if (!enabled) return "absent";
+  try {
+    const list = ((await read()) as Record<string, unknown> | undefined)?.[key];
+    return Array.isArray(list) ? (list as Record<string, unknown>[]) : [];
+  } catch (e) {
+    if (isSignedOut(e)) throw SIGNED_OUT;
+    return isSectionUnavailable(e) ? "absent" : null;
+  }
+}
+
+async function readSite(b: { id: string; name: string }, verticals: Verticals, now: Date): Promise<SiteReads> {
+  const { start, end } = dayBounds(now);
+  const scope = site.forSite(b.id);
+  const [bookings, orders, sales] = await Promise.all([
+    vertical(verticals.bookings, "bookings", () => queryBookings({ query: {
+      filter: { startDate: { $gte: start.toISOString(), $lt: end.toISOString() }, status: { $in: ["CONFIRMED"] } },
+      sort: [{ fieldName: "startDate", order: "ASC" }, { fieldName: "id", order: "ASC" }],
+      paging: { limit: ROLLUP_LIMIT, offset: 0 },
+    } }, scope)),
+    vertical(verticals.store, "orders", () => searchOrders({ search: {
+      filter: ownerOrderAttentionFilter(),
+      sort: [{ fieldName: "createdDate", order: "DESC" }, { fieldName: "id", order: "ASC" }],
+      cursorPaging: { limit: ROLLUP_LIMIT },
+    } }, scope)),
+    vertical(verticals.store, "orders", () => searchOrders({ search: {
+      filter: {
+        archived: false,
+        status: { $nin: ["CANCELED", "CANCELLED"] },
+        paymentStatus: "PAID",
+        createdDate: { $gte: start.toISOString() },
+      },
+      sort: [{ fieldName: "createdDate", order: "DESC" }, { fieldName: "id", order: "ASC" }],
+      cursorPaging: { limit: ROLLUP_LIMIT },
+    } }, scope)),
+  ]);
+  return { id: b.id, name: b.name, bookings, orders, sales };
+}
+
+async function read(): Promise<RollupState> {
+  const now = new Date();
+  const verticals = buildVerticals();
+  let listed: Array<{ id: string; name: string }>;
+  try {
+    listed = await listBusinesses();
+  } catch (e) {
+    return isSignedOut(e) ? message("signedOut", ROLLUP_COPY.signedOut) : message("error", ROLLUP_COPY.error);
+  }
+  const businesses = listed.slice(0, ROLLUP_MAX_SITES);
+  try {
+    const reads = await Promise.all(businesses.map((b) => readSite(b, verticals, now)));
+    return shapeRollup(reads, now, verticals, listed.length);
+  } catch (e) {
+    if (e === SIGNED_OUT) return message("signedOut", ROLLUP_COPY.signedOut);
+    return message("error", ROLLUP_COPY.error);
+  }
+}
+
+const svc = defineService<RollupState, {
+  load: (s: RollupState) => Promise<RollupState>;
+  refresh: (s: RollupState) => Promise<RollupState>;
+}>("ownerTodayRollup", {
+  state: message("loading", ""),
+  actions: {
+    load: async () => read(),
+    refresh: async () => read(),
+  },
+});
+
+export { svc };

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

@@ -1,22 +0,0 @@
-import { withCollectionSaving, type CollectionSaving } from './collection-service.js';
-import { readSavedProducts, writeSavedProducts } from './himi-store-saved.js';
-
-export const storeCollectionSaving: CollectionSaving = {
-  read: () => readSavedProducts().map(row => row.id),
-  write(ids, rows) {
-    const products = new Map(readSavedProducts().map(row => [row.id, row]));
-    for (const row of rows) {
-      if (typeof row.id !== 'string' || typeof row.name !== 'string') continue;
-      const previous = products.get(row.id);
-      const freshPrice = typeof row.commercePrice === 'string' ? row.commercePrice : typeof row.subtitle === 'string' ? row.subtitle : '';
-      const wasPrice = typeof row.wasPrice === 'string' ? row.wasPrice || undefined : previous?.price === freshPrice ? previous?.wasPrice : undefined;
-      products.set(row.id, { ...previous, wasPrice, id: row.id, name: row.name,
-        price: freshPrice || previous?.price || '',
-        image: typeof row.image === 'string' && row.image ? row.image : previous?.image ?? '' });
-    }
-    const selected = ids.map(id => products.get(id));
-    if (selected.some(row => !row)) throw new Error('Saved product metadata is unavailable');
-    writeSavedProducts(selected.filter((row): row is NonNullable<typeof row> => !!row));
-  },
-};
-export const defineService = withCollectionSaving(storeCollectionSaving);