@wix/himalaya-cli 0.1134.0 → 0.1135.0

package/dist/cli.mjs

@@ -6762,7 +6762,6 @@ function walk(node, registry, path2, out2) {
 var SYSTEM_FONT_FAMILY, TONAL_ELEVATION_ALPHA;
 var init_tokens = __esm({
   "../../core/ts/src/tokens.ts"() {
-    "use strict";
     SYSTEM_FONT_FAMILY = "$system";
     TONAL_ELEVATION_ALPHA = [0, 0.05, 0.08, 0.11, 0.12, 0.14];
   }
@@ -14208,8 +14207,8 @@ async function loadSharp() {
   const failures = [];
   let presentButBroken = false;
   try {
-    const { createRequire: createRequire3 } = await import("node:module");
-    cachedSharp = createRequire3(import.meta.url)("sharp");
+    const { createRequire: createRequire4 } = await import("node:module");
+    cachedSharp = createRequire4(import.meta.url)("sharp");
     lastProblem = null;
     return cachedSharp;
   } catch (e) {
@@ -48372,6 +48371,7 @@ __export(app_source_exports, {
   newestSourceChangeMs: () => newestSourceChangeMs,
   readAppSource: () => readAppSource,
   removeStaleSource: () => removeStaleSource,
+  renderInputRootDirs: () => renderInputRootDirs,
   secretFindings: () => secretFindings,
   sourceFingerprint: () => sourceFingerprint,
   staleSourcePaths: () => staleSourcePaths,
@@ -48382,6 +48382,7 @@ __export(app_source_exports, {
 import { createHash as createHash24 } from "node:crypto";
 import { readdirSync as readdirSync25, lstatSync as lstatSync9, readFileSync as readFileSync50, mkdirSync as mkdirSync22, writeFileSync as writeFileSync17, existsSync as existsSync46, rmSync as rmSync10, rmdirSync as rmdirSync2, unlinkSync as unlinkSync3 } from "node:fs";
 import { join as join44, resolve as resolve40, sep as sep11 } from "node:path";
+import { createRequire as createRequire3 } from "node:module";
 import { deflateRawSync as deflateRawSync2 } from "node:zlib";
 function walkSourceTree(dir, file, skip, enter = () => {
 }) {
@@ -48420,12 +48421,56 @@ function collectAppSource(dir) {
   skipped.sort();
   return { entries, skipped };
 }
+function renderInputRootDirs(dir) {
+  const entries = [];
+  walkSourceTree(
+    dir,
+    (archivePath, hostRel) => {
+      const segs = archivePath.split("/");
+      if (!CODE_FILE.test(archivePath) || /\.d\.[cm]?ts$/i.test(archivePath)) return;
+      if (segs.length === 1 || segs[0] === "dev" || segs[0] === "tier5-src") entries.push(join44(dir, hostRel));
+    },
+    () => {
+    }
+  );
+  const roots = new Set(RENDER_ROOT_DIRS);
+  if (entries.length === 0) return roots;
+  try {
+    const esbuild = createRequire3(import.meta.url)("esbuild");
+    const empty = Object.fromEntries(
+      [".png", ".jpg", ".jpeg", ".gif", ".webp", ".svg", ".ttf", ".otf", ".woff", ".woff2", ".css", ".txt", ".md", ".html", ".mp3", ".mp4"].map((e) => [e, "empty"])
+    );
+    const result = esbuild.buildSync({
+      entryPoints: entries,
+      absWorkingDir: dir,
+      bundle: true,
+      write: false,
+      metafile: true,
+      packages: "external",
+      platform: "neutral",
+      format: "esm",
+      outdir: join44(dir, ".himi", "render-inputs-out"),
+      loader: empty,
+      logLevel: "silent"
+    });
+    for (const input of Object.keys(result.metafile?.inputs ?? {})) {
+      const segs = input.split("/");
+      if (segs.length > 1 && !input.startsWith("..") && !input.includes(":")) roots.add(segs[0]);
+    }
+    return roots;
+  } catch {
+    return void 0;
+  }
+}
 function newestSourceChangeMs(dir) {
+  const roots = renderInputRootDirs(dir);
+  const inRead = (hostRel) => !roots || roots.has(hostRel.split(sep11)[0]);
+  const counts = (hostRel) => !hostRel.includes(sep11) || inRead(hostRel);
   let newest = 0;
   walkSourceTree(
     dir,
     (archivePath, hostRel) => {
-      if (/\.md$/i.test(archivePath)) return;
+      if (/\.md$/i.test(archivePath) || !counts(hostRel)) return;
       const m = lstatSync9(join44(dir, hostRel)).mtimeMs;
       if (m > newest) newest = m;
     },
@@ -48435,8 +48480,9 @@ function newestSourceChangeMs(dir) {
     // mtime moves. So every source directory counts too — else removing a screen after the shot
     // was taken would date that shot as current. Not the package ROOT: any file created there
     // (a plan, a build output) moves its mtime, and the screens live below it (dev/, tier5-src/).
+    // Nor a root directory the render does not read: creating a file in `_qa/` moves `_qa/`.
     (hostRel) => {
-      if (hostRel === "") return;
+      if (hostRel === "" || !inRead(hostRel)) return;
       const m = lstatSync9(join44(dir, hostRel)).mtimeMs;
       if (m > newest) newest = m;
     }
@@ -48597,7 +48643,7 @@ function pruneEmptyDirs(root, rel, needed, removed) {
   }
   return empty;
 }
-var MAX_APP_SOURCE_BYTES, SECRET_PATTERNS;
+var MAX_APP_SOURCE_BYTES, SECRET_PATTERNS, RENDER_ROOT_DIRS, CODE_FILE;
 var init_app_source = __esm({
   "src/app-source.ts"() {
     init_source_deny();
@@ -48638,6 +48684,8 @@ var init_app_source = __esm({
       { re: /\bgh[pousr]_[A-Za-z0-9]{20,}\b/, reason: "a GitHub token" },
       { re: /\bxox[baprs]-[A-Za-z0-9-]{10,}\b/, reason: "a Slack token" }
     ];
+    RENDER_ROOT_DIRS = /* @__PURE__ */ new Set(["dev", "tier5-src", "assets", "seed", "strings", "l10n", "fonts", "images", "data"]);
+    CODE_FILE = /\.(?:[cm]?[jt]s|[jt]sx)$/i;
   }
 });
 
@@ -49910,7 +49958,8 @@ function watchReminder(dir, opts = {}) {
       return `the live preview is running at ${live2.url} (pid ${live2.pid}${live2.by === "init" ? ", started by himi init" : ""}) \u2014 it repaints on every save, and the build board is ${live2.board}; give the owner that link to click around while you work, and do not start another`;
     }
     const content = opts.content ?? displayPath(dir);
-    return `start the live preview and leave it running: \`himi run --watch --content ${shellQuote(content)} &\` (the consent preflight first, if a worker or config calls Wix at boot) \u2014 it repaints on every save; the build board is ${shellQuote(join48(content, ".himi", "studio", "index.html"))}, or /__himi/studio/ on the preview`;
+    const remote = readInitSource(dir)?.source === "remote" ? "init did not start it because this template came off the serve plane \u2014 once you have read its code, " : "";
+    return `${remote}start the live preview and leave it running: \`himi run --watch --content ${shellQuote(content)} &\` (the consent preflight first, if a worker or config calls Wix at boot) \u2014 it repaints on every save; the build board is ${shellQuote(join48(content, ".himi", "studio", "index.html"))}, or /__himi/studio/ on the preview`;
   } catch {
     return void 0;
   }
@@ -72405,7 +72454,8 @@ var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
   "no-first-look",
   "no-image",
   "no-watch",
-  "mocks"
+  "mocks",
+  "no-mocks"
 ]);
 var SHELL_ENUM = SHELL_NAMES2.join("|");
 var SWITCH_FLAGS = new Set([...BOOLEAN_FLAGS].filter((name) => name !== "deep"));
@@ -72613,7 +72663,7 @@ var USAGE = `himi \u2014 the Himalaya authoring CLI (remote dev loop)
                                            (--ai writes rows for you to review first)
   himi secrets set|list|rotate --app <app> --name <name> [--environment preview|production]
                                            encrypted secret metadata; set/rotate read the value from stdin
-  himi render <screenId> [--content <dir>] [--scheme dark] [--png [<file>]] [--tree] [--dump-state] [--static] [--live] [--mocks] [--state <json|file>] [--input <json|file>] [--width <px> | --device <name>] [--rtl] [--load-budget <ms>]
+  himi render <screenId> [--content <dir>] [--scheme dark] [--png [<file>]] [--tree] [--dump-state] [--static] [--live] [--mocks | --no-mocks] [--state <json|file>] [--input <json|file>] [--width <px> | --device <name>] [--rtl] [--load-budget <ms>]
                                            [--remote --app <app> --release <id>]
                                            headless web render + diagnostics (no sim). Default: local content dir.
                                            A bare --png writes .himi/shots/<screenId>.png (what the build board shows).
@@ -72626,7 +72676,8 @@ var USAGE = `himi \u2014 the Himalaya authoring CLI (remote dev loop)
                                            --mocks runs load() against the app's OWN recorded data instead \u2014 dev/net-mocks.json
                                              (what \`himi test --record\` writes) and the config's cms seed rows, as \`himi test\`'s
                                              shots do; no request leaves this machine. With none, it renders the initial state.
-                                             The automatic pictures (init's first look, validate's refresh) use it;
+                                             It is the DEFAULT whenever the app has recorded data (mocks.default in the output);
+                                             --no-mocks renders the offline initial state instead;
                                            --tree adds stable raw structure plus a resolvedRenderTree when hydrated;
                                              --dump-state explicitly includes the full worker snapshot;
                                            --state '{"<svc>":{\u2026}}' injects worker state (render loaded/error states);
@@ -73189,7 +73240,7 @@ var COMMANDS = [
   { name: "ux", summary: "audit or record mobile UX evidence. `audit` checks the public-safe contract, seeded blank acceptance rows, placeholder source copy, app-specific mocks, and iOS/Android audit records. It warns while existing templates migrate; `--strict` promotes missing evidence. `record` stores checks performed on an installed iOS/Android build: `--checks` is required for passed|failed and empty for unavailable, which drove nothing and needs a `--reason` instead. `record` also STAMPS the release it audited (it resolves the id from a build, the same one a push would publish), because an unforced `himi push` of a release with screens refuses when no drive is recorded for THAT release, or when the one that is recorded says `failed` \u2014 the artifact stopped being advice nobody reads (#2955). `unavailable` still satisfies it; only `failed` refuses.", required: "audit [--content <dir>] [--strict] [--json] | record --content <dir> --platform ios|android --status passed|failed|unavailable [--checks back,keyboard,...] [--reason <text>]" },
   { name: "progress", summary: 'the build JOURNAL an agent keeps for the owner while it works. `himi progress "<what changed>" --step <1-8|name> --image <png>` appends one postcard to .himi/progress.jsonl \u2014 the step is one of the customer journey\'s eight (discover, classify, plan, implement, brand, validate, review, download) \u2014 and COPIES each image, content-addressed, into .himi/history/, because .himi/shots/ is overwritten by every render and cleared by every full `himi test`, so a path into it would later show a different picture than the one the owner was sent. --image repeats. With NO --image, the home screen\'s current shot is attached automatically, only when it is no older than the last source change and not the picture the latest journaled postcard already shows \u2014 and never a shot that landed on loading placeholders, an empty or an error state (.himi/shot-states.json): then the newest home picture of the current source that shows content goes on instead (its .himi/history copy, `imageNote` saying so), or none \u2014 except on the HANDOVER card (`--step review`), where a repeat is the point and it attaches anyway; that card\'s output also names the making-of (`makingOf`, .himi/making-of.html, rebuilt when missing or older than the journal so it ends on this card) and its `next` says to hand it to the owner beside the preview link; `imageAttached` in the output says whether the postcard carries a picture (with `imageNote` saying why not, or which picture went on instead), and `--no-image` sends a text-only postcard. --notify also raises a best-effort desktop notification for an owner who stepped away. A bare `himi progress` prints the journal with the current step and elapsed time \u2014 also how an agent recovers its place after its context was compacted. APPROVALS: `--approve <gate> "<what>"` records one the customer just gave (gates: site-create, connect, private-data, draft, promote, push-signing, qa-build) in .himi/approvals.jsonl, and `--done <gate>` / `--drop <gate>` closes it \u2014 an approval is owed until then, and the chat that held it does not survive a new session. `--brief` prints plain text for a session start: the current step, the last postcard, every open approval, and whether this app\'s agent files are stale \u2014 the SessionStart hook `himi agent-init` installs runs exactly this. The CLI also journals milestones by itself \u2014 the first PNG render of the home screen (for an app a current `himi init` started: once as the template\'s "Starting point" while the source is what init wrote, then once as "First look at your app" after it diverges, Markdown edits not counting; once per app otherwise), a `himi test` crawl whose outcome changed since the last one (its counts or its home picture; an identical re-run writes none, and a repeat names what changed: "The home screen changed since the last crawl." or the changed counts, was \u2192 now), every draft push (with the home picture only when that shot is newer than the last source edit \u2014 otherwise the postcard says why and names `himi render <home> --png`), and ONE rule for a long silence: a successful home `render --png` more than ten minutes after the newest postcard of any kind, with a picture the latest postcard does not show, journals "Still building: here\'s the home screen now." with it (never twice within the window). When a crawl\'s or a draft\'s home picture is the first of an app whose source diverged, "First look at your app" is journaled first, from that shot, once. All are marked `"by": "himi"`; they never move the journey step, carry no link or credential, and step aside (folded out of every reader) when the agent journals the same step or picture within five minutes. Local only: nothing is sent anywhere.', required: '["<message>" [--step <1-8|name>] [--image <png>]\u2026 [--no-image] [--notify]] [--content <dir>] | --approve|--done|--drop <gate> ["<note>"] | --brief' },
   { name: "studio", summary: "open the BUILD BOARD \u2014 one local page the owner can leave open while an agent builds their app, which fills itself in: every screen as it renders (NEW/CHANGED badges, and each earlier version kept for a filmstrip), the journey stepper and the latest postcard from `himi progress`, the validate/test/UX/draft checks as they run, the site next to the app's home screen with its palette, and the navigation the test crawl followed. Writes .himi/studio/index.html and opens it; the page re-reads its state every two seconds, so nothing needs to be served. OPT-IN BY EXISTENCE: until this command (or `himi init`, which makes the board for every app it creates, without opening a browser) has run, no other command touches .himi/studio/ \u2014 after it, render/test/validate/push/icon/site/ux/progress each refresh the board as they finish (best-effort; never fails a command). Every image is a content-addressed copy in .himi/history/, never a live path into .himi/shots/. Local only, no secrets: it never reads a preview token, handover code or control token. --no-open prints the path instead (SSH, CI). `himi studio reel` writes the MAKING-OF: one self-contained HTML file (every image inlined, nothing fetched) with a flipbook of the home screen version by version, captioned by the postcard in effect at the time, the final screens, and every postcard \u2014 sized to stay attachable, thinning frames first. Defaults to .himi/making-of.html (never archived by push), which every successful `himi push --draft` also rebuilds and names as `reel` in its output; --out to put it elsewhere. The output names that file as the one to hand the owner (`handover: {file, hint}` in JSON; two plain lines at a terminal) \u2014 beside the preview link, never instead of it.", required: "[--content <dir>] [--no-open] | reel [--out <file>] [--no-open]" },
-  { name: "render", summary: "headless-render a screen with the web renderer: render-tree + diagnostics, optional --png [<file>] (bare: .himi/shots/<id>.png, what the build board shows), --scheme dark, --tree. Local by default (content dir). Pass --remote --app --release to hit GET /v1/preview/\u2026/render on the serve plane after a push. Boots the worker so $service bindings resolve; --static raw bindings; --live real Wix fetches; --mocks runs load() against the app's own recorded data (dev/net-mocks.json from `himi test --record`, then the config's cms seed rows \u2014 hermetic, never a request; with neither it paints the initial state, and `mocks: {used: false}` says why), which is what the automatic pictures use, so they show the app's content instead of its offline placeholders; --state injects worker state; --input supplies pre-boot navigation params; --width/--device for PNG viewport; --rtl for dir=rtl + $env:isRTL.", required: "<screenId> [--content <dir>] [--scheme dark] [--png [<file>]] [--tree] [--static] [--live] [--mocks] [--state <json|file>] [--input <json|file>] [--width <px> | --device <name>] [--rtl] [--remote --app --release]" },
+  { name: "render", summary: "headless-render a screen with the web renderer: render-tree + diagnostics, optional --png [<file>] (bare: .himi/shots/<id>.png, what the build board shows), --scheme dark, --tree. Local by default (content dir). Pass --remote --app --release to hit GET /v1/preview/\u2026/render on the serve plane after a push. Boots the worker so $service bindings resolve; --static raw bindings; --live real Wix fetches; --mocks (the DEFAULT whenever the app has recorded data; --no-mocks for the offline initial state) runs load() against the app's own recorded data (dev/net-mocks.json from `himi test --record`, then the config's cms seed rows \u2014 hermetic, never a request; with neither it paints the initial state, and `mocks: {used: false}` says why), which is what the automatic pictures use, so they show the app's content instead of its offline placeholders; --state injects worker state; --input supplies pre-boot navigation params; --width/--device for PNG viewport; --rtl for dir=rtl + $env:isRTL.", required: "<screenId> [--content <dir>] [--scheme dark] [--png [<file>]] [--tree] [--static] [--live] [--mocks | --no-mocks] [--state <json|file>] [--input <json|file>] [--width <px> | --device <name>] [--rtl] [--remote --app --release]" },
   { name: "cms", summary: "inspect, provision, and seed the app's CMS (Wix Data) collections, declared as a `cms` block in config.ts. `query` is READ-ONLY \u2014 by default it fetches ONLY the physical ids `config.ts` declares (item counts + schema drift) and reports `siteScanned: false`; it never lists the site, so an UNDECLARED `himi_<app>_` collection this app owns is not reached without `--all`. `--all` SCANS the site \u2014 every collection it lists is labeled `owned`/`adopted`/`foreign`, and it describes every foreign one \u2014 id, non-system field keys + types, and the site's read role \u2014 so an app with no `cms` block at all can DISCOVER a collection to adopt (`--all` is the one case where a missing `cms` block is not 'nothing to do'). Foreign collections are described up to a cap and are never item-counted (`itemCount: null`), because a row count is one query each; `foreign.count` is how many the scan LISTED \u2014 it follows the list endpoint's pages, and `listingIncomplete: true` says when the walk stopped short of the end, with `unlistedCollections` counting what it left out when Wix gave a paging total \u2014 and `foreign.truncated` says how many of those went undescribed, each still NAMED in `foreign.others` (id + displayName), so a collection the site already has is never hidden behind the cap. The scan is OWNER-scoped \u2014 it needs --site <msid> (or WIX_SITE_ID) plus owner auth via `wix token`; a visitor token can read a public collection's ITEMS but can never enumerate collections, so there is no tokenless discovery path. `create` reconciles declared collections additively and idempotently, and REFUSES any id outside the app's `himi_<app>_` namespace, so it is safe against a production site. It reports declared-vs-site `permissionDrift` but never writes permissions unless asked with --apply-permissions, so a field reconcile can't silently revert access control changed in the dashboard. `seed` inserts the git-tracked `seed:` rows into EMPTY owned collections (--force to add to a non-empty one; --ai writes placeholder rows plus a refinement prompt for you to review). Adopted collections (declared by `wixId`) are read-only and never created, updated, or seeded. Site from --site <msid> or WIX_SITE_ID; owner auth via `wix token`.", required: "query|create|seed [--site <msid>] [--content <dir>] [--all] [--dry-run] [--force] [--allow-destructive] [--apply-permissions] [--only <id>] [--ai] [--count <n>]" },
   { name: "data", summary: "read-only plan or explicitly provision/seed declared KV and Wix Data resources. Preview and production are separate scopes. KV administration uses the operator data plane from --data-url/HIMI_DATA_ADMIN_URL and HIMI_DATA_ADMIN_TOKEN; draft push never calls it.", required: "plan|create|seed [--site <msid>] [--environment preview|production] [--content <dir>] [--data-url <url>] [--dry-run] [--force]" },
   { name: "icons", summary: "list the valid Icon.name vocabulary (an unknown name renders a fallback glyph; validate warns on unknown names) (offline)", required: "[--json]" },
@@ -75779,7 +75830,8 @@ ${doNow.map((l) => `  ${l}`).join("\n")}`);
           loader: loaderArgs(process.execArgv)
         });
         const { postcard: picturePostcard, ...picture } = homePicture;
-        print({ ...finalReport, homePicture: picture, ...picturePostcard ? { postcard: picturePostcard } : {} });
+        const validateReminder = process.env.HIMI_AUTO_RENDER ? void 0 : (await Promise.resolve().then(() => (init_milestones(), milestones_exports))).watchReminder(dir, { content: str9(flags.content) });
+        print({ ...finalReport, homePicture: picture, ...picturePostcard ? { postcard: picturePostcard } : {}, ...validateReminder ? { reminder: validateReminder } : {} });
         return hasErrors ? 1 : 0;
       }
       case "functions": {
@@ -76107,7 +76159,8 @@ ${handover.hint[0].toUpperCase()}${handover.hint.slice(1)}.`);
           const { count: count2 } = summarizeProgress2(readProgress2(dir).entries);
           const imageAttached = (entry.images?.length ?? 0) > 0;
           const handed = handover && isContentPackage ? (await Promise.resolve().then(() => (init_milestones(), milestones_exports))).afterHandoverPostcard(dir, { content: str9(flags.content) }) : null;
-          print({ ok: true, entry, journal: journal2, count: count2, imageAttached, ...imageNote ? { imageNote } : {}, ...notified === void 0 ? {} : { notified }, ...handed ? { makingOf: handed.makingOf, next: handed.next } : {}, ...hint });
+          const progressReminder = isContentPackage ? (await Promise.resolve().then(() => (init_milestones(), milestones_exports))).watchReminder(dir, { content: str9(flags.content) }) : void 0;
+          print({ ok: true, entry, journal: journal2, count: count2, imageAttached, ...imageNote ? { imageNote } : {}, ...notified === void 0 ? {} : { notified }, ...handed ? { makingOf: handed.makingOf, next: handed.next } : {}, ...hint, ...progressReminder ? { reminder: progressReminder } : {} });
           return 0;
         } catch (e) {
           if (e instanceof ProgressError2) {
@@ -76633,6 +76686,10 @@ ${[...afterRun.next, ...testReminder ? [testReminder] : []].join("\n")}`);
           io.error(JSON.stringify({ error: `--mocks and ${live2 ? "--live" : "--static"} are mutually exclusive: --mocks loads the app's recorded data, ${live2 ? "--live real Wix data" : "--static no data at all"}` }));
           return 2;
         }
+        if (flags.mocks === true && flags["no-mocks"] === true) {
+          io.error(JSON.stringify({ error: "--mocks and --no-mocks are mutually exclusive" }));
+          return 2;
+        }
         let injectedState;
         if (flags.state !== void 0) {
           const stateArg = str9(flags.state);
@@ -76705,7 +76762,8 @@ ${[...afterRun.next, ...testReminder ? [testReminder] : []].join("\n")}`);
         }
         let mocks;
         let mocksNote;
-        if (flags.mocks === true) {
+        const mocksByDefault = flags.mocks !== true && flags["no-mocks"] !== true && !live2 && flags.static !== true && injectedState === void 0;
+        if (flags.mocks === true || mocksByDefault) {
           let rules = null;
           let bad2;
           try {
@@ -76717,7 +76775,7 @@ ${[...afterRun.next, ...testReminder ? [testReminder] : []].join("\n")}`);
           const seeded = cmsSeed && Object.keys(cmsSeed).length ? cmsSeed : null;
           const picked = renderMocksFrom(rules, bad2, seeded);
           mocks = picked.mocks;
-          mocksNote = picked.note;
+          if (!mocksByDefault || bad2) mocksNote = picked.note;
         }
         const { buildContentBundles: buildContentBundles2, buildReleaseFromContent: buildReleaseFromContent2, bundleOutDir: bundleOutDir2 } = await loadAuthoring();
         const bres = await buildContentBundles2(dir, { resolution: resolutionFlag(flags) });
@@ -76759,7 +76817,7 @@ ${[...afterRun.next, ...testReminder ? [testReminder] : []].join("\n")}`);
           hydrated: live2 ? "live" : hydrate,
           dataSource: renderDataSource({ live: live2, hydrate, liveCalls: r.liveCalls, liveReturned: r.liveReturned, mocked: !!r.mockCalls }),
           // What --mocks loaded from, how many requests the load made, and the ones no layer held.
-          ...r.mockCalls && mocks ? { mocks: { used: true, from: mocks.from, calls: r.mockCalls.length, ...r.mockUnserved?.length ? { unserved: r.mockUnserved } : {}, ...mocks.ignored ? { ignored: mocks.ignored } : {} } } : mocksNote ? { mocks: mocksNote } : mocks ? { mocks: { used: false, reason: r.mockBootFailed ? "the screen's worker failed to boot against the recorded data, so its initial state was rendered" : "the screen has no worker bundle to load data into", ...mocks.ignored ? { ignored: mocks.ignored } : {} } } : {},
+          ...r.mockCalls && mocks ? { mocks: { used: true, from: mocks.from, calls: r.mockCalls.length, ...r.mockUnserved?.length ? { unserved: r.mockUnserved } : {}, ...mocks.ignored ? { ignored: mocks.ignored } : {}, ...mocksByDefault ? { default: true, hint: "the app's recorded data loaded by default; --no-mocks renders the offline initial state, --live the real site" } : {} } } : mocksNote ? { mocks: mocksNote } : mocks ? { mocks: { used: false, reason: r.mockBootFailed ? "the screen's worker failed to boot against the recorded data, so its initial state was rendered" : "the screen has no worker bundle to load data into", ...mocks.ignored ? { ignored: mocks.ignored } : {} } } : {},
           ...live2 ? {
             liveCalls: r.liveCalls?.length ?? 0,
             // Beside the attempt count, because the two coming apart IS the signal (#1883).

package/guides/headless-loop.md

@@ -111,7 +111,8 @@ when that shot is newer than the last source edit, or else the reason and the `h
 whose picture is new ("Still building: here's the home screen now."). A passing `himi validate` after a source change
 refreshes the home picture itself (the same offline render, bounded to 30 seconds, never for an unread `--remote`
 template; reported as `homePicture`), and an unchanged `himi test` crawl's home shot counts too, so a long stretch of edits,
-validates and crawls still reaches the owner. Those automatic renders are `himi render <home> --mocks --png`: the worker's
+validates and crawls still reaches the owner. Those automatic renders are `himi render <home> --mocks --png`, and so is
+your own `himi render --png` whenever the app has recorded data (`--no-mocks` for the offline one): the worker's
 load runs against the app's own recorded data — `dev/net-mocks.json` (`himi test --record` writes it), then the config's
 cms seed rows — as `himi test`'s shots do, never a request, so the picture shows content; record the site's data once
 and every automatic picture after it shows the app as it works. When the home picture a postcard carries landed on an error, loading or

package/guides/himi-test.md

@@ -205,11 +205,13 @@ every write refused at the transport) — then crawls hermetically on what it fr
 every run; record against a **QA site**, never production. See
 `docs/dev-network-gateway.md` for the record→freeze machinery.
 
-**The pictures use it too.** `himi render <id> --png --mocks` runs the worker's load against the
-same recorded data — `dev/net-mocks.json`, then the config's cms seed rows, never the canned
-fixture and never a request — so a data-driven screen paints its content instead of its offline
-placeholders. The automatic pictures (`himi init`'s first look, `himi validate`'s refresh) are
-that render. A picture painted without the site's data — the initial state, or a load in which a
+**The pictures use it too.** `himi render <id> --png` runs the worker's load against the same
+recorded data whenever the app has some — `dev/net-mocks.json`, then the config's cms seed rows,
+never the canned fixture and never a request — so a data-driven screen paints its content instead
+of its offline placeholders. It is the default (`mocks.default` in the output); `--mocks` asks for
+it explicitly, `--no-mocks` renders the offline initial state, and `--live`, `--static` and
+`--state` each render the data they name instead. The automatic pictures (`himi init`'s first look,
+`himi validate`'s refresh) are that render. A picture painted without the site's data — the initial state, or a load in which a
 request found no recorded data (a shot's `offline` flag in `.himi/shot-states.json`) — is
 captioned as an offline preview, never as the app failing.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1134.0",
+  "version": "0.1135.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": [
@@ -67,5 +67,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "b114c871da4cb1b2f6f20b7a14c5d491c36f951d089ce10a23f5ca76"
+  "falconPackageHash": "708ea7531c66305a8eece0a6f7cffeefca465601cdfac12eb39a0f14"
 }