@wix/himalaya-cli 0.1059.0 → 0.1061.0

package/guides/headless-loop.md

@@ -104,7 +104,12 @@ press Replay for a thirty-second making-of, checks included — pop the live pho
 always-on-top window, and show the owner their website next to their app the moment the brand lands.
 To put the preview on the owner's phone, run `himi run --watch --lan` instead: it prints a QR (and
 the board shows one) that a phone on the same Wi-Fi opens as the real app, full screen, repainting as
-you edit. Say that anyone on that network can open it; it is read-only. `himi test` writes one PNG per
+you edit. Say that anyone on that network can open it; it is read-only. The board also draws the app
+map while `himi test` crawls — every screen, how they link, the entries (tab bar and menu), what nothing
+was seen linking to, and links to screens that do not exist — and each `--watch` rebuild says what it
+changed (the text, the component, the token, "logic changed" for a worker-only edit), on the board and
+in its `{"watch":"rebuilt"}` line. Check the map before handover: an unreached screen or a broken
+link is a gap to close or to name. `himi test` writes one PNG per
 screen to `.himi/shots/` on every run, so take the new screens from there instead of rendering each
 one again; a bare `--png` on `himi render` writes `.himi/shots/<id>.png`. `himi progress` copies each image into `.himi/history/`
 as it was when you journaled it, so a later render cannot change what the record says the owner saw;

package/guides/himi-test.md

@@ -202,6 +202,23 @@ every run; record against a **QA site**, never production. See
 Every run prints a machine envelope with `--json`. Findings are source-mapped to the line
 you edit; the gap ledger routes you to whatever the crawl couldn't prove.
 
+It also carries `navGraph`, the app's navigation as the crawl saw it, which the build board
+draws as its **App map** and fills in while the crawl runs:
+
+- `screens` — every declared screen: `entry` (the home screen, or a screen the navigation chrome
+  opens: a tab bar, drawer or sidebar item, a drawer or sidebar header or its actions, a hosted content
+  screen, a default top-bar action), `reached` (walkable from an entry over every link seen),
+  `status` (`ok`, `failed`, `skipped`), and `unfollowed`, the links on it whose target the crawl could
+  not resolve (bound to list data with no row, or to a value the boot state lacks);
+- `edges` — every link seen, one per pair, not only the ones `edges` then followed; a link to an
+  instance of a linkable screen (`program_prog-1`) is a link to that screen. The list stops at 600;
+  `edgesDropped` counts the rest, which `reached` still walked;
+- `broken` — links to a target that is neither a baked nor a linkable screen, judged exactly like the
+  `nav-target-missing` check (and, like it, never without the app's linkable screens);
+- `unreached` and `unfollowed` — read them together: with no unfollowed links an unreached screen has
+  nothing leading to it; with some, it may be opened from list data, so name it as unverified rather
+  than dead.
+
 ```jsonc
 {
   "ok": false,                         // exit 1

package/guides/sdk-reference.json

@@ -3475,7 +3475,7 @@
         "name": "i18n",
         "kind": "const",
         "jsdoc": "",
-        "decl": "export const i18n = {\n  /** Resolve a translation key for the current locale; `fallback` (or the key)\n   *  when unknown. */\n  async t(key: string, fallback?: string): Promise<string> {\n    if (isMemberReal(\"i18n\")) {\n      try {\n        const r = await realWix<{ translation?: string }>(\"GET\", `/_api/translations-server/v1/translation/${encodeURIComponent(key)}`);\n        if (typeof r?.translation === \"string\") return r.translation;\n      } catch { /* fall through to the dev seam */ }\n    }\n    const r = await call<{ value?: string }>(\"i18nTranslate\", { key, fallback: fallback ?? key });\n    return r?.value ?? fallback ?? key;\n  },\n  /** Current resolved UI locale (2-letter). */\n  async locale(): Promise<string> {\n    const r = await call<{ locale?: string }>(\"i18nLocale\");\n    return r?.locale ?? \"en\";\n  },\n};"
+        "decl": "export const i18n = {\n  /** Resolve a translation key for the current locale; `fallback` (or the key)\n   *  when unknown. Always the native seam: `/_api/translations-server/v1/translation/<key>`\n   *  has no route on any Wix host a himi app reaches (the same 404 as a made-up path, with or\n   *  without a token), so `real.i18n` no longer sends it anywhere — it only ever 404ed. */\n  async t(key: string, fallback?: string): Promise<string> {\n    const r = await call<{ value?: string }>(\"i18nTranslate\", { key, fallback: fallback ?? key });\n    return r?.value ?? fallback ?? key;\n  },\n  /** Current resolved UI locale (2-letter). */\n  async locale(): Promise<string> {\n    const r = await call<{ locale?: string }>(\"i18nLocale\");\n    return r?.locale ?? \"en\";\n  },\n};"
       },
       {
         "name": "PingRegistration",

package/guides/wix-platform-usage.md

@@ -4,9 +4,10 @@
 **platform-agnostic** — the same JS runs on iOS, Android, macOS and web, with **one documented
 exception**: on web, `auth.signIn()` rejects rather than resolving (see
 [Real vs dev seam](#real-vs-dev-seam-and-best-effort) below). Each
-member dispatches to the native `wix_platform` capability (with an on-device dev seam),
-and REST-shaped members go to real Wix when the app enables them
-([opt-in guide](wix-platform-opt-in.md)). This is the authoritative reference for
+member dispatches to the native `wix_platform` capability (with an on-device dev seam);
+`bi`, `monitoring`, `session` and `auth` take their real backend when the app enables them
+([opt-in guide](wix-platform-opt-in.md)), while `experiments` / `flags` always read the app's
+served flags and `i18n`, `ping` and `deeplink` always answer from the seam. This is the authoritative reference for
 *calling* the members; source of truth is `core/sdk/wix-platform/src/index.ts` +
 [RFC 0042](../core/schema/RFC/0042-wix-platform-sdk.md).
 
@@ -63,12 +64,16 @@ await monitoring.captureError("thing failed", { code: "E1" });
 
 - With no `wixPlatform.real.<member>`, a member returns the **dev seam** (deterministic
   on-device value; no network). `isMemberReal(member)` reflects the flag.
-- With `real.<member> = true`, REST-shaped members route through the real `wixApi`
-  chokepoint. These are **best-effort**: a 4xx (expected until a Wix App is registered)
-  falls back to the seam value AND still emits the member's telemetry
-  (`experiment_exposed` / `ping_registered` / `deferred_deeplink_resolved` / …), so
-  feature-gating + attribution stay correct either way. Every method returns a resolved
-  value (or `null`) — never throws on a Wix error — so a worker never crashes on the SDK.
+- With `real.<member> = true`, the one REST-shaped member that still has a reachable Wix
+  route takes it: `auth.signedInstance` mints through the real `wixApi` chokepoint. That is
+  **best-effort**: a failure falls back to the seam value, so feature-gating stays correct
+  either way. Every method returns a resolved value (or `null`) — never throws on a Wix
+  error — so a worker never crashes on the SDK.
+- `real` does nothing for the rest. `experiments` / `flags` always answer from the app's
+  served flags (`GET /v1/flags/<app>/assignments`, set with `himi flags`), never Wix Petri;
+  `i18n`, `ping` and `deeplink` have no Wix route a himi app can reach (a 404 with or without
+  a token), so they always answer from the seam and `real.i18n` / `real.ping` /
+  `real.deeplink` are ignored.
 - `bi`, `monitoring`, and `auth` route through their native backends (Frog sink, Sentry
   sink, `WixNativeAuthProvider`) rather than raw `wixApi`, but the calling contract is
   identical — **except `auth.signIn()` on web**, below.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1059.0",
+  "version": "0.1061.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": [
@@ -65,5 +65,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "217408348528b793a48ae81c3b6395c3764c7e8c01df6771e26347e0"
+  "falconPackageHash": "b243ee9fc8a6a890b9210aa28588552b0722079d8481a0e61fb76869"
 }

package/templates/surface-showcase/dev/index.ts

@@ -579,7 +579,9 @@ const SCREENS = runtimeSetting({
                 "package": "himalaya",
                 "type": "Gauge",
                 "props": {
-                  "value": 0.68,
+                  "value": 68,
+                  "min": 0,
+                  "max": 100,
                   "label": "Goal"
                 }
               }