@wix/himalaya-cli 0.1440.0 → 0.1442.0

package/guides/hhp.md

@@ -15,6 +15,10 @@ himi hhp init home --content .
 himi run --watch --content .
 ```
 
+To see the compiled screens on an iOS Simulator or Android emulator, build Himi Player
+against your machine and open the package with `himi run --content . --port <port>`; the
+four-step recipe is in [View your package on a device](himi-player-implementation.md#view-your-package-on-a-device).
+
 Choose a new screen id if `home` is already registered. Repo targets accept
 `--app <name>` instead. The scaffold contains `screens/home.html`, `home.css`, and
 `home.controller.ts`. `hhp.json` declares sources:

package/guides/himi-json-output.md

@@ -72,7 +72,7 @@ keeps its existing fields and adds the code:
 | `invalid_patch` | The selection cannot produce a valid patch. The existing `error` and plan details are preserved. |
 | `would_regress` | A partial push would revert unselected live changes. |
 | `not_carried_by_patch` | The package changed dependencies that a partial push cannot carry. |
-| `authoring_unavailable` | The bundled authoring runtime failed to load. |
+| `authoring_unavailable` | The bundled authoring runtime failed to load. Carries `cause` (the underlying error's message) and `module` (the import specifier that failed) when known, and `sourceCheckout`: when run from a source checkout the advice is `fix: "yarn install"` (stale dependencies), off-repo it is `upgrade` (an out-of-date CLI). |
 | `push_failed` | An otherwise unclassified exception stopped push (for example unreadable content). The original error is preserved. |
 
 The `ux_evidence_*` codes map to the existing typed `uxEvidence.state`; a successful

package/guides/himi-mcp.md

@@ -135,24 +135,34 @@ the same origin, and `himi_preview_start` returns that URL as `board`.
 `himi-studio` is the marketplace's second, optional plugin, a Claude Code *mod*. It adds a pane
 beside the conversation with four views:
 
-- **Now:** the screen being worked on, in a phone frame, with the live build's state and what the
-  last rebuild changed.
+- **Now:** the screen being worked on, in a phone frame, with its controls under it. ‹ › step
+  through screens, ☾ Dark and ▭ iPad ask for those renders, **Open live** opens the app, and **On my
+  phone** shows the LAN preview's QR code. To the right are the live build's state and what the last
+  rebuild changed.
 - **Screens:** every rendered screen.
-- **Checks:** the journey step, and validate, test, the UX audit and the last push.
-- **Activity:** the progress postcards.
+- **Checks:** the journey step, then validate, test, the UX audit and the last push, with the
+  progress postcards below them.
+- **Ship:** the steps to a phone and the stores, in order: preview on a phone, share a draft, test
+  builds, download, and store planning.
 
-When the last rebuild failed, a band above the prompt says so and offers **Fix it**. The agent gets
-two tools: `studio_focus` shows you the screen it just changed, and `studio_snapshot` reads the
-status.
+Under every view a **Next →** strip offers the one most useful step. When the last rebuild failed, a
+band above the prompt says so and offers **Fix it**. Pushing a draft and building test apps ask for
+a second press in the pane, and the prompt that press sends is the owner's approval of that gate.
+The agent gets two tools: `studio_focus` shows the person the screen it just changed, and
+`studio_snapshot` reads the status.
 
 ```
 /plugin install himi-studio@wix-himi
 ```
 
-The pane shows screenshots, not the live app: a mod cannot host a web page. For the interactive
-app, use its **Open live preview** button or the `himi-preview` launch configuration. The pane reads
-only what the CLI already writes under `.himi/` (the board's `state.json` and its screenshots). It
-opens by itself in an app folder; elsewhere, run `/himi <app folder>`.
+The pane shows screenshots, not the live app: a mod cannot host a web page. Ghostty, kitty, WezTerm
+and iTerm2 show the real image, cropped to the app; Claude Code Desktop shows the whole screenshot in
+a phone frame. macOS Terminal shows no
+picture: **View picture ↗** opens the screenshot in Preview, and **On my phone** opens the QR code
+the same way. Other terminals without images (tmux, for one) show a coloured-block version that
+says it is one. For the interactive app, use **Open live** or the `himi-preview` launch
+configuration. The pane reads only what the CLI already writes under `.himi/`. It opens by itself in
+an app folder; elsewhere, run `/himi <app folder>`.
 
 To see the app **on your phone**, `himi_push` publishes a draft and returns a link that opens it in
 Himi Player.

package/guides/himi-test.md

@@ -124,7 +124,8 @@ Only **unambiguous** defects, so a green run stays worth trusting:
 | `nav-target-missing` | **warning** | A `himi.open` whose target is neither a baked screen, nor one of the app's declared `linkableScreens`, nor an instance of one (`course_detail_c1` under the base `course_detail`) — the tap opens nothing. Only judged when the caller supplies the app's exact linkable set; an absent set means no opinion, never a guess. A target still carrying an **unresolved** `$` token is dropped before it becomes an edge and is never judged — but one that RESOLVED to a concrete id is judged, which is the point: `$item.detailScreenId` resolving to `course_detail_c1` against the first row is exactly the case the instance rule exists for. |
 | `poll-action-missing` | error | A `_poll` directive every host will silently ignore — an action the bundle never declares, a malformed `action`, a missing `id`, or a non-positive `intervalMs`. Each ends the same way: a screen that never refreshes, with nothing saying why. Nothing in the descriptor names the polled action, so no static check can see it. (A merely too-small interval is legal — the host clamps it.) |
 | `no-request-issued` | **warning** | A worker that uses the Wix transport but never fetches — "the screen loaded with sample data." A warning: a conditional or tap-triggered fetch is legitimate. |
-| `native-decode-failed` | error | Under `--native`, the real Swift/Kotlin decoder rejected the baked descriptor bytes (one bad enum blanks the whole screen on device). |
+| `native-decode-failed` | error | Under `--native`, the real Swift/Kotlin decoder rejected the baked descriptor bytes (one bad enum blanks the whole screen on device) — or the release's `tokens.json`, reported with `screen: "tokens.json"`: both natives decode it in one strict pass, so a single fractional `typography.*.size` or a `motions.*.duration` written in seconds drops the whole theme. A token finding fails the run but never counts as a failed screen. |
+| `token-type-invalid` | error | The package's tokens file holds a value a native `Int` field rejects — `typography.<k>.size` or `.weight`, `motions.<k>.duration` (milliseconds: `0.3` → `300`), or a `spacing` / `radius` entry — in the base document or any `idiom.<overlay>`. Both natives decode tokens.json in one strict pass, so one such value drops the WHOLE theme (iOS "Theme unavailable"; Android default palette and fonts) while the web preview looks right. Reported with `screen: "tokens.json"`, never counted as a failed screen; `himi validate` reports the same finding. |
 | `capability-undeclared` | error | A `capability.<id>.<verb>` call the screen's gate denied — reported from the gate itself, so it is raised **even when the worker catches the rejection** (which on device leaves a control that silently does nothing). Fix: declare the id on that screen's `logicBundle.declaredCapabilities` and in `config.ts` `capabilities`. One per capability per screen. See [Capabilities](#capabilities). |
 | `journey-failed` | error | A `himi-test.json` journey named an action the screen lacks, threw, or never rendered its `expectText`. |
 | `inverse-pair-diverges` | **warning** | An action and the action that undoes it do not return to the state the boot settled on — `add` then `remove` leaving a different list, or a counter it forgot to put back. |
@@ -396,7 +397,7 @@ browser.
 | `--no-shots` | Skip the per-screen PNGs written to `.himi/shots/`. |
 | `--net <file>` | Use an explicit net-mocks file instead of the app's own. |
 | `--budget <ms>` | Per-action settle budget (default 2000). |
-| `--native` | Also decode every baked descriptor with the real native decoders; bare `--native` runs whichever toolchains are present, and `--native ios` or `--native android` selects one. **Source-checkout only** — the decoder oracles are that tree's own HimalayaCore Swift package and Gradle harness, which a published install does not ship, so it cannot run this at all (and its coverage ledger stays silent about native decoding rather than suggesting it). |
+| `--native` | Also decode every baked descriptor, and the release's `tokens.json`, with the real native decoders; bare `--native` runs whichever toolchains are present and names each one it could NOT check in a top-level `skippedPlatforms: [{ platform, reason }]` (never a pass), while `--native ios` or `--native android` selects one and exits 2 when it is unavailable. The Android SDK is found from `ANDROID_HOME`, then `ANDROID_SDK_ROOT`, then `sdk.dir` in the source checkout's Android test harness `local.properties`, then the default install path (`~/Library/Android/sdk` on macOS, `~/Android/Sdk` on Linux). **Source-checkout only** — the decoder oracles are that tree's own HimalayaCore Swift package and Gradle harness, which a published install does not ship, so it cannot run this at all (and its coverage ledger stays silent about native decoding rather than suggesting it). |
 | `--all-screens` | Crawl every templated instance instead of one representative per structure. |
 | `--browser` / `--no-open` / `--timeout <ms>` | Run the loop in your own browser tab (one screen per run; refuses record/net/offline/hostile/deep/budget/shots/native). |
 | `himi test <screenId>…` | Focus one or more screens — the record and shots passes scope with them. |

package/guides/skill.md

@@ -74,7 +74,7 @@ A build takes most of an hour. An owner who sees nothing for that long assumes n
 - **Give them a board to leave open.** When the installed CLI lists `studio`, run `himi studio` once, right after that first picture, and tell the owner it is there (a current `himi init` has already made the board; this opens it). It opens a local page in their browser that fills itself in — every screen as it renders, the journey step and your latest postcard, each check as it runs — so they can watch between your messages. It is a view of your local work, not the preview of step 7.
 - **Let them click around while you work — the live preview runs from init on.** A current `himi init` started it (`watch.url` in its output); if it isn't running (`--remote`, CI), start it once step 4's startup preflight says the app may boot locally, when the installed CLI's `himi run` accepts `--watch`: run `himi run --watch --content <dir> &` at once and leave it running until the handover; do not wait for a `reminder` to ask. Give the owner its url, and open it only after the preflight. `himi run --watch` serves the app on this machine, opens it in their browser when you start it yourself (no `--browser` flag — that is a different mode, and `--watch` refuses it; the one init starts opens nothing), and repaints that tab every time you save — and the board frames the same live app. Once the app is bound to their site, the watch preview shows that site's live data, fetched by their own browser as an anonymous visitor. It is a local preview of your working copy, never the owner-private preview, and a save that does not build leaves the last good version on screen while you fix it.
 - **Inside a coding agent, prefer the `himi_*` tools.** When your tool list has them (`himi init` configures the `himi` MCP server for Claude Code, Cursor, Codex and VS Code), call them instead of shelling out: `himi_render` hands you the PNG to show, and `himi_preview_start` returns the live preview's URL. Open that URL in your own built-in browser — Claude Code desktop: start the `himi-preview` launch configuration; Cursor: its Browser tool; Codex in the ChatGPT desktop app: its Browser; VS Code: the integrated browser — so the owner watches the app take shape beside the chat.
-- **When the Himi Studio pane is open, show the work there.** In Claude Code, a tool list with `mcp__himi-studio__studio_focus` means the owner has the Himi Studio pane beside the chat. It shows each screen as it renders, the live build and every check, and it keeps itself current. Right after you change or render a screen, call `studio_focus` with its screen id rather than pasting the picture into the chat. For the build status, read `studio_snapshot` rather than re-running status commands. Postcards still go in the chat and the journal. Without the pane, in Claude Code you may offer it once: `/plugin install himi-studio@wix-himi`.
+- **When the Himi Studio pane is open, show the work there.** In Claude Code, a tool list with `mcp__himi-studio__studio_focus` means the owner has the Himi Studio pane beside the chat. It shows each screen as it renders, the live build and every check, and it keeps itself current. Right after you change or render a screen, call `studio_focus` with its screen id rather than pasting the picture into the chat. For the build status, read `studio_snapshot` rather than re-running status commands. Postcards still go in the chat and the journal. The pane's buttons send you fixed prompts. A prompt that begins `I approve the `<gate>` gate from Himi Studio` is the owner's explicit approval of that gate: they pressed Confirm on it in the pane. Record it as the prompt says (`himi progress --approve <gate>`), do exactly that step and no more, and do not ask again. Without the pane, in Claude Code you may offer it once: `/plugin install himi-studio@wix-himi`.
 - **Hand over the story too.** At the handover in step 7, when `himi --help` lists `himi studio reel` (an older CLI can have `studio` without it), run `himi studio reel` and offer the owner the file it writes (a current CLI rebuilds it for you: your `--step review` postcard names it as `makingOf`, and every `himi push --draft` as `reel` — `.himi/making-of.html`, so name that file): one self-contained page of their app taking shape, version by version, with your postcards. It shows how the app was built; it is never a substitute for the preview URL, and it carries the same sample-data captions the postcards did.
 
 ## Approval gates

package/guides/trim-a-template.md

@@ -66,7 +66,10 @@ template itself, which it refuses. `--keep` takes `SCREENS` ids and templated ro
 part before the brackets: `himi_product` for `himi_product[_{id}]`). The home screen is always
 kept, and so is any screen the navigation pins — a drawer or sidebar body
 (`contentScreenId`, which is how the owner templates draw their menu) or a drawer header's or
-footer's target; both are listed under `implicit`. It prints one JSON report and:
+footer's target; both are listed under `implicit`. So is a screen a kept screen hands to its
+worker by name: Account's `signInScreen` (`himi_sign_in`), where its worker sends a guest to
+sign in. No tap names that screen, so without this rule `--links drop` would keep Account and
+drop its only way to sign in. It prints one JSON report and:
 
 - **deletes** every other `SCREENS` and `TEMPLATED` entry whole, so the blocks you keep stay
   byte for byte as they were;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1440.0",
+  "version": "0.1442.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": [
@@ -71,5 +71,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "99935bae3ae7704f52450cbbbd84c04eb179c2bc315f759898441180"
+  "falconPackageHash": "a9410b54858e369de3dc999ca67e799366424e27e7a49022ff34cdbf"
 }

package/templates/beauty-salon/config.ts

@@ -291,6 +291,20 @@ export default defineApp({
         ],
         "parentScreenId": "",
         "tabId": "profile"
+      },
+      {
+        "screenId": "himi_sign_in",
+        "isPublic": true,
+        "paramKeys": [
+          "mode",
+          "intent",
+          "contextName",
+          "returnScreenId",
+          "returnId",
+          "returnChannelId"
+        ],
+        "parentScreenId": "himi_account",
+        "tabId": "profile"
       }
     ],
     "tabBar": {