@wix/himalaya-cli 0.859.0 → 0.860.0

package/dist/cli.mjs

@@ -5234,7 +5234,6 @@ function resolveTranslation(value, catalog, sourceCatalog) {
 var BINDING_SIGILS, BINDING_SIGIL_RE, TRANSLATION_PREFIX, TRANSLATION_KEY_RE;
 var init_bindings = __esm({
   "../../core/ts/src/bindings.ts"() {
-    "use strict";
     BINDING_SIGILS = ["service", "flag", "item", "t"];
     BINDING_SIGIL_RE = new RegExp(
       `^\\$(?:${BINDING_SIGILS.filter((s) => s !== "t").join("|")})\\b|^\\$t:`

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/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.860.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": "6e5648ad5145fd23a5016b4c194db40fb00d71c22c7a0abaa2ed5020"
 }