@wix/himalaya-cli 0.862.0 → 0.863.0

package/templates/retail-store/tier5-src/_shared/home-modules.ts

@@ -1,7 +1,33 @@
 /** Bounded OTA home composition. Module ids, eligibility and defaults are
  * supplied by the signed descriptor; personal state cannot introduce content. */
-export interface HomeModule { id: string; label: string; dataSource: string; }
+/** `emptyWhen` — state keys that ALL have to be truthy for the module to have nothing
+ *  to paint. Derived from the descriptor's own `hiddenPath` gates (see
+ *  `emptyWhenOf` in home-modules-screen.ts), never hand-maintained.
+ *
+ *  It exists because "visible" had two independent meanings that never met: the user's
+ *  preference (this list) and the content's own `hiddenWhen` gates. A module the user
+ *  keeps but whose content self-hides still occupied a row, and the list's spacing is
+ *  applied per ROW — so a signed-out home left four empty rows and a ~95px hole above
+ *  the first real section. The same arithmetic runs in SwiftUI/Compose VStack spacing,
+ *  which is why this is filtered in the worker rather than patched in one renderer. */
+export interface HomeModule { id: string; label: string; dataSource: string; emptyWhen?: string[]; }
 export interface HomePreferences { order: string[]; hidden: string[]; pinned: string[]; }
+/** Mirror of the renderers' hidden-gate truthiness (`hiddenBool` on web,
+ *  `ReactiveHiddenGate.boolOf` on native): bool → itself; number ≠ 0; "true"/"1"
+ *  case-insensitively. Anything else — including undefined — is NOT hidden, so an
+ *  unknown key can only ever keep a module on screen. */
+export function hiddenFlag(v: unknown): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') { const l = v.trim().toLowerCase(); return l === 'true' || l === '1'; }
+  return false;
+}
+/** True when every one of the module's gates is currently hidden, i.e. it would render
+ *  an empty row. A module with no declared gates is never empty. */
+export function moduleIsEmpty(module: HomeModule, state: Record<string, unknown>): boolean {
+  const gates = module.emptyWhen;
+  return Array.isArray(gates) && gates.length > 0 && gates.every(key => hiddenFlag(state[key]));
+}
 export function normalizeHome(modules: HomeModule[], value?: Partial<HomePreferences>): HomePreferences {
   const ids = modules.map(module => module.id);
   const valid = (items: unknown): string[] => Array.isArray(items) ? [...new Set(items.filter((id): id is string => typeof id === 'string' && ids.includes(id)))] : [];

package/templates/retail-store/tier5-src/_shared/home-service.ts

@@ -1,5 +1,5 @@
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
-import { normalizeHome, visibleHome, type HomeModule, type HomePreferences } from './home-modules.js';
+import { normalizeHome, visibleHome, moduleIsEmpty, type HomeModule, type HomePreferences } from './home-modules.js';
 import { copyParam, stashCopy } from './himi-copy.js';
 import { localPreferences } from './local-preferences.js';
 type State = Record<string, unknown>;
@@ -18,8 +18,18 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
   let prefs: HomePreferences = normalizeHome([]);
   let presented = false;
   const derive = (s: State): State => {
+    // Two filters, and they answer different questions. `visibleHome` is what the USER
+    // chose to keep; `moduleIsEmpty` is whether the module has anything to paint right
+    // now. A row that passes the first and fails the second still costs the list its
+    // inter-row spacing on every renderer, which is the ~95px hole a signed-out home
+    // used to show. `slots` keeps the unfiltered order so a module that fills up later
+    // returns to the same place rather than jumping to the end.
     const order = visibleHome(prefs);
-    return { ...s, homeModules: { presented, visible: order.map(id => ({ id })),
+    const painted = order.filter(id => {
+      const module = modules.find(m => m.id === id);
+      return !module || !moduleIsEmpty(module, s);
+    });
+    return { ...s, homeModules: { presented, visible: painted.map(id => ({ id })),
       persistenceLabel: persisted.available ? copyParam('homeModules.onDevice', 'Saved on this device') : copyParam('homeModules.sessionOnly', 'Choices last for this session'),
       slots: Object.fromEntries(modules.map((_, i) => [`slot${i}`, order[i] ?? 'empty'])),
       choices: prefs.order.map(id => ({ ...modules.find(module => module.id === id),
@@ -35,7 +45,17 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
       try {
         const parsed: unknown = JSON.parse(arg.homeModules);
         if (Array.isArray(parsed)) {
-          modules = parsed.filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string').slice(0, 5);
+          modules = parsed
+            .filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string')
+            .slice(0, 5)
+            // Same shape rule as the ids above: a gate is a plain state key, never a
+            // path. Anything else is dropped, which can only leave a module ON screen.
+            .map(module => {
+              const gates = Array.isArray(module.emptyWhen)
+                ? module.emptyWhen.filter((k): k is string => typeof k === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,60}$/.test(k))
+                : [];
+              return gates.length ? { ...module, emptyWhen: gates } : { ...module, emptyWhen: undefined };
+            });
           prefs = normalizeHome(modules, receivedRegistry ? prefs : restored);
           receivedRegistry = true;
         }

package/templates/retail-store-owner/dev/index.ts

@@ -49593,7 +49593,7 @@ const SCREENS = runtimeSetting({
           "actionId": "tier5.himiOwnerLiteHome.load",
           "params": {
             "copy": "{\"ownerHome.acrossBusiness\":\"Across the shop\",\"ownerHome.briefCta\":\"Show me what’s waiting\",\"ownerHome.briefSubtitle\":\"Orders waiting to be packed, payments that never landed, and the lines that have run out.\",\"ownerHome.briefTitle\":\"Back office\",\"ownerHome.errorLabel\":\"Couldn’t load the back office\",\"ownerHome.headerSubtitle\":\"Shop owner · back office\",\"ownerHome.openManage\":\"Open the shop\",\"ownerHome.ordersDaily\":\"Orders · daily\",\"ownerHome.statOrders\":\"Orders\",\"ownerHome.statPosts\":\"Shop journal\",\"ownerHome.statProducts\":\"Catalog lines\",\"ownerHome.statRevenue\":\"Revenue\",\"ownerHome.statSites\":\"Shops\",\"ownerHome.switchBusiness\":\"Switch shop\"}",
-            "homeModules": "[{\"id\":\"attention\",\"label\":\"Needs attention\",\"dataSource\":\"owner-today\"},{\"id\":\"schedule\",\"label\":\"Up next\",\"dataSource\":\"owner-schedule\"},{\"id\":\"shortcuts\",\"label\":\"Quick actions\",\"dataSource\":\"owner-actions\"},{\"id\":\"metrics\",\"label\":\"Business overview\",\"dataSource\":\"dashboard\"},{\"id\":\"brief\",\"label\":\"Daily brief\",\"dataSource\":\"brief\"}]",
+            "homeModules": "[{\"id\":\"attention\",\"label\":\"Needs attention\",\"dataSource\":\"owner-today\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"schedule\",\"label\":\"Up next\",\"dataSource\":\"owner-schedule\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"shortcuts\",\"label\":\"Quick actions\",\"dataSource\":\"owner-actions\"},{\"id\":\"metrics\",\"label\":\"Business overview\",\"dataSource\":\"dashboard\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"brief\",\"label\":\"Daily brief\",\"dataSource\":\"brief\"}]",
             "enabledSources": "[\"products\",\"posts\",\"sites\",\"orders\",\"members\",\"reviews\",\"reservations\"]"
           }
         }

package/templates/retail-store-owner/tier5-src/_shared/home-modules.ts

@@ -1,7 +1,33 @@
 /** Bounded OTA home composition. Module ids, eligibility and defaults are
  * supplied by the signed descriptor; personal state cannot introduce content. */
-export interface HomeModule { id: string; label: string; dataSource: string; }
+/** `emptyWhen` — state keys that ALL have to be truthy for the module to have nothing
+ *  to paint. Derived from the descriptor's own `hiddenPath` gates (see
+ *  `emptyWhenOf` in home-modules-screen.ts), never hand-maintained.
+ *
+ *  It exists because "visible" had two independent meanings that never met: the user's
+ *  preference (this list) and the content's own `hiddenWhen` gates. A module the user
+ *  keeps but whose content self-hides still occupied a row, and the list's spacing is
+ *  applied per ROW — so a signed-out home left four empty rows and a ~95px hole above
+ *  the first real section. The same arithmetic runs in SwiftUI/Compose VStack spacing,
+ *  which is why this is filtered in the worker rather than patched in one renderer. */
+export interface HomeModule { id: string; label: string; dataSource: string; emptyWhen?: string[]; }
 export interface HomePreferences { order: string[]; hidden: string[]; pinned: string[]; }
+/** Mirror of the renderers' hidden-gate truthiness (`hiddenBool` on web,
+ *  `ReactiveHiddenGate.boolOf` on native): bool → itself; number ≠ 0; "true"/"1"
+ *  case-insensitively. Anything else — including undefined — is NOT hidden, so an
+ *  unknown key can only ever keep a module on screen. */
+export function hiddenFlag(v: unknown): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') { const l = v.trim().toLowerCase(); return l === 'true' || l === '1'; }
+  return false;
+}
+/** True when every one of the module's gates is currently hidden, i.e. it would render
+ *  an empty row. A module with no declared gates is never empty. */
+export function moduleIsEmpty(module: HomeModule, state: Record<string, unknown>): boolean {
+  const gates = module.emptyWhen;
+  return Array.isArray(gates) && gates.length > 0 && gates.every(key => hiddenFlag(state[key]));
+}
 export function normalizeHome(modules: HomeModule[], value?: Partial<HomePreferences>): HomePreferences {
   const ids = modules.map(module => module.id);
   const valid = (items: unknown): string[] => Array.isArray(items) ? [...new Set(items.filter((id): id is string => typeof id === 'string' && ids.includes(id)))] : [];

package/templates/retail-store-owner/tier5-src/_shared/home-service.ts

@@ -1,5 +1,5 @@
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
-import { normalizeHome, visibleHome, type HomeModule, type HomePreferences } from './home-modules.js';
+import { normalizeHome, visibleHome, moduleIsEmpty, type HomeModule, type HomePreferences } from './home-modules.js';
 import { copyParam, stashCopy } from './himi-copy.js';
 import { localPreferences } from './local-preferences.js';
 type State = Record<string, unknown>;
@@ -18,8 +18,18 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
   let prefs: HomePreferences = normalizeHome([]);
   let presented = false;
   const derive = (s: State): State => {
+    // Two filters, and they answer different questions. `visibleHome` is what the USER
+    // chose to keep; `moduleIsEmpty` is whether the module has anything to paint right
+    // now. A row that passes the first and fails the second still costs the list its
+    // inter-row spacing on every renderer, which is the ~95px hole a signed-out home
+    // used to show. `slots` keeps the unfiltered order so a module that fills up later
+    // returns to the same place rather than jumping to the end.
     const order = visibleHome(prefs);
-    return { ...s, homeModules: { presented, visible: order.map(id => ({ id })),
+    const painted = order.filter(id => {
+      const module = modules.find(m => m.id === id);
+      return !module || !moduleIsEmpty(module, s);
+    });
+    return { ...s, homeModules: { presented, visible: painted.map(id => ({ id })),
       persistenceLabel: persisted.available ? copyParam('homeModules.onDevice', 'Saved on this device') : copyParam('homeModules.sessionOnly', 'Choices last for this session'),
       slots: Object.fromEntries(modules.map((_, i) => [`slot${i}`, order[i] ?? 'empty'])),
       choices: prefs.order.map(id => ({ ...modules.find(module => module.id === id),
@@ -35,7 +45,17 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
       try {
         const parsed: unknown = JSON.parse(arg.homeModules);
         if (Array.isArray(parsed)) {
-          modules = parsed.filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string').slice(0, 5);
+          modules = parsed
+            .filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string')
+            .slice(0, 5)
+            // Same shape rule as the ids above: a gate is a plain state key, never a
+            // path. Anything else is dropped, which can only leave a module ON screen.
+            .map(module => {
+              const gates = Array.isArray(module.emptyWhen)
+                ? module.emptyWhen.filter((k): k is string => typeof k === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,60}$/.test(k))
+                : [];
+              return gates.length ? { ...module, emptyWhen: gates } : { ...module, emptyWhen: undefined };
+            });
           prefs = normalizeHome(modules, receivedRegistry ? prefs : restored);
           receivedRegistry = true;
         }

package/templates/yoga-studio/dev/index.ts

@@ -2287,7 +2287,7 @@ const SCREENS = runtimeSetting({
           "actionId": "tier5.himiBrandedHome.refresh",
           "params": {
             "verticals": "[\"bookings\",\"programs\",\"plans\",\"events\",\"blog\"]",
-            "homeModules": "[{\"id\":\"member_progress\",\"label\":\"Today's schedule\",\"dataSource\":\"member.bookings.schedule\"},{\"id\":\"up_next\",\"label\":\"Up next\",\"dataSource\":\"member.bookings\"},{\"id\":\"saved\",\"label\":\"Saved on this device\",\"dataSource\":\"device.saved_items\"},{\"id\":\"section_0\",\"label\":\"Today's schedule\",\"dataSource\":\"calmStudio.section0\"},{\"id\":\"section_1\",\"label\":\"Your practice\",\"dataSource\":\"calmStudio.section1\"}]",
+            "homeModules": "[{\"id\":\"member_progress\",\"label\":\"Today's schedule\",\"dataSource\":\"member.bookings.schedule\",\"emptyWhen\":[\"hideMemberProgress\"]},{\"id\":\"up_next\",\"label\":\"Up next\",\"dataSource\":\"member.bookings\",\"emptyWhen\":[\"hideNextBooking\",\"hidePersonalError\"]},{\"id\":\"saved\",\"label\":\"Saved on this device\",\"dataSource\":\"device.saved_items\",\"emptyWhen\":[\"noSavedContent\"]},{\"id\":\"section_0\",\"label\":\"Today's schedule\",\"dataSource\":\"calmStudio.section0\",\"emptyWhen\":[\"noTodaysClasses\"]},{\"id\":\"section_1\",\"label\":\"Your practice\",\"dataSource\":\"calmStudio.section1\"}]",
             "ownerDefaultLayout": "calmStudio",
             "brandAccent": "#5F7360",
             "copy": "{\"home.bookClassCta\":\"Reserve your spot\",\"home.onboardingBody\":\"Reserve classes, follow programs, and join retreats — all from one calm place.\",\"home.practiceTitle\":\"Your practice\",\"home.retreatsTitle\":\"Retreats & workshops\",\"home.scheduleTitle\":\"Today's schedule\",\"home.teachersCaption\":\"Your teachers\"}"

package/templates/yoga-studio/tier5-src/_shared/home-modules.ts

@@ -1,7 +1,33 @@
 /** Bounded OTA home composition. Module ids, eligibility and defaults are
  * supplied by the signed descriptor; personal state cannot introduce content. */
-export interface HomeModule { id: string; label: string; dataSource: string; }
+/** `emptyWhen` — state keys that ALL have to be truthy for the module to have nothing
+ *  to paint. Derived from the descriptor's own `hiddenPath` gates (see
+ *  `emptyWhenOf` in home-modules-screen.ts), never hand-maintained.
+ *
+ *  It exists because "visible" had two independent meanings that never met: the user's
+ *  preference (this list) and the content's own `hiddenWhen` gates. A module the user
+ *  keeps but whose content self-hides still occupied a row, and the list's spacing is
+ *  applied per ROW — so a signed-out home left four empty rows and a ~95px hole above
+ *  the first real section. The same arithmetic runs in SwiftUI/Compose VStack spacing,
+ *  which is why this is filtered in the worker rather than patched in one renderer. */
+export interface HomeModule { id: string; label: string; dataSource: string; emptyWhen?: string[]; }
 export interface HomePreferences { order: string[]; hidden: string[]; pinned: string[]; }
+/** Mirror of the renderers' hidden-gate truthiness (`hiddenBool` on web,
+ *  `ReactiveHiddenGate.boolOf` on native): bool → itself; number ≠ 0; "true"/"1"
+ *  case-insensitively. Anything else — including undefined — is NOT hidden, so an
+ *  unknown key can only ever keep a module on screen. */
+export function hiddenFlag(v: unknown): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') { const l = v.trim().toLowerCase(); return l === 'true' || l === '1'; }
+  return false;
+}
+/** True when every one of the module's gates is currently hidden, i.e. it would render
+ *  an empty row. A module with no declared gates is never empty. */
+export function moduleIsEmpty(module: HomeModule, state: Record<string, unknown>): boolean {
+  const gates = module.emptyWhen;
+  return Array.isArray(gates) && gates.length > 0 && gates.every(key => hiddenFlag(state[key]));
+}
 export function normalizeHome(modules: HomeModule[], value?: Partial<HomePreferences>): HomePreferences {
   const ids = modules.map(module => module.id);
   const valid = (items: unknown): string[] => Array.isArray(items) ? [...new Set(items.filter((id): id is string => typeof id === 'string' && ids.includes(id)))] : [];

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

@@ -1,5 +1,5 @@
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
-import { normalizeHome, visibleHome, type HomeModule, type HomePreferences } from './home-modules.js';
+import { normalizeHome, visibleHome, moduleIsEmpty, type HomeModule, type HomePreferences } from './home-modules.js';
 import { copyParam, stashCopy } from './himi-copy.js';
 import { localPreferences } from './local-preferences.js';
 type State = Record<string, unknown>;
@@ -18,8 +18,18 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
   let prefs: HomePreferences = normalizeHome([]);
   let presented = false;
   const derive = (s: State): State => {
+    // Two filters, and they answer different questions. `visibleHome` is what the USER
+    // chose to keep; `moduleIsEmpty` is whether the module has anything to paint right
+    // now. A row that passes the first and fails the second still costs the list its
+    // inter-row spacing on every renderer, which is the ~95px hole a signed-out home
+    // used to show. `slots` keeps the unfiltered order so a module that fills up later
+    // returns to the same place rather than jumping to the end.
     const order = visibleHome(prefs);
-    return { ...s, homeModules: { presented, visible: order.map(id => ({ id })),
+    const painted = order.filter(id => {
+      const module = modules.find(m => m.id === id);
+      return !module || !moduleIsEmpty(module, s);
+    });
+    return { ...s, homeModules: { presented, visible: painted.map(id => ({ id })),
       persistenceLabel: persisted.available ? copyParam('homeModules.onDevice', 'Saved on this device') : copyParam('homeModules.sessionOnly', 'Choices last for this session'),
       slots: Object.fromEntries(modules.map((_, i) => [`slot${i}`, order[i] ?? 'empty'])),
       choices: prefs.order.map(id => ({ ...modules.find(module => module.id === id),
@@ -35,7 +45,17 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
       try {
         const parsed: unknown = JSON.parse(arg.homeModules);
         if (Array.isArray(parsed)) {
-          modules = parsed.filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string').slice(0, 5);
+          modules = parsed
+            .filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string')
+            .slice(0, 5)
+            // Same shape rule as the ids above: a gate is a plain state key, never a
+            // path. Anything else is dropped, which can only leave a module ON screen.
+            .map(module => {
+              const gates = Array.isArray(module.emptyWhen)
+                ? module.emptyWhen.filter((k): k is string => typeof k === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,60}$/.test(k))
+                : [];
+              return gates.length ? { ...module, emptyWhen: gates } : { ...module, emptyWhen: undefined };
+            });
           prefs = normalizeHome(modules, receivedRegistry ? prefs : restored);
           receivedRegistry = true;
         }

package/templates/yoga-studio-owner/dev/index.ts

@@ -49385,7 +49385,7 @@ const SCREENS = runtimeSetting({
           "actionId": "tier5.himiOwnerLiteHome.load",
           "params": {
             "copy": "{\"ownerHome.acrossBusiness\":\"Across the studio\",\"ownerHome.briefCta\":\"Show me today\",\"ownerHome.briefSubtitle\":\"Which classes have space on the mat, who is booked in, and whether the next retreat still needs filling.\",\"ownerHome.briefTitle\":\"Today’s schedule\",\"ownerHome.errorLabel\":\"Couldn’t load today’s schedule\",\"ownerHome.headerSubtitle\":\"Studio owner · today’s schedule\",\"ownerHome.openManage\":\"Open the studio\",\"ownerHome.statAppointments\":\"Students booked in\",\"ownerHome.statEvents\":\"Workshops & retreats\",\"ownerHome.statPosts\":\"Studio journal\",\"ownerHome.statSites\":\"Studios\",\"ownerHome.switchBusiness\":\"Switch studio\"}",
-            "homeModules": "[{\"id\":\"attention\",\"label\":\"Needs attention\",\"dataSource\":\"owner-today\"},{\"id\":\"schedule\",\"label\":\"Up next\",\"dataSource\":\"owner-schedule\"},{\"id\":\"shortcuts\",\"label\":\"Quick actions\",\"dataSource\":\"owner-actions\"},{\"id\":\"metrics\",\"label\":\"Business overview\",\"dataSource\":\"dashboard\"},{\"id\":\"brief\",\"label\":\"Daily brief\",\"dataSource\":\"brief\"}]",
+            "homeModules": "[{\"id\":\"attention\",\"label\":\"Needs attention\",\"dataSource\":\"owner-today\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"schedule\",\"label\":\"Up next\",\"dataSource\":\"owner-schedule\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"shortcuts\",\"label\":\"Quick actions\",\"dataSource\":\"owner-actions\"},{\"id\":\"metrics\",\"label\":\"Business overview\",\"dataSource\":\"dashboard\",\"emptyWhen\":[\"hideContent\"]},{\"id\":\"brief\",\"label\":\"Daily brief\",\"dataSource\":\"brief\"}]",
             "enabledSources": "[\"posts\",\"sites\",\"bookings\",\"events\",\"members\",\"reviews\",\"reservations\"]"
           }
         }

package/templates/yoga-studio-owner/tier5-src/_shared/home-modules.ts

@@ -1,7 +1,33 @@
 /** Bounded OTA home composition. Module ids, eligibility and defaults are
  * supplied by the signed descriptor; personal state cannot introduce content. */
-export interface HomeModule { id: string; label: string; dataSource: string; }
+/** `emptyWhen` — state keys that ALL have to be truthy for the module to have nothing
+ *  to paint. Derived from the descriptor's own `hiddenPath` gates (see
+ *  `emptyWhenOf` in home-modules-screen.ts), never hand-maintained.
+ *
+ *  It exists because "visible" had two independent meanings that never met: the user's
+ *  preference (this list) and the content's own `hiddenWhen` gates. A module the user
+ *  keeps but whose content self-hides still occupied a row, and the list's spacing is
+ *  applied per ROW — so a signed-out home left four empty rows and a ~95px hole above
+ *  the first real section. The same arithmetic runs in SwiftUI/Compose VStack spacing,
+ *  which is why this is filtered in the worker rather than patched in one renderer. */
+export interface HomeModule { id: string; label: string; dataSource: string; emptyWhen?: string[]; }
 export interface HomePreferences { order: string[]; hidden: string[]; pinned: string[]; }
+/** Mirror of the renderers' hidden-gate truthiness (`hiddenBool` on web,
+ *  `ReactiveHiddenGate.boolOf` on native): bool → itself; number ≠ 0; "true"/"1"
+ *  case-insensitively. Anything else — including undefined — is NOT hidden, so an
+ *  unknown key can only ever keep a module on screen. */
+export function hiddenFlag(v: unknown): boolean {
+  if (typeof v === 'boolean') return v;
+  if (typeof v === 'number') return v !== 0;
+  if (typeof v === 'string') { const l = v.trim().toLowerCase(); return l === 'true' || l === '1'; }
+  return false;
+}
+/** True when every one of the module's gates is currently hidden, i.e. it would render
+ *  an empty row. A module with no declared gates is never empty. */
+export function moduleIsEmpty(module: HomeModule, state: Record<string, unknown>): boolean {
+  const gates = module.emptyWhen;
+  return Array.isArray(gates) && gates.length > 0 && gates.every(key => hiddenFlag(state[key]));
+}
 export function normalizeHome(modules: HomeModule[], value?: Partial<HomePreferences>): HomePreferences {
   const ids = modules.map(module => module.id);
   const valid = (items: unknown): string[] => Array.isArray(items) ? [...new Set(items.filter((id): id is string => typeof id === 'string' && ids.includes(id)))] : [];

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

@@ -1,5 +1,5 @@
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
-import { normalizeHome, visibleHome, type HomeModule, type HomePreferences } from './home-modules.js';
+import { normalizeHome, visibleHome, moduleIsEmpty, type HomeModule, type HomePreferences } from './home-modules.js';
 import { copyParam, stashCopy } from './himi-copy.js';
 import { localPreferences } from './local-preferences.js';
 type State = Record<string, unknown>;
@@ -18,8 +18,18 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
   let prefs: HomePreferences = normalizeHome([]);
   let presented = false;
   const derive = (s: State): State => {
+    // Two filters, and they answer different questions. `visibleHome` is what the USER
+    // chose to keep; `moduleIsEmpty` is whether the module has anything to paint right
+    // now. A row that passes the first and fails the second still costs the list its
+    // inter-row spacing on every renderer, which is the ~95px hole a signed-out home
+    // used to show. `slots` keeps the unfiltered order so a module that fills up later
+    // returns to the same place rather than jumping to the end.
     const order = visibleHome(prefs);
-    return { ...s, homeModules: { presented, visible: order.map(id => ({ id })),
+    const painted = order.filter(id => {
+      const module = modules.find(m => m.id === id);
+      return !module || !moduleIsEmpty(module, s);
+    });
+    return { ...s, homeModules: { presented, visible: painted.map(id => ({ id })),
       persistenceLabel: persisted.available ? copyParam('homeModules.onDevice', 'Saved on this device') : copyParam('homeModules.sessionOnly', 'Choices last for this session'),
       slots: Object.fromEntries(modules.map((_, i) => [`slot${i}`, order[i] ?? 'empty'])),
       choices: prefs.order.map(id => ({ ...modules.find(module => module.id === id),
@@ -35,7 +45,17 @@ export function decorateHome(def: { state: State; actions?: Record<string, Actio
       try {
         const parsed: unknown = JSON.parse(arg.homeModules);
         if (Array.isArray(parsed)) {
-          modules = parsed.filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string').slice(0, 5);
+          modules = parsed
+            .filter((m): m is HomeModule => typeof m?.id === 'string' && /^[a-z][a-z0-9_-]{0,40}$/.test(m.id) && typeof m.label === 'string')
+            .slice(0, 5)
+            // Same shape rule as the ids above: a gate is a plain state key, never a
+            // path. Anything else is dropped, which can only leave a module ON screen.
+            .map(module => {
+              const gates = Array.isArray(module.emptyWhen)
+                ? module.emptyWhen.filter((k): k is string => typeof k === 'string' && /^[A-Za-z][A-Za-z0-9_]{0,60}$/.test(k))
+                : [];
+              return gates.length ? { ...module, emptyWhen: gates } : { ...module, emptyWhen: undefined };
+            });
           prefs = normalizeHome(modules, receivedRegistry ? prefs : restored);
           receivedRegistry = true;
         }