@wix/himalaya-cli 0.1578.0 → 0.1580.0

package/dist/quickjs-worker-entry.js

@@ -0,0 +1,313 @@
+// ../../core/dev-server/src/quickjs-worker-entry.ts
+import { parentPort, workerData } from "node:worker_threads";
+import { pathToFileURL } from "node:url";
+var CTL_READY = 0;
+var CTL_LEN = 1;
+var CTL_SEQ = 2;
+var CTL_WORDS = 4;
+var DATA_OFFSET = CTL_WORDS * 4;
+var sessions = /* @__PURE__ */ new Map();
+var { sab, intlPath, webGlobalsPath } = workerData;
+var webGlobalsInstaller = null;
+async function installWebGlobalsInto(ctx) {
+  webGlobalsInstaller ??= (await import(pathToFileURL(webGlobalsPath).href)).installWebGlobals;
+  webGlobalsInstaller(ctx);
+}
+var intlInstaller = null;
+async function installIntlInto(ctx) {
+  intlInstaller ??= (await import(pathToFileURL(intlPath).href)).installIntl;
+  intlInstaller(ctx);
+}
+var ctl = new Int32Array(sab, 0, CTL_WORDS);
+var data = new Uint8Array(sab, DATA_OFFSET);
+var decoder = new TextDecoder();
+var crossingSeq = 0;
+function crossToHost(kind, method, path, body, waitMs, headers = "") {
+  const mine = ++crossingSeq;
+  const deadline = Date.now() + waitMs;
+  Atomics.store(ctl, CTL_SEQ, 0);
+  Atomics.store(ctl, CTL_READY, 0);
+  parentPort.postMessage({ want: { kind, method, path, body, headers, seq: mine } });
+  for (; ; ) {
+    const left = deadline - Date.now();
+    if (left <= 0) {
+      return JSON.stringify({ ok: false, e: `the host transport did not answer within ${waitMs}ms` });
+    }
+    const res = Atomics.wait(ctl, CTL_READY, 0, left);
+    if (res === "timed-out") {
+      return JSON.stringify({ ok: false, e: `the host transport did not answer within ${waitMs}ms` });
+    }
+    if (Atomics.load(ctl, CTL_SEQ) !== mine) {
+      Atomics.store(ctl, CTL_READY, 0);
+      continue;
+    }
+    const len = Atomics.load(ctl, CTL_LEN);
+    if (len < 0 || len > data.length) {
+      return JSON.stringify({ ok: false, e: `the host transport returned an out-of-range length (${len})` });
+    }
+    return decoder.decode(data.subarray(0, len));
+  }
+}
+var modulePromise = null;
+async function realmModule() {
+  modulePromise ??= (async () => {
+    const { newQuickJSWASMModuleFromVariant } = await import("quickjs-emscripten");
+    const variant = await import("@jitl/quickjs-wasmfile-release-sync");
+    return newQuickJSWASMModuleFromVariant(variant.default ?? variant);
+  })();
+  return modulePromise;
+}
+async function boot(msg) {
+  const mod = await realmModule();
+  const runtime = mod.newRuntime();
+  runtime.setMemoryLimit(msg.memoryLimitBytes);
+  let deadline = Date.now() + (msg.timeoutMs > 0 ? msg.timeoutMs : 2e3);
+  let waiting = false;
+  runtime.setInterruptHandler(() => !waiting && Date.now() > deadline);
+  const ctx = runtime.newContext();
+  let keepAlive = false;
+  try {
+    const host = ctx.newFunction("__himiWixCall", (mH, pH, bH, hH) => {
+      waiting = true;
+      try {
+        const answer = crossToHost(
+          "wix",
+          ctx.getString(mH),
+          ctx.getString(pH),
+          ctx.getString(bH),
+          // An explicit per-crossing budget when the caller set one; otherwise the remaining boot
+          // time, floored, so a stalled transport still surfaces as a rejected call rather than as
+          // the whole boot timing out with no attribution.
+          msg.answerTimeoutMs !== void 0 ? msg.answerTimeoutMs : Math.max(1e3, deadline - Date.now()),
+          // `undefined` when the guest called with three arguments, which every caller did
+          // before per-call site scope existed.
+          hH === void 0 ? "" : ctx.getString(hH)
+        );
+        return ctx.newString(answer);
+      } finally {
+        waiting = false;
+      }
+    });
+    ctx.setProp(ctx.global, "__himiWixCall", host);
+    host.dispose();
+    const dispatchHost = ctx.newFunction("__himiDispatch", (aH, pH) => {
+      waiting = true;
+      try {
+        const answer = crossToHost(
+          "dispatch",
+          "",
+          ctx.getString(aH),
+          ctx.getString(pH),
+          msg.answerTimeoutMs !== void 0 ? msg.answerTimeoutMs : Math.max(1e3, deadline - Date.now())
+        );
+        return ctx.newString(answer);
+      } finally {
+        waiting = false;
+      }
+    });
+    ctx.setProp(ctx.global, "__himiDispatch", dispatchHost);
+    dispatchHost.dispose();
+    const pre = ctx.evalCode(msg.prelude, "himi-sandbox.js");
+    if (pre.error) {
+      const detail = ctx.dump(pre.error);
+      pre.error.dispose();
+      throw new Error(`sandbox prelude failed: ${String(detail?.message ?? detail)}`);
+    }
+    const bridge = pre.value;
+    const readback = ctx.getProp(bridge, "readback");
+    const dispatch2 = ctx.getProp(bridge, "dispatch");
+    const actionsReadback = ctx.getProp(bridge, "actions");
+    bridge.dispose();
+    if (msg.webGlobals && !msg.hide?.length) await installWebGlobalsInto(ctx);
+    if (msg.intl) await installIntlInto(ctx);
+    let bundleThrow = null;
+    try {
+      const res = ctx.evalCode(msg.bundleJs, msg.filename);
+      if (res.error) {
+        const detail = ctx.dump(res.error);
+        res.error.dispose();
+        bundleThrow = String(detail?.message ?? detail);
+      } else {
+        res.value.dispose();
+      }
+      let actions = "[]";
+      let sweepError = null;
+      try {
+        actions = drain(ctx, runtime, msg.skipLoad ? "himi.quickjs.actions" : "himi.quickjs.loads");
+      } catch (e) {
+        sweepError = String(e?.message ?? e);
+      }
+      const services = readbackJson(ctx, readback);
+      sessions.set(msg.id, {
+        runtime,
+        ctx,
+        dispatch: dispatch2,
+        actions: actionsReadback,
+        setDeadline(timeoutMs) {
+          deadline = Date.now() + (timeoutMs > 0 ? timeoutMs : 2e3);
+        }
+      });
+      keepAlive = true;
+      return { actions, error: bundleThrow ?? sweepError ?? void 0, console: services, sessionId: msg.id };
+    } finally {
+      readback.dispose();
+      if (!keepAlive) {
+        dispatch2.dispose();
+        actionsReadback.dispose();
+      }
+    }
+  } finally {
+    if (!keepAlive) {
+      try {
+        ctx.dispose();
+      } catch {
+      }
+      try {
+        runtime.dispose();
+      } catch {
+      }
+    }
+  }
+}
+function dispatch(msg) {
+  const session = sessions.get(msg.sessionId);
+  if (!session) throw new Error("the contained guest session is no longer available");
+  session.setDeadline(msg.timeoutMs);
+  const service = session.ctx.newString(msg.service);
+  const action = session.ctx.newString(msg.action);
+  const args = session.ctx.newString(msg.argsJson);
+  try {
+    const called = session.ctx.callFunction(
+      session.dispatch,
+      session.ctx.undefined,
+      service,
+      action,
+      args,
+      typeof msg.online === "boolean" ? msg.online ? session.ctx.true : session.ctx.false : session.ctx.undefined
+    );
+    if (called.error) {
+      const detail = session.ctx.dump(called.error);
+      called.error.dispose();
+      throw new Error(`the guest dispatch could not be started: ${String(detail?.message ?? detail)}`);
+    }
+    settlePromise(session.ctx, session.runtime, called.value, "guest dispatch");
+    drainDetachedJobs(session.ctx, session.runtime);
+    return { actions: readbackJson(session.ctx, session.actions) };
+  } finally {
+    service.dispose();
+    action.dispose();
+    args.dispose();
+  }
+}
+function release(sessionId) {
+  const session = sessions.get(sessionId);
+  if (!session) return;
+  sessions.delete(sessionId);
+  try {
+    session.dispatch.dispose();
+  } catch {
+  }
+  try {
+    session.actions.dispose();
+  } catch {
+  }
+  try {
+    session.ctx.dispose();
+  } catch {
+  }
+  try {
+    session.runtime.dispose();
+  } catch {
+  }
+}
+function drain(ctx, runtime, trigger) {
+  const trig = ctx.evalCode(`globalThis[${JSON.stringify(trigger)}]`, "himi-actions.js");
+  if (trig.error) {
+    const detail = ctx.dump(trig.error);
+    trig.error.dispose();
+    throw new Error(`the guest load sweep could not be started: ${String(detail?.message ?? detail)}`);
+  }
+  return settlePromise(ctx, runtime, trig.value, "guest load sweep");
+}
+function settlePromise(ctx, runtime, promise, label) {
+  try {
+    for (let i = 0; i < MAX_PUMP_ROUNDS; i++) {
+      const state = ctx.getPromiseState(promise);
+      if (state.type === "fulfilled") {
+        const out = String(ctx.dump(state.value));
+        state.value.dispose();
+        return out;
+      }
+      if (state.type === "rejected") {
+        const detail = ctx.dump(state.error);
+        state.error.dispose();
+        throw new Error(`the ${label} failed: ${String(detail?.message ?? detail)}`);
+      }
+      state.value?.dispose?.();
+      const pending = runtime.executePendingJobs();
+      if (pending.error) {
+        const detail = ctx.dump(pending.error);
+        pending.error.dispose();
+        throw new Error(`a guest job threw during the load sweep: ${String(detail?.message ?? detail)}`);
+      }
+      if (pending.value === 0) {
+        const ticked = ctx.evalCode(`globalThis["himi.quickjs.tick"]`, "himi-tick.js");
+        if (ticked.error) {
+          const detail = ctx.dump(ticked.error);
+          ticked.error.dispose();
+          throw new Error(`the guest timer pump failed: ${String(detail?.message ?? detail)}`);
+        }
+        const fired = ctx.dump(ticked.value) === true;
+        ticked.value.dispose();
+        if (fired) continue;
+        throw new Error(
+          `the ${label} is pending with no runnable jobs \u2014 a worker awaited something the sandbox never resolves (a capability this realm does not provide)`
+        );
+      }
+    }
+    throw new Error(`the ${label} did not settle within ${MAX_PUMP_ROUNDS} job rounds`);
+  } finally {
+    promise.dispose();
+  }
+}
+function drainDetachedJobs(ctx, runtime) {
+  for (let i = 0; i < MAX_PUMP_ROUNDS; i++) {
+    const pending = runtime.executePendingJobs();
+    if (pending.error) {
+      const detail = ctx.dump(pending.error);
+      pending.error.dispose();
+      throw new Error(`a nested guest job threw after dispatch: ${String(detail?.message ?? detail)}`);
+    }
+    if (pending.value === 0) {
+      const ticked = ctx.evalCode(`globalThis["himi.quickjs.tick"]`, "himi-tick.js");
+      if (ticked.error) {
+        const detail = ctx.dump(ticked.error);
+        ticked.error.dispose();
+        throw new Error(`the nested guest timer pump failed: ${String(detail?.message ?? detail)}`);
+      }
+      const fired = ctx.dump(ticked.value) === true;
+      ticked.value.dispose();
+      if (!fired) return;
+    }
+  }
+  throw new Error(`nested guest actions did not quiesce within ${MAX_PUMP_ROUNDS} job rounds`);
+}
+var MAX_PUMP_ROUNDS = 1e4;
+parentPort.on("message", (msg) => {
+  if ("end" in msg) {
+    process.exit(0);
+  }
+  const operation = msg.kind === "warm" ? realmModule().then(() => ({})) : msg.kind === "boot" ? boot(msg) : msg.kind === "dispatch" ? Promise.resolve(dispatch(msg)) : Promise.resolve((release(msg.sessionId), {}));
+  operation.then((r) => parentPort.postMessage({ id: msg.id, ...r })).catch((e) => parentPort.postMessage({ id: msg.id, error: String(e?.message ?? e) }));
+});
+function readbackJson(ctx, readback) {
+  const called = ctx.callFunction(readback, ctx.undefined);
+  if (called.error) {
+    const detail = ctx.dump(called.error);
+    called.error.dispose();
+    throw new Error(String(detail?.message ?? detail));
+  }
+  const dumped = ctx.dump(called.value);
+  called.value.dispose();
+  return String(dumped);
+}

package/guides/himi-json-output.md

@@ -6,7 +6,7 @@ repurposed when human wording changes. New codes may be added; consumers must
 handle an unknown code as a failure, without parsing prose.
 
 **Rollout:** this contract is enforced for **`himi push`**, including `--only`,
-first, for **`himi store iap connect`**, for **`himi site member-app`**, for **`himi fidelity`**, for the **`himi base44`** entity and function verbs, and for **`himi l10n import`**. Other subcommands still have legacy failures without codes and are a
+first, for **`himi publish-size`**, for **`himi store iap connect`**, for **`himi site member-app`**, for **`himi fidelity`**, for the **`himi base44`** entity and function verbs, and for **`himi l10n import`**. Other subcommands still have legacy failures without codes and are a
 follow-up migration. This is an additive change: existing `error`, `errors`,
 `message`, `hint`, status, body, and gate-specific fields stay as they were.
 Some legacy envelopes have no singular `error` or `hint`; consumers must not
@@ -47,6 +47,22 @@ keeps its existing fields and adds the code:
 | `source_icon_unavailable` | Verified source evidence or its logo is missing, unreadable, unavailable, over the download/decoding budget, or cannot be normalized. |
 | `source_icon_unusable` | The prepared source mark fails mechanical launcher/store checks. Existing icon files and metadata are left unchanged. |
 
+## `himi publish-size` codes
+
+This local planning command never claims or publishes. Every failure includes
+`pushed: false` and `claimed: false`.
+
+| Code | Meaning |
+| --- | --- |
+| `invalid_usage` | Unsupported, repeated, missing or invalid measurement options (exit 2). Publishing flags are refused. |
+| `build_failed` | The contained local release could not be built completely, required host/network access, or the isolated build failed; measuring missing screens or bundles would undercount (exit 1). |
+| `app_source_contains_secrets` | The shared source scanner found possible credentials (exit 1). |
+| `app_source_too_large` | The base64 source archive exceeds its independent limit (exit 1). |
+| `publish_body_too_large` | Measured draft JSON plus the explicit metadata planning reserve exceeds the publish budget (exit 1). `bodyBytes` and `overageBytes` describe the measured envelope; `planningBytes` and `planningOverageBytes` also include the reserve. |
+
+`ok: true` means the measured draft plus its reserve fits. It does not certify
+publication readiness or bound metadata not yet supplied to the final push.
+
 ## `himi one-app validate-payments` codes
 
 | Code | Meaning |
@@ -58,6 +74,19 @@ keeps its existing fields and adds the code:
 The checker validates recorded evidence and decisions; it does not independently
 verify merchant readiness or create transactions. General publication remains unchanged.
 
+## `himi one-app validate-identity` codes
+
+| Code | Meaning |
+| --- | --- |
+| `invalid_usage` | Missing, repeated or unsupported identity-check arguments. |
+| `identity_source_unverified` | Collected source hashes or the business display name cannot be verified. Recollect older evidence that did not save business identity. |
+| `identity_target_unverified` | The technical app slug, target compilation or complete built descriptors are unavailable. |
+| `literal_slug_visible` | Built display text or the known business-chat identity seed contains the technical slug instead of the collected business identity, without matching exact authored source copy. |
+
+The check reads built descriptors, not every possible runtime string. A passing
+result does not verify dynamic live data, translations, branding images or device
+appearance. It does not change publication or coverage policy.
+
 ## Push codes
 
 | Code | Meaning |

package/guides/one-app-section-mappings.md

@@ -16,7 +16,7 @@ Use this companion to the [Structure inference guide](https://apps.wix.com/_api/
 - Existing screen builders often return a complete screen. Preserve the source inline placement using supported composition; do not replace a mixed source screen with an unrelated full vertical screen.
 - Map data selectors, labels/media, design, permissions, CTA parameters and target destinations. The source definition's `settingsData.componentId` identifies a source editor component, not a Himalaya implementation or a complete settings schema.
 
-Source snapshots: Catalyst `617c06d43d2a5608b6876d724553269b1e5346f0`; Himalaya `97f1542f2f7d6e8cb7a902b912c87dcaa37e5a67`. GitHub references are pinned to these inspected versions. Recheck implementation contracts if using another version. No customer data was fetched, no app was generated, and no parity tests were run for this documentation inventory.
+Source snapshots: Catalyst `617c06d43d2a5608b6876d724553269b1e5346f0`; Himalaya `97f1542f2f7d6e8cb7a902b912c87dcaa37e5a67`. GitHub references are pinned to these inspected versions. Recheck implementation contracts if using another version. No customer data was fetched, no app was generated, and no parity tests were run for the original documentation inventory. The Pages row now links the current source-selected editorial reconstruction recipe; its capture/decoder tests do not certify an individual app’s parity.
 
 ## Coverage summary
 
@@ -24,9 +24,9 @@ Source snapshots: Catalyst `617c06d43d2a5608b6876d724553269b1e5346f0`; Himalaya
 | --- | ---: |
 | Module | 13 |
 | Primitive | 7 |
-| Composition | 8 |
+| Composition | 9 |
 | Partial | 24 |
-| Empty | 25 |
+| Empty | 24 |
 | Total | 77 |
 
 ## Mappings by server group
@@ -51,6 +51,32 @@ The **Himalaya implementation** cell is blank for every unassigned row. Notes on
 | `achievements_carousel_section` | `wix-one-app-achievements.MemberChallengesCarousel` | [Programs data/detail](https://github.com/wix-private/himalaya/blob/97f1542f2f7d6e8cb7a902b912c87dcaa37e5a67/core/dev-server/tier5-bundles-src/himi-branded-lite-programs/index.ts "audience-lint-ok: optional pinned upstream evidence, not a local authoring dependency") + [Core Carousel](https://github.com/wix-private/himalaya/blob/97f1542f2f7d6e8cb7a902b912c87dcaa37e5a67/core/dev-server/src/builder.ts "audience-lint-ok: optional pinned upstream evidence, not a local authoring dependency") | Existing base; adaptation needed | Partial | Reuse the Programs feature and compose a carousel; preserve source extraProps.limit=5 and selected programs. No ready-made legacy Challenges carousel adapter is claimed. |
 | `achievements_participant_carousel_section` | `wix-one-app-achievements.ParticipantChallengesCarousel` |  |  | Empty | The public Programs catalog is not a member-participating-programs carousel. No verified consumer participant/progress list implementation was found. |
 
+For authored Programs sections, pass the source settings as a JSON string in the
+`programsSection` parameter to `tier5.himiBrandedPrograms.load`:
+
+```js
+const programsSection = JSON.stringify({ settings: {
+  sortingSettings: { ordering: "MANUAL", challengesOrder: ["program-id-b", "program-id-a"] },
+} });
+// Source IDs come from the collected section, never customer-specific constants in a template.
+const onAppear = { actionId: "tier5.himiBrandedPrograms.load", params: { programsSection } };
+```
+
+The worker also reads the same string from navigation input at boot. Preserve it
+in the authored section's onAppear params when forwarding the copy pack. A
+copy-only load or Retry retains the last settings. Sending an explicit empty
+settings object, `DEFAULT`, or an empty manual order restores the complete
+newest-first catalog. Manual ordering puts known configured IDs first, then all
+remaining Programs in catalog order; it is not an inclusion list. Stale and
+repeated IDs add no cards. Each worker instance retains its own source settings.
+The collection's member-selected A–Z/Z–A sort still overrides its default order;
+pass `collectionSort: "default"` when opening a source section that must start in
+source order. The member list (`himi_member_programs`) does not read
+`programsSection` and has no manual order yet. This is an authoring recipe, not an
+automatic section importer.
+Category selection, participant status/counts, display flags, limits, See All and
+carousel placement remain separate gaps; the mappings above stay Partial.
+
 ### 3. bookings-section-definitions.json
 
 [Server definitions](https://github.com/wix-private/catalyst-server/blob/617c06d43d2a5608b6876d724553269b1e5346f0/one-app-sections/one-app-sections-definitions/src/main/resources/sections/bookings-section-definitions.json) · 4 definition(s).
@@ -143,7 +169,7 @@ The **Himalaya implementation** cell is blank for every unassigned row. Notes on
 
 | Source sectionDefinitionId | Source viewer component | Himalaya implementation | Placement / reuse | Class | Settings, actions and gaps |
 | --- | --- | --- | --- | --- | --- |
-| `pages_section` | `Pages.SectionPageClientScreen` |  |  | Empty | No matching Wix Pages content fetch/render adapter was found. Generic CMS or RichContent renderers do not identify the original page entity or its data contract. |
+| `pages_section` | `Pages.SectionPageClientScreen` | [Pages capture recipe](https://apps.wix.com/_api/himi-serve/docs/one-app-to-himi-app.md#referenced-pages-content) / `oneAppPageSection` | Editable inline native RichContent | Composition | Select `settings.value.pageId`; use the collector’s Visitor-only referenced read and `pages-content.json`. Preserve source placement order, text, formatting and links. Ready/empty captures can be reconstructed; missing, forbidden, malformed and unsupported captures remain explicit gaps. This is editorial reconstruction, not a live runtime Pages adapter. |
 
 ### 12. photoalbum-section-definitions.json
 
@@ -332,7 +358,6 @@ These are the exact definitions whose target cells above remain empty. “Not fo
 | `loyalty-section-definitions.json` | `loyalty_status_section` | The existing Loyalty worker lists the program and rewards but does not load this member's points balance/tier/status. A rewards catalog is not a loyalty-status widget. |
 | `referrals-section-definitions.json` | `referrals_refer_section` | No consumer referral-code/link sharing and referral-status feature was found. Do not map to Loyalty or generic sharing without a user decision. A visitor-readable program read exists; see the row above. |
 | `referrals-section-definitions.json` | `referrals_description_section` | No referral-program description/data implementation was found. Text primitives alone do not resolve the business-bound referral content. A visitor-readable program read exists; see the row above. |
-| `pages-section-definitions.json` | `pages_section` | No matching Wix Pages content fetch/render adapter was found. Generic CMS or RichContent renderers do not identify the original page entity or its data contract. |
 | `photoalbum-section-definitions.json` | `photoAlbums_list_section` | Existing Photo Albums code is an empty-state placeholder with no album API wired. Pro Gallery uses a different data source and is not a substitute; choose an implementation explicitly. |
 | `photoalbum-section-definitions.json` | `photoAlbums_photos_list` | Existing Photo Albums code is an empty-state placeholder with no album API wired. Pro Gallery uses a different data source and is not a substitute; choose an implementation explicitly. |
 | `photoalbum-section-definitions.json` | `photoAlbums_carousel_section` | Existing Photo Albums code is an empty-state placeholder with no album API wired. Pro Gallery uses a different data source and is not a substitute; choose an implementation explicitly. |