@wix/himalaya-cli 0.859.0 → 0.861.0

package/guides/himi-test.md

@@ -315,11 +315,30 @@ the relations held.
 
 - **Measured, not asserted.** A committed kill-rate benchmark records what fraction of planted,
   realistic reducer bugs the crawl actually catches, per bug class, and every new check has to move
-  that number. Today it is **13.6%** (11 of 81 planted bugs across 25 content dirs), and the table
-  is as useful for what it misses as for what it catches: bugs that produce an *implausible* value
-  — a crash, a stuck skeleton, a `NaN` — are caught, while bugs that produce a *plausible wrong
-  value*, such as reading the wrong key off a response or a total off by one, are caught 0 of 34
-  times. A green run means no invariant fired, not that the app is correct.
+  that number. It is **31 of 269 = 11.5%** across all 48 content dirs, and the table is as useful
+  for what it misses as for what it catches. Most of the checks judge a *single settled state* and
+  look there for an *implausible* value — a crash, a stuck skeleton, a `NaN` — so a bug that
+  produces a plausible wrong one walks straight past them: a total off by one is 0/32, the wrong
+  row dropped 0/27. What reaches a plausible wrong value is the smaller set of checks that compare
+  two states instead of judging one — the relational axis (an action against the action that
+  undoes it, a refresh against a fresh boot) and `typed-value-ignored`, which fires when a dispatch
+  carrying a real payload changes nothing at all. That last one is what moved `wrong-key` to 12/48,
+  by typing the value a UI control actually carries so the half of each reducer that reads its
+  payload finally runs. A green run means no invariant fired, not that the app is correct.
+
+  The benchmark also carries a `control-throw` row at 48/48, and it is **excluded from the rate on
+  purpose**: a planted `throw` is caught by construction, so counting it would inflate the figure
+  with a class that can never move. It is the harness checking itself — anything below 100% there
+  means the run stopped dispatching and no other number in the table should be believed. Read it as
+  the harness's self-test — never as evidence that the crawl catches crashes in your app.
+
+  Two things about that number are worth knowing, because both were learned the hard way. It was
+  published as 13.6% (11 of 81) until that denominator turned out to omit a whole bug class, and it
+  was measured over 25 sample apps until the starter templates `himi init --template` ships — the
+  23 a customer actually adopts, and 97% of the benchmark's worker *files* (90% of its code) —
+  turned out never to have been in it at all. Measured over the code customers ship, the crawl is roughly half as effective
+  as the sample apps suggested. This page carries the current figure; treat one quoted anywhere
+  else, including in a dated release note, as the number on the day it was written.
 - **Zero false positives, corpus-proven.** Held across every sweep of the 40+ app corpus —
   except `poll-action-missing`, which ships at `error` without corpus evidence behind it
   (see the exception noted under "What it checks" above).

package/guides/mobile-ux.md

@@ -115,8 +115,10 @@ errors block readiness; record tool-coverage limits separately.
 
 ## Evidence
 
-- Render compact (320/360), phone, and expanded widths. Record whether a one-column expanded
-  layout is intentional or the screen adapts.
+- Render each screen at a phone width, at the narrowest width you support, and again at a width
+  past the 600px breakpoint. `himi render <screen> --width 320` then `--width 834` writes both
+  into `.himi/ux-audit.json`, which is what this marker grades. Record whether a one-column
+  layout at the wider size is intentional or the screen adapts.
 - Exercise typed input, submit, completion, cancel/back, and any destructive action; record
   confirmation, undo, or recovery.
 - Drive iOS back/cancel, keyboard submit, Dynamic Type, and VoiceOver; drive Android system Back,
@@ -143,8 +145,11 @@ itself the evidence — see the strict audit contract.
 
 **Two commands read this contract.** `himi validate` reports a gap as a **warning**, so a rewrite
 that drops something the gate needs is caught in the loop you are already running rather than at
-the end of it. `himi validate --strict` and `himi ux audit --strict` both promote that warning to a
-**release blocker**. Both read the same markers. The two HEADINGS are matched verbatim — other
+the end of it. `himi ux audit --strict` promotes every gap to a **release blocker**.
+`himi validate --strict` promotes the structural ones — the two headings and the one-CTA rule — but
+deliberately leaves **width evidence** a warning: a package that has not rendered yet would
+otherwise fail strict validation the moment it is scaffolded, so that gap is the evidence gate's to
+refuse. Both read the same markers. The two HEADINGS are matched verbatim — other
 tooling addresses the document by them, so a heading really is the thing itself:
 
 - The heading `## Implementation acceptance`.
@@ -229,8 +234,11 @@ tried in this order:
   icon-834.png` pass. The marker is permissive there on purpose. A gate that rejects real work
   costs build loops; a permissive one costs a line of prose, and a card or drawer width always
   passed anyway.
-- Or keep the scaffold's own sentence, `compact (320/360)` followed later by `expanded`, which is
-  still accepted as-is. The two **may wrap across lines** — the check is not line-based — but
+- Or, in a package scaffolded before #2590, keep the legacy scaffold sentence,
+  `compact (320/360)` followed later by `expanded`, which is still accepted as-is. The template
+  stopped shipping that sentence in #2590 — it satisfied this marker on a package that had
+  rendered nothing — so a newer scaffold does not carry it, and adding it by hand claims evidence
+  you may not have. The two **may wrap across lines** — the check is not line-based — but
   `expanded` must follow within about 400 characters, so keep them in the same sentence or bullet
   rather than in separate sections.
 

package/guides/owner-lite-site-binding.md

@@ -23,6 +23,11 @@ Source of truth: `apps/himi-owner-lite/config.ts`. A management app that rendere
 knowing *which owner* is looking at it would be showing someone else's business, which is why
 the gate fails closed rather than falling back to a visitor.
 
+The Sites List is the Tier-5 `himi-owner-lite-sites` worker. Its `pick` action calls
+`site.setActiveSite(msid)` and waits for the site-scoped signed instance before the selected
+business is used by subsequent management screens. The worker also clears the Stores catalog
+version around the switch so a catalog resolved for one business is not reused for another.
+
 ## What owner-lite *does* read
 
 Verified against `apps/himi-owner-lite/config.ts` — if a variable is not in this table, owner-lite

package/guides/release-notes.md

@@ -172,12 +172,19 @@ areas, always in the same order, so you can skim for the one you care about.
   the behavioural crawl over any error-level lint issue, and skipped typed journeys entirely while
   still reporting a pass. (#2392)
 - **The `himi test` reference now states what a green run does and does not prove.** A benchmark
-  plants realistic reducer bugs and measures the fraction the crawl catches, per bug class — 13.6%
-  today. The useful half is where it is zero: bugs that produce an *implausible* value (a crash, a
-  stuck skeleton, a `NaN`) are caught, while bugs that produce a *plausible wrong value*, such as
-  reading the wrong key off a response or a total off by one, are caught 0 of 34 times. A green run
-  means no invariant fired, not that your app is correct. The figure comes from that benchmark, not
-  from your own runs — `himi test` output is unchanged. (#2402)
+  plants realistic reducer bugs and measures the fraction the crawl catches, per bug class. The
+  useful half is where it is low: bugs that produce an *implausible* value (a crash, a stuck
+  skeleton, a `NaN`) are caught, while bugs that produce a *plausible wrong value* — a total off by
+  one, the wrong row dropped — largely are not. A green run means no invariant fired, not that your
+  app is correct. The figure comes from that benchmark, not from your own runs — `himi test` output
+  is unchanged. (#2402)
+
+  This entry no longer quotes the rate, and that is deliberate. It said "13.6% today", a figure
+  corrected shortly afterwards for omitting a whole bug class and moved several times since by
+  changes to the corpus and the oracles — so a reader calibrating how far to trust a green run was
+  reading a number that was both wrong and getting wronger. A dated note cannot stay right about a
+  live measurement. `himi docs himi-test` carries the current figure, how it was measured, and the
+  corrections behind it.
 - **`himi validate` no longer answers `ok: true` after a CMS check that never ran.** An unloadable
   `config.ts` was swallowed, the CMS pass returned nothing, and validation reported success. (#2389)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.859.0",
+  "version": "0.861.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -63,5 +63,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "d7b917e8cde66a4d5863631ca5f5de90316a307fb73e854c63310248"
+  "falconPackageHash": "2d77c6f215930baecdc2a1637d6fb8dd37e4a6ba32421c3a31e94a16"
 }

package/templates/beauty-salon-owner/tier5-src/himi-owner-lite-analytics/report.ts

@@ -181,11 +181,22 @@ function subjectLabelOf(m: SemanticModelSummary): string {
  * renders as a dash rather than as 0. `formatNumber` and not `toLocaleString`,
  * which is ECMA-402 and absent on QuickJS-ng (watchOS/Wear OS).
  */
+/**
+ * The one placeholder a cell falls back to when there is nothing to render.
+ *
+ * Named, because two things depend on it meaning exactly one thing: `cellText`
+ * produces it, and `runQuery` asks whether the server's total came back as it —
+ * which is how "the owner asked for a total and got a dash" is told apart from
+ * "the server answered". Spelling it twice let those two drift apart once
+ * already.
+ */
+const DASH = "\u2014";
+
 function cellText(v: SemanticValue | undefined): string {
-  if (!v) return "—";
+  if (!v) return DASH;
   if (v.formatted !== undefined && v.formatted !== "") return v.formatted;
   const raw = v.value;
-  if (raw === null || raw === undefined) return "—";
+  if (raw === null || raw === undefined) return DASH;
   if (typeof raw === "number") return formatNumber(raw);
   if (typeof raw === "boolean") return raw ? "Yes" : "No";
   if (typeof raw === "string") return raw;
@@ -387,6 +398,23 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? copyParam("ownerReport.missingFields", "No data returned for: ") + result.missingFields.join(", ")
       : "";
 
+    // Did the SERVER actually answer with a total for the measure asked for?
+    // This is NOT the same question as "is a totals row on screen": the row is
+    // rendered as a dash when the owner asked and nothing came back, and a dash
+    // is a placeholder, not an answer. Keeping the two apart is what stops a
+    // placeholder from counting as content — see `hideTable`/`noEmpty` below.
+    //
+    // A zero is unaffected: `cellText` formats it as "0", not as the dash, and a
+    // zero total is a real answer that must keep the table up.
+    // Asked of `cellText` rather than re-derived: a `SemanticValue` is an OBJECT
+    // even when it carries `value: null`, so a nullish check on the entry itself
+    // calls a valueless total an answer. `cellText` already owns the decision of
+    // what counts as showable, down to `formatted: ""`, so the question is simply
+    // whether it produced the placeholder.
+    const serverTotal = result.totals?.[s.measureName];
+    const totalText = cellText(serverTotal);
+    const answeredTotal = totalText !== DASH;
+
     // `noTotals` is the owner's REQUEST and stays theirs; only they change it.
     // When they asked and the server sent no total, that is reported as a dash —
     // an absent number the owner asked for must be visible, not silently dropped
@@ -395,9 +423,12 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? null
       : {
           dimension: copyParam("ownerReport.totalsLabel", "Total"),
-          measure: result.totals ? cellText(result.totals[s.measureName]) : "—",
+          measure: totalText,
         };
 
+    // Is there anything to READ? Rows, or a total the server actually sent.
+    const hasContent = rows.length > 0 || answeredTotal;
+
     const out: ReportState = {
       ...s,
       status: "ready",
@@ -405,16 +436,22 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
         + `${s.measureLabel} ${copyParam("ownerReport.by", "by")} ${s.dimensionLabel}`,
       rows,
       totals,
-      rowCount: rows.length > 0
-        ? `${result.paging.count || rows.length} ${copyParam("ownerReport.rows", "rows")}`
-        : "",
+      // A zero count is stated, not left blank. Silence beside a caption reads
+      // as "still loading" — the ambiguity this screen removes everywhere else —
+      // so "0 rows" says the query ran and came back with nothing.
+      rowCount: `${rows.length > 0 ? result.paging.count || rows.length : 0} ${copyParam("ownerReport.rows", "rows")}`,
       missingFields: gap,
       noGap: gap === "",
-      // Rows OR totals. The API can answer `results: []` WITH a `totals` object
-      // — the SDK has a test for exactly that shape — and gating on rows alone
-      // hid the server's total and put "Nothing to show" over it. Opting into
-      // Show total would then have thrown away the only answer that came back.
-      hideTable: rows.length === 0 && !totals,
+      // Rows OR a total the SERVER sent. The API can answer `results: []` WITH a
+      // `totals` object — the SDK has a test for exactly that shape — and gating
+      // on rows alone hid the server's total and put "Nothing to show" over it.
+      //
+      // But it must be `answeredTotal`, not `totals`: `totals` is non-null for
+      // the whole time the owner has Show total on, INCLUDING when the answer is
+      // the "—" placeholder. Gating on it meant an empty result with the toggle
+      // on rendered a table whose only row was `Total —`, and the empty state
+      // could never fire while the toggle was on. Two states each correct alone.
+      hideTable: !hasContent,
       notLoading: true,
       notErrored: true,
       hideContent: false,
@@ -423,10 +460,10 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       // It is NOT conflated with a dropped field: the SDK reports no
       // `missingFields` when nothing came back at all, precisely because the two
       // are indistinguishable there, so this arm never accuses a field.
-      noEmpty: rows.length > 0 || totals !== null,
-      emptyText: rows.length === 0 && !totals
-        ? copyParam("ownerReport.empty", "No data for this range.")
-        : "",
+      noEmpty: hasContent,
+      emptyText: hasContent
+        ? ""
+        : copyParam("ownerReport.empty", "No data for this range."),
       // Carried through untouched: see the totals comment above.
       noTotals: s.noTotals,
       error: "",

package/templates/community-club-owner/tier5-src/himi-owner-lite-analytics/report.ts

@@ -181,11 +181,22 @@ function subjectLabelOf(m: SemanticModelSummary): string {
  * renders as a dash rather than as 0. `formatNumber` and not `toLocaleString`,
  * which is ECMA-402 and absent on QuickJS-ng (watchOS/Wear OS).
  */
+/**
+ * The one placeholder a cell falls back to when there is nothing to render.
+ *
+ * Named, because two things depend on it meaning exactly one thing: `cellText`
+ * produces it, and `runQuery` asks whether the server's total came back as it —
+ * which is how "the owner asked for a total and got a dash" is told apart from
+ * "the server answered". Spelling it twice let those two drift apart once
+ * already.
+ */
+const DASH = "\u2014";
+
 function cellText(v: SemanticValue | undefined): string {
-  if (!v) return "—";
+  if (!v) return DASH;
   if (v.formatted !== undefined && v.formatted !== "") return v.formatted;
   const raw = v.value;
-  if (raw === null || raw === undefined) return "—";
+  if (raw === null || raw === undefined) return DASH;
   if (typeof raw === "number") return formatNumber(raw);
   if (typeof raw === "boolean") return raw ? "Yes" : "No";
   if (typeof raw === "string") return raw;
@@ -387,6 +398,23 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? copyParam("ownerReport.missingFields", "No data returned for: ") + result.missingFields.join(", ")
       : "";
 
+    // Did the SERVER actually answer with a total for the measure asked for?
+    // This is NOT the same question as "is a totals row on screen": the row is
+    // rendered as a dash when the owner asked and nothing came back, and a dash
+    // is a placeholder, not an answer. Keeping the two apart is what stops a
+    // placeholder from counting as content — see `hideTable`/`noEmpty` below.
+    //
+    // A zero is unaffected: `cellText` formats it as "0", not as the dash, and a
+    // zero total is a real answer that must keep the table up.
+    // Asked of `cellText` rather than re-derived: a `SemanticValue` is an OBJECT
+    // even when it carries `value: null`, so a nullish check on the entry itself
+    // calls a valueless total an answer. `cellText` already owns the decision of
+    // what counts as showable, down to `formatted: ""`, so the question is simply
+    // whether it produced the placeholder.
+    const serverTotal = result.totals?.[s.measureName];
+    const totalText = cellText(serverTotal);
+    const answeredTotal = totalText !== DASH;
+
     // `noTotals` is the owner's REQUEST and stays theirs; only they change it.
     // When they asked and the server sent no total, that is reported as a dash —
     // an absent number the owner asked for must be visible, not silently dropped
@@ -395,9 +423,12 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? null
       : {
           dimension: copyParam("ownerReport.totalsLabel", "Total"),
-          measure: result.totals ? cellText(result.totals[s.measureName]) : "—",
+          measure: totalText,
         };
 
+    // Is there anything to READ? Rows, or a total the server actually sent.
+    const hasContent = rows.length > 0 || answeredTotal;
+
     const out: ReportState = {
       ...s,
       status: "ready",
@@ -405,16 +436,22 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
         + `${s.measureLabel} ${copyParam("ownerReport.by", "by")} ${s.dimensionLabel}`,
       rows,
       totals,
-      rowCount: rows.length > 0
-        ? `${result.paging.count || rows.length} ${copyParam("ownerReport.rows", "rows")}`
-        : "",
+      // A zero count is stated, not left blank. Silence beside a caption reads
+      // as "still loading" — the ambiguity this screen removes everywhere else —
+      // so "0 rows" says the query ran and came back with nothing.
+      rowCount: `${rows.length > 0 ? result.paging.count || rows.length : 0} ${copyParam("ownerReport.rows", "rows")}`,
       missingFields: gap,
       noGap: gap === "",
-      // Rows OR totals. The API can answer `results: []` WITH a `totals` object
-      // — the SDK has a test for exactly that shape — and gating on rows alone
-      // hid the server's total and put "Nothing to show" over it. Opting into
-      // Show total would then have thrown away the only answer that came back.
-      hideTable: rows.length === 0 && !totals,
+      // Rows OR a total the SERVER sent. The API can answer `results: []` WITH a
+      // `totals` object — the SDK has a test for exactly that shape — and gating
+      // on rows alone hid the server's total and put "Nothing to show" over it.
+      //
+      // But it must be `answeredTotal`, not `totals`: `totals` is non-null for
+      // the whole time the owner has Show total on, INCLUDING when the answer is
+      // the "—" placeholder. Gating on it meant an empty result with the toggle
+      // on rendered a table whose only row was `Total —`, and the empty state
+      // could never fire while the toggle was on. Two states each correct alone.
+      hideTable: !hasContent,
       notLoading: true,
       notErrored: true,
       hideContent: false,
@@ -423,10 +460,10 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       // It is NOT conflated with a dropped field: the SDK reports no
       // `missingFields` when nothing came back at all, precisely because the two
       // are indistinguishable there, so this arm never accuses a field.
-      noEmpty: rows.length > 0 || totals !== null,
-      emptyText: rows.length === 0 && !totals
-        ? copyParam("ownerReport.empty", "No data for this range.")
-        : "",
+      noEmpty: hasContent,
+      emptyText: hasContent
+        ? ""
+        : copyParam("ownerReport.empty", "No data for this range."),
       // Carried through untouched: see the totals comment above.
       noTotals: s.noTotals,
       error: "",

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-analytics/report.ts

@@ -181,11 +181,22 @@ function subjectLabelOf(m: SemanticModelSummary): string {
  * renders as a dash rather than as 0. `formatNumber` and not `toLocaleString`,
  * which is ECMA-402 and absent on QuickJS-ng (watchOS/Wear OS).
  */
+/**
+ * The one placeholder a cell falls back to when there is nothing to render.
+ *
+ * Named, because two things depend on it meaning exactly one thing: `cellText`
+ * produces it, and `runQuery` asks whether the server's total came back as it —
+ * which is how "the owner asked for a total and got a dash" is told apart from
+ * "the server answered". Spelling it twice let those two drift apart once
+ * already.
+ */
+const DASH = "\u2014";
+
 function cellText(v: SemanticValue | undefined): string {
-  if (!v) return "—";
+  if (!v) return DASH;
   if (v.formatted !== undefined && v.formatted !== "") return v.formatted;
   const raw = v.value;
-  if (raw === null || raw === undefined) return "—";
+  if (raw === null || raw === undefined) return DASH;
   if (typeof raw === "number") return formatNumber(raw);
   if (typeof raw === "boolean") return raw ? "Yes" : "No";
   if (typeof raw === "string") return raw;
@@ -387,6 +398,23 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? copyParam("ownerReport.missingFields", "No data returned for: ") + result.missingFields.join(", ")
       : "";
 
+    // Did the SERVER actually answer with a total for the measure asked for?
+    // This is NOT the same question as "is a totals row on screen": the row is
+    // rendered as a dash when the owner asked and nothing came back, and a dash
+    // is a placeholder, not an answer. Keeping the two apart is what stops a
+    // placeholder from counting as content — see `hideTable`/`noEmpty` below.
+    //
+    // A zero is unaffected: `cellText` formats it as "0", not as the dash, and a
+    // zero total is a real answer that must keep the table up.
+    // Asked of `cellText` rather than re-derived: a `SemanticValue` is an OBJECT
+    // even when it carries `value: null`, so a nullish check on the entry itself
+    // calls a valueless total an answer. `cellText` already owns the decision of
+    // what counts as showable, down to `formatted: ""`, so the question is simply
+    // whether it produced the placeholder.
+    const serverTotal = result.totals?.[s.measureName];
+    const totalText = cellText(serverTotal);
+    const answeredTotal = totalText !== DASH;
+
     // `noTotals` is the owner's REQUEST and stays theirs; only they change it.
     // When they asked and the server sent no total, that is reported as a dash —
     // an absent number the owner asked for must be visible, not silently dropped
@@ -395,9 +423,12 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? null
       : {
           dimension: copyParam("ownerReport.totalsLabel", "Total"),
-          measure: result.totals ? cellText(result.totals[s.measureName]) : "—",
+          measure: totalText,
         };
 
+    // Is there anything to READ? Rows, or a total the server actually sent.
+    const hasContent = rows.length > 0 || answeredTotal;
+
     const out: ReportState = {
       ...s,
       status: "ready",
@@ -405,16 +436,22 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
         + `${s.measureLabel} ${copyParam("ownerReport.by", "by")} ${s.dimensionLabel}`,
       rows,
       totals,
-      rowCount: rows.length > 0
-        ? `${result.paging.count || rows.length} ${copyParam("ownerReport.rows", "rows")}`
-        : "",
+      // A zero count is stated, not left blank. Silence beside a caption reads
+      // as "still loading" — the ambiguity this screen removes everywhere else —
+      // so "0 rows" says the query ran and came back with nothing.
+      rowCount: `${rows.length > 0 ? result.paging.count || rows.length : 0} ${copyParam("ownerReport.rows", "rows")}`,
       missingFields: gap,
       noGap: gap === "",
-      // Rows OR totals. The API can answer `results: []` WITH a `totals` object
-      // — the SDK has a test for exactly that shape — and gating on rows alone
-      // hid the server's total and put "Nothing to show" over it. Opting into
-      // Show total would then have thrown away the only answer that came back.
-      hideTable: rows.length === 0 && !totals,
+      // Rows OR a total the SERVER sent. The API can answer `results: []` WITH a
+      // `totals` object — the SDK has a test for exactly that shape — and gating
+      // on rows alone hid the server's total and put "Nothing to show" over it.
+      //
+      // But it must be `answeredTotal`, not `totals`: `totals` is non-null for
+      // the whole time the owner has Show total on, INCLUDING when the answer is
+      // the "—" placeholder. Gating on it meant an empty result with the toggle
+      // on rendered a table whose only row was `Total —`, and the empty state
+      // could never fire while the toggle was on. Two states each correct alone.
+      hideTable: !hasContent,
       notLoading: true,
       notErrored: true,
       hideContent: false,
@@ -423,10 +460,10 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       // It is NOT conflated with a dropped field: the SDK reports no
       // `missingFields` when nothing came back at all, precisely because the two
       // are indistinguishable there, so this arm never accuses a field.
-      noEmpty: rows.length > 0 || totals !== null,
-      emptyText: rows.length === 0 && !totals
-        ? copyParam("ownerReport.empty", "No data for this range.")
-        : "",
+      noEmpty: hasContent,
+      emptyText: hasContent
+        ? ""
+        : copyParam("ownerReport.empty", "No data for this range."),
       // Carried through untouched: see the totals comment above.
       noTotals: s.noTotals,
       error: "",

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-analytics/report.ts

@@ -181,11 +181,22 @@ function subjectLabelOf(m: SemanticModelSummary): string {
  * renders as a dash rather than as 0. `formatNumber` and not `toLocaleString`,
  * which is ECMA-402 and absent on QuickJS-ng (watchOS/Wear OS).
  */
+/**
+ * The one placeholder a cell falls back to when there is nothing to render.
+ *
+ * Named, because two things depend on it meaning exactly one thing: `cellText`
+ * produces it, and `runQuery` asks whether the server's total came back as it —
+ * which is how "the owner asked for a total and got a dash" is told apart from
+ * "the server answered". Spelling it twice let those two drift apart once
+ * already.
+ */
+const DASH = "\u2014";
+
 function cellText(v: SemanticValue | undefined): string {
-  if (!v) return "—";
+  if (!v) return DASH;
   if (v.formatted !== undefined && v.formatted !== "") return v.formatted;
   const raw = v.value;
-  if (raw === null || raw === undefined) return "—";
+  if (raw === null || raw === undefined) return DASH;
   if (typeof raw === "number") return formatNumber(raw);
   if (typeof raw === "boolean") return raw ? "Yes" : "No";
   if (typeof raw === "string") return raw;
@@ -387,6 +398,23 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? copyParam("ownerReport.missingFields", "No data returned for: ") + result.missingFields.join(", ")
       : "";
 
+    // Did the SERVER actually answer with a total for the measure asked for?
+    // This is NOT the same question as "is a totals row on screen": the row is
+    // rendered as a dash when the owner asked and nothing came back, and a dash
+    // is a placeholder, not an answer. Keeping the two apart is what stops a
+    // placeholder from counting as content — see `hideTable`/`noEmpty` below.
+    //
+    // A zero is unaffected: `cellText` formats it as "0", not as the dash, and a
+    // zero total is a real answer that must keep the table up.
+    // Asked of `cellText` rather than re-derived: a `SemanticValue` is an OBJECT
+    // even when it carries `value: null`, so a nullish check on the entry itself
+    // calls a valueless total an answer. `cellText` already owns the decision of
+    // what counts as showable, down to `formatted: ""`, so the question is simply
+    // whether it produced the placeholder.
+    const serverTotal = result.totals?.[s.measureName];
+    const totalText = cellText(serverTotal);
+    const answeredTotal = totalText !== DASH;
+
     // `noTotals` is the owner's REQUEST and stays theirs; only they change it.
     // When they asked and the server sent no total, that is reported as a dash —
     // an absent number the owner asked for must be visible, not silently dropped
@@ -395,9 +423,12 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       ? null
       : {
           dimension: copyParam("ownerReport.totalsLabel", "Total"),
-          measure: result.totals ? cellText(result.totals[s.measureName]) : "—",
+          measure: totalText,
         };
 
+    // Is there anything to READ? Rows, or a total the server actually sent.
+    const hasContent = rows.length > 0 || answeredTotal;
+
     const out: ReportState = {
       ...s,
       status: "ready",
@@ -405,16 +436,22 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
         + `${s.measureLabel} ${copyParam("ownerReport.by", "by")} ${s.dimensionLabel}`,
       rows,
       totals,
-      rowCount: rows.length > 0
-        ? `${result.paging.count || rows.length} ${copyParam("ownerReport.rows", "rows")}`
-        : "",
+      // A zero count is stated, not left blank. Silence beside a caption reads
+      // as "still loading" — the ambiguity this screen removes everywhere else —
+      // so "0 rows" says the query ran and came back with nothing.
+      rowCount: `${rows.length > 0 ? result.paging.count || rows.length : 0} ${copyParam("ownerReport.rows", "rows")}`,
       missingFields: gap,
       noGap: gap === "",
-      // Rows OR totals. The API can answer `results: []` WITH a `totals` object
-      // — the SDK has a test for exactly that shape — and gating on rows alone
-      // hid the server's total and put "Nothing to show" over it. Opting into
-      // Show total would then have thrown away the only answer that came back.
-      hideTable: rows.length === 0 && !totals,
+      // Rows OR a total the SERVER sent. The API can answer `results: []` WITH a
+      // `totals` object — the SDK has a test for exactly that shape — and gating
+      // on rows alone hid the server's total and put "Nothing to show" over it.
+      //
+      // But it must be `answeredTotal`, not `totals`: `totals` is non-null for
+      // the whole time the owner has Show total on, INCLUDING when the answer is
+      // the "—" placeholder. Gating on it meant an empty result with the toggle
+      // on rendered a table whose only row was `Total —`, and the empty state
+      // could never fire while the toggle was on. Two states each correct alone.
+      hideTable: !hasContent,
       notLoading: true,
       notErrored: true,
       hideContent: false,
@@ -423,10 +460,10 @@ async function runQuery(s: ReportState, days: number): Promise<ReportState | Dec
       // It is NOT conflated with a dropped field: the SDK reports no
       // `missingFields` when nothing came back at all, precisely because the two
       // are indistinguishable there, so this arm never accuses a field.
-      noEmpty: rows.length > 0 || totals !== null,
-      emptyText: rows.length === 0 && !totals
-        ? copyParam("ownerReport.empty", "No data for this range.")
-        : "",
+      noEmpty: hasContent,
+      emptyText: hasContent
+        ? ""
+        : copyParam("ownerReport.empty", "No data for this range."),
       // Carried through untouched: see the totals comment above.
       noTotals: s.noTotals,
       error: "",