@wix/himalaya-cli 0.1446.0 → 0.1448.0

package/templates/portfolio-creative-owner/tier5-src/himi-owner-lite-manage/logic.ts

@@ -110,13 +110,26 @@ export function countText(metric: Metric, label: string): string {
   return `${count}${metric.hasMore ? "+" : ""} ${label}`;
 }
 
-/** Apply independently loaded metrics. A failed source stays visibly unknown;
- * it never becomes a misleading zero. */
-export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, unavailable: Set<string>): ManageArea[] {
+/** Why a summary could not load: the area's app is not on the site, the owner may not read it, or the read failed.
+ *  From the LEADING status only, as Today reads it (`isSectionUnavailable`): a transient
+ *  `HTTP 503: {"message":"upstream returned 404"}` is a failure, not a missing app. */
+export type MetricFailure = "notSetUp" | "noAccess" | "failed";
+
+export function metricFailure(error: unknown): MetricFailure {
+  const text = String((error as Error)?.message ?? error);
+  if (/^HTTP (?:404|428)\b/.test(text) || /^HTTP \d{3} \[FAILED_PRECONDITION\]/.test(text)) return "notSetUp";
+  if (/^HTTP 403\b/.test(text) || /^HTTP \d{3} \[PERMISSION_DENIED\]/.test(text)) return "noAccess";
+  return "failed";
+}
+
+/** Apply independently loaded metrics. A failed source stays visibly unknown, saying why on its own row
+ * ([failures]: metric key → that row's status); it never becomes a misleading zero. */
+export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, failures: Map<string, string>): ManageArea[] {
   return areas.map(area => {
     const metric = metrics[area.metricKey];
-    if (!metric || unavailable.has(area.metricKey)) {
-      return { ...area, metricText: "—", statusText: "Couldn’t load summary", unavailable: true };
+    const failure = failures.get(area.metricKey);
+    if (!metric || failure !== undefined) {
+      return { ...area, metricText: "—", statusText: failure ?? "", unavailable: true };
     }
     return {
       ...area,

package/templates/restaurant/tier5-src/_shared/collection-query.ts

@@ -20,6 +20,13 @@ export interface CollectionQueryState<Row> extends CollectionPage<Row> {
   pageError: boolean;
   complete: boolean;
   error: string;
+  /** The rows are the source's `cached` page, shown while the live read is still out. */
+  provisional?: boolean;
+}
+/** What a collection showed, as `shownPage` hands it out and `seed` takes it back on a restored boot. */
+export interface CollectionShownPage<Row> {
+  state: CollectionQueryState<Row>;
+  loadedPages: number;
 }
 export interface CollectionQuerySource<Row> {
   fetch(criteria: CollectionQuery, cursor: string): Promise<CollectionPage<Row>>;
@@ -50,13 +57,19 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
   let state: CollectionQueryState<Row> = { criteria: normalize({}), items: [], nextCursor: '', status: 'idle', loadingMore: false, pageError: false, complete: false, error: '' };
   /** The query a revalidation is running under: its snapshots are held back until it is done. */
   let revalidating = -1;
-  /** What the screen shows: the last published state, restored when a revalidation fails. */
-  let shown: { state: CollectionQueryState<Row>; loadedPages: number } | undefined;
+  /** The last page the screen showed whole (rows ready, nothing paging, failing or standing in): what a revalidation
+   *  keeps on screen and restores when it fails, and what a restored boot shows. A next page loading or failing after
+   *  it leaves those rows on screen, so it is still this. */
+  let lastShown: { state: CollectionQueryState<Row>; loadedPages: number } | undefined;
+  const sameCriteria = (a: CollectionQuery, b: CollectionQuery) => JSON.stringify(a) === JSON.stringify(b);
   let clearedByError = false;
   const snapshot = (): CollectionQueryState<Row> => ({ ...state, criteria: copyQuery(state.criteria), items: [...state.items] });
   const emit = () => {
     if (disposed || revalidating === generation) return;
-    shown = { state: snapshot(), loadedPages };
+    // A settled answer replaces it, an empty one included: rows the live query proved gone are never kept.
+    if (state.status === 'ready' && !state.pageError && !state.loadingMore && !state.provisional) {
+      lastShown = state.items.length > 0 ? { state: snapshot(), loadedPages } : undefined;
+    }
     publish(snapshot());
   };
   const merge = (old: Row[], page: Row[]): Row[] => {
@@ -77,14 +90,14 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
     const criteria = copyQuery(state.criteria);
     if (!append) loadedPages = 0;
     state = { ...state, status: append ? 'ready' : 'loading', loadingMore: append, pageError: false, error: '',
-      ...(append ? {} : { items: [], nextCursor: '', total: undefined, metadata: undefined, complete: false }) };
+      ...(append ? {} : { items: [], nextCursor: '', total: undefined, metadata: undefined, complete: false, provisional: false }) };
     emit();
     try {
       if (!append && source.cached) {
         const cached = await source.cached(criteria).catch(() => undefined);
         if (disposed || generation !== revision) return;
         if (cached?.items.length) {
-          state = { ...state, items: merge([], cached.items), metadata: cached.metadata, status: 'ready', complete: false };
+          state = { ...state, items: merge([], cached.items), metadata: cached.metadata, status: 'ready', complete: false, provisional: true };
           emit();
         }
       }
@@ -94,17 +107,18 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
       state = { ...state, items: merge(append ? state.items : [], page.items), nextCursor: page.nextCursor,
         total: typeof page.total === 'number' && Number.isFinite(page.total) && page.total >= 0 ? page.total : (append ? state.total : undefined),
         metadata: page.metadata ?? (append ? state.metadata : undefined),
-        status: 'ready', loadingMore: false, pageError: false, complete: page.complete ?? !page.nextCursor };
+        status: 'ready', loadingMore: false, pageError: false, complete: page.complete ?? !page.nextCursor, provisional: false };
       loadedPages++;
     } catch (error) {
       if (disposed || generation !== revision) return;
       const clear = source.clearOnError?.(error) === true;
       // Revoked access always ends what a revalidation showed, whether or not the source clears its rows.
       clearedByError = clear || /HTTP 40[13]\b/.test(String(error));
+      if (clearedByError) lastShown = undefined;
       if (clear) loadedPages = 0;
       state = { ...state, ...(clear ? { items: [], nextCursor: '', total: undefined, metadata: undefined } : {}),
         status: append && !clear ? 'ready' : 'error', loadingMore: false, pageError: append && !clear, complete: false,
-        error: source.errorMessage?.(error) ?? '' };
+        provisional: false, error: source.errorMessage?.(error) ?? '' };
     }
     emit();
   };
@@ -117,8 +131,7 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
       const next = normalize(criteria);
       const same = JSON.stringify(next) === JSON.stringify(state.criteria);
       const count = restorePages && same ? Math.max(loadedPages, restoringPages, 1) : 1;
-      const showing = shown && shown.state.status === 'ready' && shown.state.items.length > 0 && !shown.state.pageError
-        && !shown.state.loadingMore && JSON.stringify(shown.state.criteria) === JSON.stringify(next) ? shown : undefined;
+      const showing = lastShown && sameCriteria(lastShown.state.criteria, next) ? lastShown : undefined;
       restoringPages = count;
       state = { ...state, criteria: next };
       if (revalidate && showing) { revalidating = generation + 1; clearedByError = false; }
@@ -140,6 +153,27 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
         emit();
       }
     },
+    /** The page the screen shows (rows ready, nothing failing or still paging), for the service to keep with its
+     *  state; undefined when it shows none. */
+    shownPage(): CollectionShownPage<Row> | undefined {
+      if (!lastShown || !sameCriteria(lastShown.state.criteria, state.criteria)) return undefined;
+      const page = lastShown.state;
+      return { state: { ...page, criteria: copyQuery(page.criteria), items: [...page.items] }, loadedPages: lastShown.loadedPages };
+    },
+    /** A cold boot restored from disk: what the last run showed becomes what this one shows, so its first `load`
+     *  revalidates behind it instead of starting empty. Only before the first query, and only a well-formed page. */
+    seed(page: unknown): boolean {
+      const candidate = page && typeof page === 'object' ? page as Partial<CollectionShownPage<Row>> : undefined;
+      const restored = candidate?.state;
+      if (generation !== 0 || state.status !== 'idle' || !restored || restored.status !== 'ready'
+        || !Array.isArray(restored.items) || restored.items.length === 0 || typeof restored.nextCursor !== 'string') return false;
+      try { restored.items.forEach(item => { if (!source.id(item)) throw new Error('A backend collection row requires an identity'); }); } catch { return false; }
+      state = { ...state, ...restored, criteria: normalize(restored.criteria ?? {}), items: [...restored.items], status: 'ready',
+        loadingMore: false, pageError: false, provisional: false, error: '' };
+      loadedPages = Math.max(1, Math.floor(Number(candidate?.loadedPages) || 1));
+      lastShown = { state: snapshot(), loadedPages };
+      return true;
+    },
     refresh: () => { restoringPages = 0; return fetch(false); },
     loadMore: () => fetch(true),
     retry: () => fetch(state.pageError),

package/templates/restaurant/tier5-src/_shared/collection-service.ts

@@ -142,6 +142,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // the query controller carries a recoverable failure. Treat each shape as
     // one collection state so the shared UI never renders a blank catalog.
     const backendState = backend?.controller.getState();
+    const provisional = backendState?.provisional === true;
     const errored = s.status === 'error' || s.isErrored === true || s.errored === true || backendState?.status === 'error';
     const domainError = typeof s.error === 'string' ? s.error.trim() : '';
     const queryError = typeof backendState?.error === 'string' ? backendState.error.trim() : '';
@@ -177,13 +178,17 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // un-narrowed failure. A re-query while typing keeps it (and the search field's focus).
     const hideChrome = (!narrowed && !s.nextCursor && projected.loaded < COLLECTION_CHROME_MIN_ITEMS)
       || sourceEmpty || ((loading || errored) && rows.length === 0 && !narrowed);
-    return { ...s, collection: { ...prefs, ...projected,
+    // Kept with the state, so a cold boot restored from disk shows its last page and revalidates behind it.
+    const collectionShown = backend?.controller.shownPage();
+    return { ...s, ...(backend ? { collectionShown: collectionShown ?? null } : {}), collection: { ...prefs, ...projected,
       hideChrome, noActiveCriteria: !narrowed,
       viewName, viewMessage, saveMessage, noSavedViews: prefs.savedViews.length === 0,
       cursor: s.pageError === true || s.loadingMore === true ? '' : s.nextCursor,
       noMore: !s.nextCursor || s.pageError === true || s.loadingMore === true,
       noPageError: s.pageError !== true,
-      noOffline: s.fromCache !== true,
+      // Rows read from the device ahead of the live read are shown as they are: "saved offline" is what stays on
+      // screen when the live read failed, not a first visit that is still loading.
+      noOffline: s.fromCache !== true || provisional,
       noError: !errored,
       noRetry: !canRetry || signInRequired,
       noSignIn: !signInRequired,
@@ -202,7 +207,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
       filtersPresented, previewPresented: !!previewId, preview: projected.items.filter(row => row.collectionId === previewId),
       persistenceLabel: persisted.available ? copyParam('collection.onDevice', 'Saved on this device') : copyParam('collection.sessionOnly', 'Choices last for this session'),
       noEmpty: loading || errored || sourceEmpty || domainNarrowed || projected.items.length > 0,
-      summary: backend && config.backendQuery && s.fromCache
+      summary: backend && config.backendQuery && s.fromCache && !provisional
         ? copyParam('collection.cached', 'Saved offline · may be outdated')
         : collectionSummary({ shown: projected.items.length, loaded: projected.loaded, backend: !!(backend && config.backendQuery),
           total: typeof s.total === 'number' ? s.total : undefined, noun: config.countNoun
@@ -345,6 +350,13 @@ export function defineBackendCollection<S extends object, Row extends object>(na
     apply: (state, page) => options.apply(state as S, page as unknown as CollectionQueryState<Row>) as State,
   });
   const handle = (options.register ?? register)(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.
+  const restored = (handle as { getState?: () => State }).getState?.();
+  const rowsKey = COLLECTIONS[name]?.rows;
+  const restoredRows = rowsKey ? restored?.[rowsKey] : undefined;
+  if (Array.isArray(restoredRows) && restoredRows.length > 0) controller.seed(restored?.collectionShown);
   publish = () => handle.collectionDataChanged();
   return handle;
 }

package/templates/restaurant/tier5-src/_shared/iap-presentation.ts

@@ -45,7 +45,9 @@ export function withIapPresentation<S extends object>(options: {
       return project(next);
     }]));
     const service = (options.register ?? defineService)(name, {
-      ...definition, notHydrated: [...(definition.notHydrated ?? []), ...options.transientKeys],
+      // The collection's shown page goes with the rows and chrome it copies: kept out of the restore with them.
+      ...definition, notHydrated: [...(definition.notHydrated ?? []), ...options.transientKeys,
+        ...((options.transientKeys as string[]).includes('collection') ? ['collectionShown' as keyof S & string] : [])],
       actions: { ...actions, iapPublish: project, iapPoll: async () => { await commerce.poll(); return undefined; },
         iapRefresh: async () => { await commerce.loadPrices(items); return undefined; } },
     });

package/templates/restaurant-owner/dev/index.ts

@@ -51769,20 +51769,6 @@ const SCREENS = runtimeSetting({
                                   }
                                 }
                               },
-                              {
-                                "id": "",
-                                "body": {
-                                  "package": "himalaya",
-                                  "type": "Text",
-                                  "props": {
-                                    "text": "$service:himiOwnerLiteManage.summaryNote",
-                                    "style": "caption",
-                                    "color": "textSecondary",
-                                    "maxLines": 2,
-                                    "collapseWhenEmpty": true
-                                  }
-                                }
-                              },
                               {
                                 "id": "",
                                 "body": {
@@ -52407,6 +52393,9 @@ const SCREENS = runtimeSetting({
                               }
                             ]
                           }
+                        },
+                        "modifiers": {
+                          "animateContentSize": true
                         }
                       }
                     }

package/templates/restaurant-owner/tier5-src/_shared/collection-query.ts

@@ -20,6 +20,13 @@ export interface CollectionQueryState<Row> extends CollectionPage<Row> {
   pageError: boolean;
   complete: boolean;
   error: string;
+  /** The rows are the source's `cached` page, shown while the live read is still out. */
+  provisional?: boolean;
+}
+/** What a collection showed, as `shownPage` hands it out and `seed` takes it back on a restored boot. */
+export interface CollectionShownPage<Row> {
+  state: CollectionQueryState<Row>;
+  loadedPages: number;
 }
 export interface CollectionQuerySource<Row> {
   fetch(criteria: CollectionQuery, cursor: string): Promise<CollectionPage<Row>>;
@@ -50,13 +57,19 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
   let state: CollectionQueryState<Row> = { criteria: normalize({}), items: [], nextCursor: '', status: 'idle', loadingMore: false, pageError: false, complete: false, error: '' };
   /** The query a revalidation is running under: its snapshots are held back until it is done. */
   let revalidating = -1;
-  /** What the screen shows: the last published state, restored when a revalidation fails. */
-  let shown: { state: CollectionQueryState<Row>; loadedPages: number } | undefined;
+  /** The last page the screen showed whole (rows ready, nothing paging, failing or standing in): what a revalidation
+   *  keeps on screen and restores when it fails, and what a restored boot shows. A next page loading or failing after
+   *  it leaves those rows on screen, so it is still this. */
+  let lastShown: { state: CollectionQueryState<Row>; loadedPages: number } | undefined;
+  const sameCriteria = (a: CollectionQuery, b: CollectionQuery) => JSON.stringify(a) === JSON.stringify(b);
   let clearedByError = false;
   const snapshot = (): CollectionQueryState<Row> => ({ ...state, criteria: copyQuery(state.criteria), items: [...state.items] });
   const emit = () => {
     if (disposed || revalidating === generation) return;
-    shown = { state: snapshot(), loadedPages };
+    // A settled answer replaces it, an empty one included: rows the live query proved gone are never kept.
+    if (state.status === 'ready' && !state.pageError && !state.loadingMore && !state.provisional) {
+      lastShown = state.items.length > 0 ? { state: snapshot(), loadedPages } : undefined;
+    }
     publish(snapshot());
   };
   const merge = (old: Row[], page: Row[]): Row[] => {
@@ -77,14 +90,14 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
     const criteria = copyQuery(state.criteria);
     if (!append) loadedPages = 0;
     state = { ...state, status: append ? 'ready' : 'loading', loadingMore: append, pageError: false, error: '',
-      ...(append ? {} : { items: [], nextCursor: '', total: undefined, metadata: undefined, complete: false }) };
+      ...(append ? {} : { items: [], nextCursor: '', total: undefined, metadata: undefined, complete: false, provisional: false }) };
     emit();
     try {
       if (!append && source.cached) {
         const cached = await source.cached(criteria).catch(() => undefined);
         if (disposed || generation !== revision) return;
         if (cached?.items.length) {
-          state = { ...state, items: merge([], cached.items), metadata: cached.metadata, status: 'ready', complete: false };
+          state = { ...state, items: merge([], cached.items), metadata: cached.metadata, status: 'ready', complete: false, provisional: true };
           emit();
         }
       }
@@ -94,17 +107,18 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
       state = { ...state, items: merge(append ? state.items : [], page.items), nextCursor: page.nextCursor,
         total: typeof page.total === 'number' && Number.isFinite(page.total) && page.total >= 0 ? page.total : (append ? state.total : undefined),
         metadata: page.metadata ?? (append ? state.metadata : undefined),
-        status: 'ready', loadingMore: false, pageError: false, complete: page.complete ?? !page.nextCursor };
+        status: 'ready', loadingMore: false, pageError: false, complete: page.complete ?? !page.nextCursor, provisional: false };
       loadedPages++;
     } catch (error) {
       if (disposed || generation !== revision) return;
       const clear = source.clearOnError?.(error) === true;
       // Revoked access always ends what a revalidation showed, whether or not the source clears its rows.
       clearedByError = clear || /HTTP 40[13]\b/.test(String(error));
+      if (clearedByError) lastShown = undefined;
       if (clear) loadedPages = 0;
       state = { ...state, ...(clear ? { items: [], nextCursor: '', total: undefined, metadata: undefined } : {}),
         status: append && !clear ? 'ready' : 'error', loadingMore: false, pageError: append && !clear, complete: false,
-        error: source.errorMessage?.(error) ?? '' };
+        provisional: false, error: source.errorMessage?.(error) ?? '' };
     }
     emit();
   };
@@ -117,8 +131,7 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
       const next = normalize(criteria);
       const same = JSON.stringify(next) === JSON.stringify(state.criteria);
       const count = restorePages && same ? Math.max(loadedPages, restoringPages, 1) : 1;
-      const showing = shown && shown.state.status === 'ready' && shown.state.items.length > 0 && !shown.state.pageError
-        && !shown.state.loadingMore && JSON.stringify(shown.state.criteria) === JSON.stringify(next) ? shown : undefined;
+      const showing = lastShown && sameCriteria(lastShown.state.criteria, next) ? lastShown : undefined;
       restoringPages = count;
       state = { ...state, criteria: next };
       if (revalidate && showing) { revalidating = generation + 1; clearedByError = false; }
@@ -140,6 +153,27 @@ export function createCollectionQuery<Row>(source: CollectionQuerySource<Row>, p
         emit();
       }
     },
+    /** The page the screen shows (rows ready, nothing failing or still paging), for the service to keep with its
+     *  state; undefined when it shows none. */
+    shownPage(): CollectionShownPage<Row> | undefined {
+      if (!lastShown || !sameCriteria(lastShown.state.criteria, state.criteria)) return undefined;
+      const page = lastShown.state;
+      return { state: { ...page, criteria: copyQuery(page.criteria), items: [...page.items] }, loadedPages: lastShown.loadedPages };
+    },
+    /** A cold boot restored from disk: what the last run showed becomes what this one shows, so its first `load`
+     *  revalidates behind it instead of starting empty. Only before the first query, and only a well-formed page. */
+    seed(page: unknown): boolean {
+      const candidate = page && typeof page === 'object' ? page as Partial<CollectionShownPage<Row>> : undefined;
+      const restored = candidate?.state;
+      if (generation !== 0 || state.status !== 'idle' || !restored || restored.status !== 'ready'
+        || !Array.isArray(restored.items) || restored.items.length === 0 || typeof restored.nextCursor !== 'string') return false;
+      try { restored.items.forEach(item => { if (!source.id(item)) throw new Error('A backend collection row requires an identity'); }); } catch { return false; }
+      state = { ...state, ...restored, criteria: normalize(restored.criteria ?? {}), items: [...restored.items], status: 'ready',
+        loadingMore: false, pageError: false, provisional: false, error: '' };
+      loadedPages = Math.max(1, Math.floor(Number(candidate?.loadedPages) || 1));
+      lastShown = { state: snapshot(), loadedPages };
+      return true;
+    },
     refresh: () => { restoringPages = 0; return fetch(false); },
     loadMore: () => fetch(true),
     retry: () => fetch(state.pageError),

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

@@ -142,6 +142,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // the query controller carries a recoverable failure. Treat each shape as
     // one collection state so the shared UI never renders a blank catalog.
     const backendState = backend?.controller.getState();
+    const provisional = backendState?.provisional === true;
     const errored = s.status === 'error' || s.isErrored === true || s.errored === true || backendState?.status === 'error';
     const domainError = typeof s.error === 'string' ? s.error.trim() : '';
     const queryError = typeof backendState?.error === 'string' ? backendState.error.trim() : '';
@@ -177,13 +178,17 @@ export function decorateCollection(name: string, def: { state: State; actions?:
     // un-narrowed failure. A re-query while typing keeps it (and the search field's focus).
     const hideChrome = (!narrowed && !s.nextCursor && projected.loaded < COLLECTION_CHROME_MIN_ITEMS)
       || sourceEmpty || ((loading || errored) && rows.length === 0 && !narrowed);
-    return { ...s, collection: { ...prefs, ...projected,
+    // Kept with the state, so a cold boot restored from disk shows its last page and revalidates behind it.
+    const collectionShown = backend?.controller.shownPage();
+    return { ...s, ...(backend ? { collectionShown: collectionShown ?? null } : {}), collection: { ...prefs, ...projected,
       hideChrome, noActiveCriteria: !narrowed,
       viewName, viewMessage, saveMessage, noSavedViews: prefs.savedViews.length === 0,
       cursor: s.pageError === true || s.loadingMore === true ? '' : s.nextCursor,
       noMore: !s.nextCursor || s.pageError === true || s.loadingMore === true,
       noPageError: s.pageError !== true,
-      noOffline: s.fromCache !== true,
+      // Rows read from the device ahead of the live read are shown as they are: "saved offline" is what stays on
+      // screen when the live read failed, not a first visit that is still loading.
+      noOffline: s.fromCache !== true || provisional,
       noError: !errored,
       noRetry: !canRetry || signInRequired,
       noSignIn: !signInRequired,
@@ -202,7 +207,7 @@ export function decorateCollection(name: string, def: { state: State; actions?:
       filtersPresented, previewPresented: !!previewId, preview: projected.items.filter(row => row.collectionId === previewId),
       persistenceLabel: persisted.available ? copyParam('collection.onDevice', 'Saved on this device') : copyParam('collection.sessionOnly', 'Choices last for this session'),
       noEmpty: loading || errored || sourceEmpty || domainNarrowed || projected.items.length > 0,
-      summary: backend && config.backendQuery && s.fromCache
+      summary: backend && config.backendQuery && s.fromCache && !provisional
         ? copyParam('collection.cached', 'Saved offline · may be outdated')
         : collectionSummary({ shown: projected.items.length, loaded: projected.loaded, backend: !!(backend && config.backendQuery),
           total: typeof s.total === 'number' ? s.total : undefined, noun: config.countNoun
@@ -345,6 +350,13 @@ export function defineBackendCollection<S extends object, Row extends object>(na
     apply: (state, page) => options.apply(state as S, page as unknown as CollectionQueryState<Row>) as State,
   });
   const handle = (options.register ?? register)(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.
+  const restored = (handle as { getState?: () => State }).getState?.();
+  const rowsKey = COLLECTIONS[name]?.rows;
+  const restoredRows = rowsKey ? restored?.[rowsKey] : undefined;
+  if (Array.isArray(restoredRows) && restoredRows.length > 0) controller.seed(restored?.collectionShown);
   publish = () => handle.collectionDataChanged();
   return handle;
 }

package/templates/restaurant-owner/tier5-src/himi-owner-lite-manage/index.ts

@@ -17,7 +17,7 @@ import { OWNER_MODULES, ownerModuleId } from '../_shared/owner-modules.js';
 import { localPreferences } from '../_shared/local-preferences.js';
 import { stashCopy, copyParam, copyTemplate } from '../_shared/himi-copy.js';
 import { fallbackNameFrom, selectedSiteName } from '../_shared/owner-selected-site.js';
-import { DASHBOARD_PATHS, deriveManage, parseAreas, recentAreas, rememberArea, withMetrics, type ManageArea, type Metric } from './logic.js';
+import { DASHBOARD_PATHS, deriveManage, parseAreas, recentAreas, metricFailure, rememberArea, withMetrics, type ManageArea, type Metric, type MetricFailure } from './logic.js';
 
 interface State {
   /** The business the header names: the one picked on Sites, else the descriptor's
@@ -43,7 +43,6 @@ interface State {
   noSections: boolean;
   isLoading: boolean;
   notLoading: boolean;
-  summaryNote: string;
   handoffError: string;
 }
 
@@ -242,20 +241,26 @@ async function loadMetrics(state: State): Promise<State> {
   return newestStarted ?? settled;
 }
 
+/** A row's status when its summary could not load: why, so a missing app or a denied read is not taken for a fault. */
+function failureText(failure: MetricFailure): string {
+  switch (failure) {
+    case 'notSetUp': return copyParam('ownerManage.notSetUp', 'Not set up on this site');
+    case 'noAccess': return copyParam('ownerManage.noAccess', 'No access');
+    default: return copyParam('ownerManage.summaryUnavailable', 'Couldn’t load summary');
+  }
+}
+
 async function readMetrics(state: State): Promise<State> {
   const keys = [...new Set(state.areas.map(area => area.metricKey))];
   const settled = await Promise.allSettled(keys.map(metricFor));
   const metrics: Record<string, Metric | undefined> = {};
-  const unavailable = new Set<string>();
+  const failures = new Map<string, string>();
   settled.forEach((result, index) => {
     if (result.status === 'fulfilled') metrics[keys[index]] = result.value;
-    else unavailable.add(keys[index]);
+    else failures.set(keys[index], failureText(metricFailure(result.reason)));
   });
-  const areas = withMetrics(state.areas, metrics, unavailable);
-  const note = unavailable.size
-    ? copyParam('ownerManage.partialSummary', 'Some summaries couldn’t load. You can still open every business area.')
-    : '';
-  return derive({ ...state, areas, isLoading: false, notLoading: true, summaryNote: note, handoffError: '' }, areas);
+  const areas = withMetrics(state.areas, metrics, failures);
+  return derive({ ...state, areas, isLoading: false, notLoading: true, handoffError: '' }, areas);
 }
 
 function findArea(state: State, arg: unknown): ManageArea | undefined {
@@ -294,7 +299,7 @@ const svc = defineService<State, {
     // 'All' is always a valid filter, so the chip row paints from the first frame
     // instead of appearing (and shifting the layout) when the areas arrive.
     groups: [{ id: 'all', label: allLabel() }], summary: '', noEmpty: true,
-    hasRecents: false, noRecents: true, noSections: true, isLoading: true, notLoading: false, summaryNote: '', handoffError: '',
+    hasRecents: false, noRecents: true, noSections: true, isLoading: true, notLoading: false, handoffError: '',
   },
   actions: {
     load: async (state, arg) => {
@@ -313,7 +318,7 @@ const svc = defineService<State, {
       const parsed = (() => { try { return JSON.parse(str(arg, 'areas') || '[]'); } catch { return []; } })();
       const areas = parseAreas(parsed);
       if (state.status === 'ready' && sameAreas(state.areas, areas)) return loadMetrics(revalidating(state, areas));
-      return loadMetrics(derive({ ...state, status: 'ready', areas, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }, areas));
+      return loadMetrics(derive({ ...state, status: 'ready', areas, isLoading: true, notLoading: false, handoffError: '' }, areas));
     },
     // Refresh re-reads summaries for KNOWN areas. Before the descriptor has
     // delivered them there is nothing to refresh, and settling here would open
@@ -321,7 +326,7 @@ const svc = defineService<State, {
     // it is re-read either way.
     refresh: async state => {
       currentBusinessName = selectedSiteName(fallbackBusinessName);
-      return state.status !== 'ready' ? { ...state, businessName: currentBusinessName } : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, summaryNote: '', handoffError: '' }));
+      return state.status !== 'ready' ? { ...state, businessName: currentBusinessName } : loadMetrics(derive({ ...state, isLoading: true, notLoading: false, handoffError: '' }));
     },
     search: (state, arg) => derive({ ...state, query: str(arg, 'value').slice(0, 256) }),
     filter: (state, arg) => {

package/templates/restaurant-owner/tier5-src/himi-owner-lite-manage/logic.ts

@@ -110,13 +110,26 @@ export function countText(metric: Metric, label: string): string {
   return `${count}${metric.hasMore ? "+" : ""} ${label}`;
 }
 
-/** Apply independently loaded metrics. A failed source stays visibly unknown;
- * it never becomes a misleading zero. */
-export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, unavailable: Set<string>): ManageArea[] {
+/** Why a summary could not load: the area's app is not on the site, the owner may not read it, or the read failed.
+ *  From the LEADING status only, as Today reads it (`isSectionUnavailable`): a transient
+ *  `HTTP 503: {"message":"upstream returned 404"}` is a failure, not a missing app. */
+export type MetricFailure = "notSetUp" | "noAccess" | "failed";
+
+export function metricFailure(error: unknown): MetricFailure {
+  const text = String((error as Error)?.message ?? error);
+  if (/^HTTP (?:404|428)\b/.test(text) || /^HTTP \d{3} \[FAILED_PRECONDITION\]/.test(text)) return "notSetUp";
+  if (/^HTTP 403\b/.test(text) || /^HTTP \d{3} \[PERMISSION_DENIED\]/.test(text)) return "noAccess";
+  return "failed";
+}
+
+/** Apply independently loaded metrics. A failed source stays visibly unknown, saying why on its own row
+ * ([failures]: metric key → that row's status); it never becomes a misleading zero. */
+export function withMetrics(areas: ManageArea[], metrics: Record<string, Metric | undefined>, failures: Map<string, string>): ManageArea[] {
   return areas.map(area => {
     const metric = metrics[area.metricKey];
-    if (!metric || unavailable.has(area.metricKey)) {
-      return { ...area, metricText: "—", statusText: "Couldn’t load summary", unavailable: true };
+    const failure = failures.get(area.metricKey);
+    if (!metric || failure !== undefined) {
+      return { ...area, metricText: "—", statusText: failure ?? "", unavailable: true };
     }
     return {
       ...area,