@wix/himalaya-cli 0.1297.0 → 0.1298.0

package/dist/cli.mjs

@@ -7530,6 +7530,7 @@ function buttonVariant(style) {
 var SYSTEM_FONT_FAMILY, TONAL_ELEVATION_ALPHA, BUTTON_MIN_HIT_TARGET, nonNegative, nonEmpty, own, COLOR_TOKEN_PROPS, TYPOGRAPHY_TOKEN_PROPS, BUTTON_VARIANTS;
 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];
     BUTTON_MIN_HIT_TARGET = 44;
@@ -7585,6 +7586,7 @@ function resolveTranslation(value, catalog3, 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((s2) => s2 !== "t").join("|")})\\b|^\\$t:`

package/guides/index.json

@@ -95,6 +95,18 @@
       "category": "Workers & SDKs",
       "file": "webview-page-sdk.md"
     },
+    {
+      "id": "web-page-native-sdk",
+      "title": "Call native device features from a web page inside a Himi app",
+      "category": "Workers & SDKs",
+      "file": "web-page-native-sdk.md"
+    },
+    {
+      "id": "web-page-sdk-reference",
+      "title": "Web page SDK reference",
+      "category": "Workers & SDKs",
+      "file": "web-page-sdk-reference.md"
+    },
     {
       "id": "component-reference",
       "title": "Component reference",

package/guides/web-page-native-sdk.md

@@ -0,0 +1,286 @@
+# Call native device features from a web page inside a Himi app
+
+This guide is for anyone — a person or a coding agent such as Base44, Lovable or Claude — building
+a web page (React or plain JavaScript) that will be shown **inside** a Himi mobile app, such as a
+Brandy app that wraps a website. From that page you can call the phone's native features: Health
+(HealthKit / Health Connect), haptics, camera, share, location, secure storage and more.
+
+You do **not** install any package. The app injects a small bridge into your page; you paste one
+file (below) that talks to it.
+
+```
+your page → window.HimalayaWorker → the app's companion worker → native iOS / Android
+```
+
+## Before you start: what the app owner must enable
+
+Your page can only use capabilities the **app owner** turned on for your site. In a Brandy app
+that is the `webSdk` block of the app's provisioning file:
+
+```json
+{
+  "webSdk": {
+    "bundle": "my-site-capabilities",
+    "capabilities": ["health", "haptic"],
+    "permissionCopy": {
+      "health": "Show your daily steps and save the workouts you finish."
+    }
+  }
+}
+```
+
+- `capabilities` — the capability ids your page will call (see the
+  [Web page SDK reference](https://apps.wix.com/_api/himi-serve/docs/web-page-sdk-reference.md) for every id and method).
+- `permissionCopy` — the sentence the phone shows when it asks the user for permission. Write it
+  for the end user, about what *they* get.
+- `bundle` — the app's companion worker, which allowlists exactly which methods your page may
+  call. A health-only site can omit it; any other set needs one.
+
+When you hand work to the app owner, give them the list as `capability.method` pairs, for example
+`health.availability`, `health.requestPermission`, `health.query`, `haptic.play`. A method that is
+not on the allowlist never answers — your call times out (see *Errors*).
+
+Your page must be served from the site origin the app was built for. Pages in iframes, and pages
+reached through a redirect to another origin, do not get the bridge.
+
+## Step 1 — add the client file
+
+Create `src/lib/himalaya.ts` with exactly this content. It has no dependencies and works with
+React, Vue, Svelte or plain JavaScript callers. It is TypeScript: Vite-based projects (including
+Lovable and Base44) compile it as is; a project with no TypeScript build step needs it compiled to
+JavaScript first (for example with `npx -p typescript tsc --target es2020 --module esnext himalaya.ts`).
+
+```ts
+// himalaya.ts — call native Himi app capabilities from a web page. No dependencies.
+// Protocol v1: the page posts {v, id, capability, method, args}; the app answers {v, id, ok, result | error}.
+
+type Bridge = { post(message: unknown): boolean; onMessage(handler: (message: unknown) => void): void };
+type Reply = { v: 1; id: string; ok: boolean; result?: unknown; error?: { message: string; code?: string } };
+
+export class HimalayaError extends Error {
+  /** "not_in_app" | "bridge_refused" | "timeout", or the capability's own code (e.g. "not_authorized"). */
+  readonly code: string;
+  constructor(message: string, code: string) {
+    super(message);
+    this.name = "HimalayaError";
+    this.code = code;
+  }
+}
+
+const pending = new Map<string, { resolve(value: unknown): void; reject(error: Error): void; timer: ReturnType<typeof setTimeout> }>();
+let listeningOn: Bridge | undefined;
+let counter = 0;
+
+function bridge(): Bridge | undefined {
+  const candidate = (globalThis as { HimalayaWorker?: Bridge }).HimalayaWorker;
+  if (!candidate || typeof candidate.post !== "function" || typeof candidate.onMessage !== "function") return undefined;
+  if (listeningOn !== candidate) {
+    candidate.onMessage((message) => {
+      const reply = message as Reply;
+      if (!reply || reply.v !== 1 || typeof reply.id !== "string" || typeof reply.ok !== "boolean") return;
+      const call = pending.get(reply.id);
+      if (!call) return;
+      pending.delete(reply.id);
+      clearTimeout(call.timer);
+      if (reply.ok) call.resolve(reply.result);
+      else call.reject(new HimalayaError(reply.error?.message ?? "Native call failed", reply.error?.code ?? "failed"));
+    });
+    listeningOn = candidate;
+  }
+  return candidate;
+}
+
+/** True when the page is running inside a Himi app WebView (false in a normal browser). */
+export function isInHimiApp(): boolean {
+  return bridge() !== undefined;
+}
+
+/** Call one native method, e.g. call("health", "query", [{ type: "steps", from, to }]). */
+export function call<T = unknown>(capability: string, method: string, args: unknown[] = [], timeoutMs = 30_000): Promise<T> {
+  const target = bridge();
+  if (!target) return Promise.reject(new HimalayaError("Not running inside a Himi app", "not_in_app"));
+  const id = `page-${Date.now().toString(36)}-${++counter}`;
+  return new Promise<T>((resolve, reject) => {
+    const timer = setTimeout(() => {
+      pending.delete(id);
+      reject(new HimalayaError(`${capability}.${method} did not answer — is it enabled for this site?`, "timeout"));
+    }, timeoutMs);
+    pending.set(id, { resolve: resolve as (value: unknown) => void, reject, timer });
+    if (!target.post({ v: 1, id, capability, method, args })) {
+      clearTimeout(timer);
+      pending.delete(id);
+      reject(new HimalayaError("The app refused the message (too large or too frequent)", "bridge_refused"));
+    }
+  });
+}
+
+/** True when `capability.method` answers within `timeoutMs`. Use a read-only method. */
+export async function isEnabled(capability: string, method: string, args: unknown[] = [], timeoutMs = 3_000): Promise<boolean> {
+  try {
+    await call(capability, method, args, timeoutMs);
+    return true;
+  } catch (error) {
+    // Only an answer from the app (even an error) proves the method is enabled.
+    return !(error instanceof HimalayaError && ["timeout", "not_in_app", "bridge_refused"].includes(error.code));
+  }
+}
+
+type Namespace = { [method: string]: ((...args: any[]) => Promise<any>) & Namespace };
+
+function member(capability: string, path: string[]): Namespace {
+  return new Proxy(function () {} as unknown as Namespace, {
+    get: (_target, key) => (typeof key === "string" && key !== "then" ? member(capability, [...path, key]) : undefined),
+    apply: (_target, _this, args: unknown[]) => call(capability, path.join("."), args),
+  });
+}
+
+/** himalaya.<capability>.<method>(...args), e.g. himalaya.haptic.play("success"). Always returns a Promise. */
+export const himalaya = new Proxy({} as Record<string, Namespace>, {
+  get: (_target, key) => (typeof key === "string" && key !== "then" ? member(key, []) : undefined),
+});
+```
+
+Keep it as an ES module (`import` / `export`). In a classic `<script>` tag, do not create a global
+named `himalaya` — the app already defines a read-only `window.himalaya`.
+
+## Step 2 — call a capability
+
+Capability ids are snake_case (`health`, `haptic`, `secure_storage`, `local_database`); method
+names are exactly the SDK's function names. Arguments and results are plain JSON.
+
+```ts
+import { himalaya, HimalayaError } from "./lib/himalaya";
+
+// Light, fire-and-forget feedback.
+await himalaya.haptic.play("success");
+
+// Health: check, ask (from a button tap), then read.
+const { available } = await himalaya.health.availability();
+if (available) {
+  await himalaya.health.requestPermission({ read: ["steps"] });
+  const midnight = new Date();
+  midnight.setHours(0, 0, 0, 0);
+  const { samples } = await himalaya.health.query({
+    type: "steps",
+    from: midnight.toISOString(),
+    to: new Date().toISOString(),
+  });
+}
+```
+
+`call("health", "availability")` is the same thing without the proxy, and is handy when the
+capability or method name is a variable.
+
+## Step 3 — React pattern
+
+```tsx
+import { useEffect, useState } from "react";
+import { call, himalaya, isInHimiApp, HimalayaError } from "./lib/himalaya";
+
+export function StepsCard() {
+  const [state, setState] = useState<"checking" | "browser" | "off" | "ready" | "denied" | "failed">("checking");
+  const [steps, setSteps] = useState<number | null>(null);
+
+  useEffect(() => {
+    if (!isInHimiApp()) return setState("browser");
+    // Answering is not enough: a phone without a health store answers { available: false }.
+    call<{ available: boolean }>("health", "availability", [], 3_000)
+      .then(({ available }) => setState(available ? "ready" : "off"))
+      // Not enabled for this site (timeout) hides the feature; any other failure offers a retry.
+      .catch((error) => setState(error instanceof HimalayaError && error.code === "timeout" ? "off" : "failed"));
+  }, []);
+
+  async function connect() {
+    try {
+      await himalaya.health.requestPermission({ read: ["steps"] });
+      const from = new Date(); from.setHours(0, 0, 0, 0);
+      const { samples } = await himalaya.health.query({ type: "steps", from: from.toISOString(), to: new Date().toISOString() });
+      setSteps(samples.reduce((sum: number, s: { value: number }) => sum + s.value, 0));
+      await himalaya.haptic.play("success").catch(() => {});
+    } catch (error) {
+      // Every outcome gets a state: a click handler that rethrows leaves an unhandled rejection.
+      const code = error instanceof HimalayaError ? error.code : "failed";
+      setState(code === "not_authorized" ? "denied" : code === "timeout" || code === "unavailable" ? "off" : "failed");
+    }
+  }
+
+  if (state === "checking") return null;
+  if (state === "browser") return <p>Open this page in our app to see your steps.</p>;
+  if (state === "off") return null; // no health store, or Health not enabled for this site — hide it
+  if (state === "denied") return <p>Health access is off. You can turn it on in your phone's Settings.</p>;
+  if (state === "failed") return <button onClick={connect}>Couldn't load your steps — try again</button>;
+  return steps === null ? <button onClick={connect}>Show today's steps</button> : <p>{steps} steps today</p>;
+}
+```
+
+The same page must keep working in an ordinary browser (and in Base44 / Lovable previews): check
+`isInHimiApp()` and render a fallback instead of calling.
+
+## Rules that keep a page working
+
+- **Ask for permission only from a user action** (a button tap), after explaining the benefit on
+  screen. Never prompt on page load.
+- **Handle "no" and "not available".** Every permission can be denied; Health may not exist on the
+  device (`availability()` tells you). Show a calm fallback, not an error.
+- **Hide features the app doesn't enable.** Probe once with `isEnabled(...)` on a read-only method
+  and hide the UI when it is `false`. `true` only means the method is enabled — still read its
+  answer (`availability()` can say `{ available: false }`).
+- **Plain JSON only.** Arguments and results cross as JSON: no functions, `Date` objects (use ISO
+  strings), `Blob`s or class instances. At most 12 arguments; keep each message under 1 MB.
+- **Don't flood the bridge.** About 50 messages per second is the ceiling; debounce sliders and
+  scroll handlers.
+- **Request/response only.** Methods that return a stream (`AsyncIterable`) or take a callback are
+  not callable from a page — the reference marks them. Poll a read method instead, or ask the
+  app owner for a page-friendly method.
+- **Never put secrets in the page.** The page is public web code; native calls are authorized by
+  the app, not by anything you send.
+
+## Errors
+
+Every failure rejects with a `HimalayaError` that has a `code`:
+
+| `code` | Meaning | What to do |
+|---|---|---|
+| `not_in_app` | Ordinary browser or preview, no bridge | Render the browser fallback |
+| `timeout` | No answer: capability or method not enabled for this site, or not on this app build | Hide the feature; ask the app owner to enable `capability.method` |
+| `bridge_refused` | Message too large or too frequent | Send less, less often |
+| `not_authorized` | The user denied permission | Explain how to enable it in Settings |
+| `unavailable` | Not supported on this device | Hide the feature |
+| `invalid_argument` | Wrong argument shape | Fix the call — check the reference |
+| `failed` / other | The native call failed | Show a retry |
+
+Codes other than the first three come from the capability itself; its reference page lists them.
+
+## Test it
+
+- **In a browser** — `isInHimiApp()` is `false`; confirm your fallback renders.
+- **With a fake bridge** — for unit tests or a design preview, install a fake before your app code
+  runs:
+
+  ```ts
+  const answers: Record<string, unknown> = {
+    "health.availability": { available: true },
+    "health.requestPermission": undefined,
+    "health.query": { samples: [{ value: 4200 }] },
+    "haptic.play": undefined,
+  };
+  let reply: (message: unknown) => void = () => {};
+  (window as any).HimalayaWorker = {
+    post: (m: any) => (setTimeout(() => reply({ v: 1, id: m.id, ok: true, result: answers[`${m.capability}.${m.method}`] })), true),
+    onMessage: (handler: (message: unknown) => void) => { reply = handler; },
+  };
+  ```
+
+  Never ship the fake: a page that defines `HimalayaWorker` itself is lying to its own feature
+  checks.
+- **On a phone** — open the page inside the app build the owner configured. Check each feature
+  once with permission granted and once denied.
+
+## Reference
+
+- [Web page SDK reference](https://apps.wix.com/_api/himi-serve/docs/web-page-sdk-reference.md) — every capability id and the methods a
+  page can call, with signatures.
+- Per-package pages (type definitions and examples; long declarations are abridged there, the
+  reference above lists every callable signature in full): `https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2F<package>`,
+  for example [health](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fhealth) and
+  [haptic](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fhaptic).

package/guides/web-page-sdk-reference.md

@@ -0,0 +1,642 @@
+# Web page SDK reference
+
+Every native capability a web page hosted inside a Himi app can call, and each method's signature
+as the page calls it. How to call them — the client file, permissions, errors, testing — is in
+*Call native device features from a web page inside a Himi app*
+([web-page-native-sdk](https://apps.wix.com/_api/himi-serve/docs/web-page-native-sdk.md)).
+
+A capability or method listed here is callable only when the app owner enabled it for your site;
+otherwise the call times out. Arguments and results are JSON: `Date` values travel as ISO
+strings. Each section ends with the package's functions a page cannot call — local helpers, and
+methods that return a live object, take a callback or push events. Generated from the SDK sources, so it matches the shipped SDKs.
+
+## `app_info`
+
+Tier-5 typed binding for this app's OWN build + OTA metadata. Package `@himalaya/app-info` — type definitions and examples (long declarations abridged; the signatures below are complete): [app-info](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fapp-info).
+
+- `himalaya.app_info.get(): Promise<AppInfo>`
+  Read this app's build + OTA metadata from the host.
+- `himalaya.app_info.displayVersion(): Promise<string>`
+  `"1.2.0 (34)"` — the conventional user-facing version string, or `"1.2.0"` when the build number is missing or identical to the version, and "" when there is no version at all.
+
+## `audio_record`
+
+Tier-5 typed binding for microphone recording. Package `@himalaya/audio-record` — type definitions and examples (long declarations abridged; the signatures below are complete): [audio-record](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Faudio-record).
+
+- `himalaya.audio_record.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.audio_record.requestPermission(): Promise<PermissionStatus>`
+- `himalaya.audio_record.start(options?: { maxSeconds?: number }): Promise<{ started: boolean }>`
+  Begin recording.
+- `himalaya.audio_record.stop(): Promise<AudioRecording | null>`
+  Stop recording and resolve the saved file (substrate FileHandle), or null if nothing was recorded.
+- `himalaya.audio_record.pause(): Promise<{ paused: boolean }>`
+  Pause an in-progress recording; the same file resumes accumulating.
+- `himalaya.audio_record.resume(): Promise<{ resumed: boolean }>`
+  Resume a paused recording into the same file.
+- `himalaya.audio_record.cancel(): Promise<{ cancelled: boolean }>`
+  Stop and discard the in-progress recording.
+- `himalaya.audio_record.startSession(options: { mode?: RecordingMode; chunkSeconds?: number } = {}): Promise<RecordingSession | null>`
+  Start a recoverable recording session.
+- `himalaya.audio_record.getSession(sessionId: string): Promise<RecordingSession | null>`
+- `himalaya.audio_record.listSessions(): Promise<RecordingSession[]>`
+  Enumerate persisted sessions so a worker can discover recoverable work after restart.
+- `himalaya.audio_record.listSegments(sessionId: string, afterSequence = -1): Promise<RecordingSegment[]>`
+- `himalaya.audio_record.stopSession(sessionId: string): Promise<RecordingSession | null>`
+- `himalaya.audio_record.cancelSession(sessionId: string): Promise<boolean>`
+- `himalaya.audio_record.watchStart(sessionId: string, afterSequence = -1): Promise<string | null>`
+- `himalaya.audio_record.watchNext(watchId: string, timeoutMs = 30_000): Promise<RecordingWatchEvent>`
+- `himalaya.audio_record.watchStop(watchId: string): Promise<void>`
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `subscribeLevel`.
+
+## `base44`
+
+Tier-5 typed binding for a Base44 app's backend. Package `@himalaya/base44` — type definitions and examples (long declarations abridged; the signatures below are complete): [base44](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fbase44).
+
+- `himalaya.base44.auth.loginViaEmailPassword(email: string, password: string): Promise<LoginResult>`
+  Sign in with email + password.
+- `himalaya.base44.auth.loginWithProvider(provider: AuthProvider = "google"): Promise<LoginResult>`
+  Sign in with a provider using the native system browser.
+- `himalaya.base44.auth.register(email: string, password: string): Promise<JsonObject>`
+- `himalaya.base44.auth.loginViaOtp(email: string): Promise<JsonObject>`
+  Send a one-time login code to `email`.
+- `himalaya.base44.auth.verifyOtp(email: string, otpCode: string): Promise<LoginResult>`
+  Verify the one-time code.
+- `himalaya.base44.auth.resetPassword(email: string): Promise<void>`
+  Request a password-reset email.
+- `himalaya.base44.auth.me(): Promise<Base44User>`
+- `himalaya.base44.auth.updateMe(patch: JsonObject): Promise<Base44User>`
+- `himalaya.base44.auth.status(): Promise<AuthStatus>`
+  Whether a user is signed in, and who.
+- `himalaya.base44.auth.logout(): Promise<void>`
+  Drop the stored token.
+- `himalaya.base44.functions.invoke(name: string, data: JsonObject = {}): Promise<Json>`
+  Invoke a Base44 backend function by name.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `base44Error`, `isBase44Error`, `toBase44Error`, `entities`.
+
+## `biometrics`
+
+Tier-5 typed binding to the platform's biometric authentication capability. Package `@himalaya/biometrics` — type definitions and examples (long declarations abridged; the signatures below are complete): [biometrics](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fbiometrics).
+
+- `himalaya.biometrics.available(): Promise<BiometricKind>`
+  Returns the kind of biometric the device supports.
+- `himalaya.biometrics.confirm(options: ConfirmOptions): Promise<boolean>`
+  Ask the system to authenticate the user.
+
+## `browser_auth`
+
+Tier-5 typed binding for native browser SSO. Package `@himalaya/browser-auth` — type definitions and examples (long declarations abridged; the signatures below are complete): [browser-auth](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fbrowser-auth).
+
+- `himalaya.browser_auth.start(options: BrowserAuthOptions): Promise<BrowserAuthResult>`
+
+## `calendar`
+
+Tier-5 typed binding for the device calendar. Package `@himalaya/calendar` — type definitions and examples (long declarations abridged; the signatures below are complete): [calendar](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fcalendar).
+
+- `himalaya.calendar.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.calendar.requestPermission(access: CalendarAccess = "full"): Promise<PermissionStatus>`
+  Prompt for calendar access.
+- `himalaya.calendar.listEvents(start: number, end: number): Promise<CalendarEvent[]>`
+  Events overlapping [start, end) (epoch ms).
+- `himalaya.calendar.createEvent(event: NewCalendarEvent): Promise<{ id: string | null }>`
+- `himalaya.calendar.updateEvent(id: string, patch: Partial<NewCalendarEvent>): Promise<{ updated: boolean }>`
+- `himalaya.calendar.deleteEvent(id: string): Promise<{ deleted: boolean }>`
+
+## `calls`
+
+Tier-5 typed binding for real-time 1:1 audio calls (Stage 1). Package `@himalaya/calls` — type definitions and examples (long declarations abridged; the signatures below are complete): [calls](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fcalls).
+
+- `himalaya.calls.availability(): Promise<AvailabilityReport>`
+  Whether this host can place a call at all (spec R8).
+- `himalaya.calls.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.calls.requestPermission(): Promise<PermissionStatus>`
+- `himalaya.calls.start(opts: { peerId: string; iceServers?: readonly IceServer[] }): Promise<CallState | null>`
+  Place a call.
+- `himalaya.calls.offer(opts: { callId: string; peerId: string; signal: string; iceServers?: readonly IceServer[]; }): Promise<CallState | null>`
+  An inbound offer arrived over the worker's own channel.
+- `himalaya.calls.answer(opts: { callId: string; iceServers?: readonly IceServer[] }): Promise<CallState | null>`
+  Accept a ringing call.
+- `himalaya.calls.reject(opts: { callId: string }): Promise<CallState | null>`
+  Decline a ringing call.
+- `himalaya.calls.hangup(opts: { callId: string }): Promise<CallState | null>`
+  End a call.
+- `himalaya.calls.receiveSignal(opts: { callId: string; signal: string }): Promise<CallState | null>`
+  Feed the peer's opaque blob back in.
+- `himalaya.calls.setMuted(opts: { callId: string; muted: boolean }): Promise<CallState | null>`
+- `himalaya.calls.setSpeaker(opts: { callId: string; route: CallRoute }): Promise<CallState | null>`
+- `himalaya.calls.getState(opts: { callId: string }): Promise<CallState | null>`
+- `himalaya.calls.listCalls(): Promise<CallState[]>`
+  Every live call.
+- `himalaya.calls.signalStart(opts: { callId: string; afterSequence?: number }): Promise<string | null>`
+  Open the LOSSLESS outbound-signal queue.
+- `himalaya.calls.signalNext(opts: { watchId: string; timeoutMs?: number }): Promise<OutboundSignal>`
+  Park until the next outbound signal.
+- `himalaya.calls.signalStop(opts: { watchId: string }): Promise<void>`
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `configureRelays`, `configuredRelays`, `hasRelay`, `lastCallOfferedRelay`, `relaysFromJson`, `resolveIceServers`, `callStateFrom`, `describeEndReason`, `subscribeEvents`.
+
+## `camera`
+
+Tier-5 typed binding to the platform's camera capability. Package `@himalaya/camera` — type definitions and examples (long declarations abridged; the signatures below are complete): [camera](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fcamera).
+
+- `himalaya.camera.capturePhoto(options: CaptureOptions): Promise<CapturedAsset | null>`
+  Capture a photo from the device camera or library.
+- `himalaya.camera.pickDocument(): Promise<PickedDocument | null>`
+  Present the system document picker (iOS UIDocumentPicker / Android SAF).
+- `himalaya.camera.scanQR(): Promise<string | null>`
+  Present a full-screen QR scanner (iOS AVFoundation; camera-based).
+
+## `clipboard`
+
+Tier-5 typed binding for the system clipboard. Package `@himalaya/clipboard` — type definitions and examples (long declarations abridged; the signatures below are complete): [clipboard](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fclipboard).
+
+- `himalaya.clipboard.writeText(text: string): Promise<void>`
+  Copy `text` to the clipboard.
+- `himalaya.clipboard.readText(): Promise<string | null>`
+  Read the clipboard's text, or null if empty / the read was blocked (no focus, denied permission).
+- `himalaya.clipboard.hasText(): Promise<boolean>`
+  Whether the clipboard holds text — no content access, no iOS paste banner.
+
+## `contacts`
+
+Tier-5 typed binding for the device address book. Package `@himalaya/contacts` — type definitions and examples (long declarations abridged; the signatures below are complete): [contacts](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fcontacts).
+
+- `himalaya.contacts.pick(): Promise<Contact | null>`
+  Present the OS contact picker (no permission).
+- `himalaya.contacts.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.contacts.requestPermission(): Promise<PermissionStatus>`
+- `himalaya.contacts.search(query: string, limit?: number): Promise<Contact[]>`
+  Search contacts by name (requires read permission).
+
+## `file_picker`
+
+Tier-5 typed binding for user-mediated document access OUTSIDE the app sandbox. Package `@himalaya/file-picker` — type definitions and examples (long declarations abridged; the signatures below are complete): [file-picker](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Ffile-picker).
+
+- `himalaya.file_picker.pick(options?: FilePickOptions): Promise<FileHandle[]>`
+  Present the OS document picker.
+- `himalaya.file_picker.pickDirectoryForExport(file: FileHandle | string): Promise<{ exported: boolean }>`
+  Export a substrate file out to a user-chosen location (save/export picker).
+
+## `files`
+
+Tier-5 typed binding for app-scoped document storage. Package `@himalaya/files` — type definitions and examples (long declarations abridged; the signatures below are complete): [files](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Ffiles).
+
+- `himalaya.files.write( path: string, content: string | { base64: string }, opts?: { mimeType?: string }, ): Promise<FileHandle>`
+  Write text or base64 bytes to `path` (relative to the app's bundle_docs root).
+- `himalaya.files.readText(ref: FileHandle | string): Promise<string>`
+  Read a file's contents as a UTF-8 string.
+- `himalaya.files.readBase64(ref: FileHandle | string): Promise<string>`
+  Read a file's contents as base64.
+- `himalaya.files.list(dirPath?: string): Promise<FileStat[]>`
+  List the files under `dirPath` (relative to bundle_docs; omit for the root).
+- `himalaya.files.remove(ref: FileHandle | string): Promise<void>`
+  Delete a file.
+- `himalaya.files.stat(path: string): Promise<FileStat | null>`
+  Stat a path, or `null` if it doesn't exist (the existence check for handles).
+
+## `godot`
+
+Tier-5 typed binding for a Godot game surface. Package `@himalaya/godot` — type definitions and examples (long declarations abridged; the signatures below are complete): [godot](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fgodot).
+
+- `himalaya.godot.send( sessionId: GameSessionId, message: Record<string, unknown>, ): Promise<void>`
+  Send a message to the running game (worker -> game).
+- `himalaya.godot.loadPack( sessionId: GameSessionId, pack: GamePack, ): Promise<PackResult>`
+  Fetch, verify, and mount a content pack into the running engine.
+- `himalaya.godot.release(sessionId: GameSessionId): Promise<void>`
+  Release the game surface's engine/GPU resources.
+
+## `haptic`
+
+Tier-5 typed binding for the platform's haptic capability. Package `@himalaya/haptic` — type definitions and examples (long declarations abridged; the signatures below are complete): [haptic](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fhaptic).
+
+- `himalaya.haptic.play(pattern: HapticPattern = "light"): Promise<void>`
+  Play a haptic feedback pattern.
+
+## `health`
+
+Tier-5 typed binding for the platform HEALTH store. Package `@himalaya/health` — type definitions and examples (long declarations abridged; the signatures below are complete): [health](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fhealth).
+
+- `himalaya.health.availability(): Promise<HealthAvailability>`
+  Whether this device has a health store the app can reach.
+- `himalaya.health.requestPermission(p: { read: HealthType[]; write?: HealthWriteType[] }): Promise<{ granted: HealthType[] }>`
+  Prompt for read (and optionally write) access.
+- `himalaya.health.getPermissionStatus(p: { types: HealthType[] }): Promise<Record<HealthType, HealthPermissionState>>`
+  Current READ permission per type, without prompting.
+- `himalaya.health.query(p: HealthQuery): Promise<{ samples: HealthSample[] }>`
+  Read samples of one type over [from, to).
+- `himalaya.health.saveWorkout(w: Workout): Promise<{ id: string }>`
+  Save a completed workout (with its energy/distance, when given).
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `healthError`, `isHealthError`.
+
+## `himi_apps`
+
+Tier-5 typed binding for cross-app open / host queries. Package `@himalaya/himi-apps` — type definitions and examples (long declarations abridged; the signatures below are complete): [himi-apps](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fhimi-apps).
+
+- `himalaya.himi_apps.open(args: OpenArgs): Promise<OpenResult>`
+  Open another Himi app (switch or handoff depending on host).
+- `himalaya.himi_apps.canOpen(appId: string): Promise<boolean>`
+  Whether the host can open `appId` (registry / handoff availability).
+- `himalaya.himi_apps.current(): Promise<{ appId: string } | null>`
+  Active host app id, or null when unknown.
+- `himalaya.himi_apps.hostInfo(): Promise<HostInfo>`
+  Host kind + whether handoff URLs are supported.
+
+## `iap`
+
+Tier-5 typed binding to the platform's in-app-purchase capability. Package `@himalaya/iap` — type definitions and examples (long declarations abridged; the signatures below are complete): [iap](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fiap).
+
+- `himalaya.iap.getPaywallConfig(): Promise<PaywallConfig>`
+  Fetch the server-configured paywall (the OTA `iapConfig`) with each product resolved against the store.
+- `himalaya.iap.getProducts(productIds: string[]): Promise<Product[]>`
+  Look up store metadata (localized title/price/etc.) for the given product ids.
+- `himalaya.iap.purchase(productId: string): Promise<PurchaseResult>`
+  Start a purchase for `productId` and resolve once the store flow completes.
+- `himalaya.iap.restore(): Promise<Entitlement[]>`
+  Restore prior purchases (iOS `AppStore.sync()` / Android `queryPurchasesAsync`) and resolve with the current entitlements.
+- `himalaya.iap.entitlements(): Promise<Entitlement[]>`
+  The user's current active entitlements, verified on-device.
+- `himalaya.iap.consume(transactionId: string): Promise<boolean>`
+  Finish a consumable purchase (iOS `Transaction.finish` / Android `consumeAsync`) AFTER the worker has granted the balance, so the user can purchase it again.
+- `himalaya.iap.purchaseForVerification(input: { productId: string; appAccountToken: string }): Promise<VerificationPurchaseResult>`
+  Apple non-consumables only.
+- `himalaya.iap.getUnfinishedTransactions(): Promise<UnfinishedTransactionsResult>`
+  Same-install recovery; does not restore finished purchases or override ownership.
+- `himalaya.iap.finishTransaction(input: { transactionId: string }): Promise<FinishTransactionResult>`
+  Trusted callers must first obtain durable backend processing acknowledgement.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `createPurchaseCoordinator`, `createPricingController`, `createIapCatalogPricing`, `iapPriceFields`, `onlineProgramItem`, `createWixIapClient`.
+
+## `keyboard`
+
+Tier-5 typed binding for the platform's keyboard capability. Package `@himalaya/keyboard` — type definitions and examples (long declarations abridged; the signatures below are complete): [keyboard](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fkeyboard).
+
+- `himalaya.keyboard.dismiss(): Promise<void>`
+  Dismiss the software keyboard.
+
+## `live_activity`
+
+Tier-5 typed binding to the platform's Live Activity capability. Package `@himalaya/live-activity` — type definitions and examples (long declarations abridged; the signatures below are complete): [live-activity](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Flive-activity).
+
+- `himalaya.live_activity.start(options: StartOptions): Promise<StartResult>`
+  Start a Live Activity.
+- `himalaya.live_activity.update(options: UpdateOptions): Promise<void>`
+  Update a running activity's rendered content.
+- `himalaya.live_activity.end(options: EndOptions): Promise<void>`
+  End a running activity (optionally showing one last frame).
+
+## `local_database`
+
+Tier-5 typed binding to the platform's local-database capability: a per-entity on-device store (EntityStore) + an offline WriteQueue, so a worker bundle can persist and query real data on device. Package `@himalaya/local-db` — type definitions and examples (long declarations abridged; the signatures below are complete): [local-db](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Flocal-db).
+
+- `himalaya.local_database.availability(): Promise<Availability>`
+  Whether this host actually backs the local database.
+- `himalaya.local_database.getAll(entity: string): Promise<DbEntity[]>`
+  All rows of a collection (empty array if none).
+- `himalaya.local_database.get(entity: string, id: string): Promise<DbEntity | null>`
+  One row by `id`, or null.
+- `himalaya.local_database.upsert(entity: string, object: DbEntity): Promise<void>`
+  Insert or replace a row (matched by its `id`).
+- `himalaya.local_database.remove(entity: string, id: string): Promise<void>`
+  Remove a row by `id` (no-op if missing).
+- `himalaya.local_database.purge(entity: string): Promise<void>`
+  Drop the whole collection.
+- `himalaya.local_database.query(entity: string, q: LocalQuery = {}): Promise<DbEntity[]>`
+  Rows of a collection matching `q` (filter + sort + paginate), evaluated on device.
+- `himalaya.local_database.count(entity: string, q: LocalQuery = {}): Promise<number>`
+  Number of rows matching `q` (ignores limit/offset).
+- `himalaya.local_database.enqueue(actionId: string, params: Record<string, string | number | boolean> = {}): Promise<void>`
+  Queue an offline mutation to replay later.
+- `himalaya.local_database.queueDepth(): Promise<number>`
+  Number of queued writes.
+- `himalaya.local_database.drainQueue(): Promise<number>`
+  Drain (clear) the queue; returns how many writes were drained.
+
+## `location`
+
+Tier-5 typed binding for device location. Package `@himalaya/location` — type definitions and examples (long declarations abridged; the signatures below are complete): [location](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Flocation).
+
+- `himalaya.location.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.location.requestPermission(options?: { background?: boolean }): Promise<PermissionStatus>`
+  Prompt for location access.
+- `himalaya.location.getCurrent(options?: { accuracy?: LocationAccuracy; timeoutMs?: number }): Promise<Position | null>`
+  One-shot current position, or null (denied / timed out / unavailable).
+- `himalaya.location.startBackgroundTracking(): Promise<void>`
+  Keep location delivery alive while the app is backgrounded, so an open `watch()` keeps recording with the screen off.
+- `himalaya.location.stopBackgroundTracking(): Promise<void>`
+  Stop background delivery.
+- `himalaya.location.regionMonitoringSupport(): Promise<RegionMonitoringSupport>`
+  What the OS can do here, on THIS device.
+- `himalaya.location.addMonitoredRegion(fence: Geofence): Promise<MonitoredRegionResult>`
+  Hand a region to the OS.
+- `himalaya.location.removeMonitoredRegion(id: string): Promise<boolean>`
+  Stop monitoring one region.
+- `himalaya.location.monitoredRegions(): Promise<Geofence[]>`
+  What the OS is monitoring for this app right now.
+- `himalaya.location.clearMonitoredRegions(): Promise<void>`
+  Stop monitoring everything.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `watch`, `distanceMeters`, `createGeofenceMonitor`, `watchGeofences`, `watchMonitoredRegions`.
+
+## `media_playback`
+
+Tier-5 typed binding for background-capable media playback and offline downloads. Package `@himalaya/media-playback` — type definitions and examples (long declarations abridged; the signatures below are complete): [media-playback](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fmedia-playback).
+
+- `himalaya.media_playback.play(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.play(item?: MediaQueueItem): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.pause(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.pause(): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.stop(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.seek(positionMs: number): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.seekTo(ref: MediaSessionRef & { positionSeconds: number }): Promise<void>`
+- `himalaya.media_playback.skip(delta: number): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.next(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.previous(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.setRate(ref: MediaSessionRef & { rate: number }): Promise<void>`
+- `himalaya.media_playback.setRate(rate: number): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.setMuted(ref: MediaSessionRef & { muted: boolean }): Promise<void>`
+- `himalaya.media_playback.presentFullscreen(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.pictureInPicture(ref: MediaSessionRef): Promise<{ started: boolean }>`
+- `himalaya.media_playback.getState(ref: MediaSessionRef): Promise<MediaPlaybackState | null>`
+- `himalaya.media_playback.getCapabilities(ref: MediaSessionRef): Promise<MediaPlaybackCapabilities>`
+- `himalaya.media_playback.release(ref: MediaSessionRef): Promise<void>`
+- `himalaya.media_playback.status(): Promise<MediaPlaybackStatus>`
+- `himalaya.media_playback.download(item: MediaQueueItem): Promise<MediaDownloadResult>`
+- `himalaya.media_playback.removeDownload(id: string): Promise<MediaDownloadResult>`
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `setQueue`, `encodeSessionOptions`, `subscribeStatus`, `unsubscribeStatus`.
+
+## `motion`
+
+Tier-5 typed binding for the device's motion sensors. Package `@himalaya/motion` — type definitions and examples (long declarations abridged; the signatures below are complete): [motion](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fmotion).
+
+- `himalaya.motion.getPermissionStatus(): Promise<PermissionStatus>`
+  Motion permission status.
+- `himalaya.motion.requestPermission(): Promise<PermissionStatus>`
+  Prompt for motion access (step counting).
+- `himalaya.motion.availability(): Promise<MotionAvailability>`
+  Which sensors this device has.
+- `himalaya.motion.openStepHistorySetup(): Promise<boolean>`
+  Take the user to whatever would make `stepHistory` "available": on Android, update Google Play services (`needs_setup`) or grant step access (`needs_permission`).
+- `himalaya.motion.getStepCount(fromMs: number, toMs: number): Promise<number | null>`
+  Steps between two epoch-ms instants — HISTORICAL, so it can answer "how many steps today" even though the app was not running.
+- `himalaya.motion.getAltitude(): Promise<AltitudeSample | null>`
+  One barometric reading.
+- `himalaya.motion.getHeading(): Promise<HeadingSample | null>`
+  One compass reading, or null when there is no magnetometer / no permission.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `watch`.
+
+## `on_device_ai`
+
+Tier-5 typed binding for ON-DEVICE text generation. Package `@himalaya/on-device-ai` — type definitions and examples (long declarations abridged; the signatures below are complete): [on-device-ai](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fon-device-ai).
+
+- `himalaya.on_device_ai.availability(): Promise<OnDeviceAvailability>`
+  Probe on-device text-generation support on this device/host BEFORE calling `generateText` (spec R8), so a bundle branches instead of rendering a dead button.
+- `himalaya.on_device_ai.generateText(input: GenerateTextInput): Promise<GenerateTextResult>`
+  Generate text ON DEVICE from a prompt, returning a schema-conforming JSON string.
+- `himalaya.on_device_ai.generateJson<T = Record<string, unknown>>(input: GenerateTextInput): Promise<T | null>`
+  Generate text on device and parse it against its schema, returning the typed object (or null on unavailable / failure / unparseable output).
+- `himalaya.on_device_ai.summarize(text: string, opts: SummarizeOptions = {}): Promise<GenerateTextResult>`
+  Summarize a block of text on device.
+
+## `open_url`
+
+Tier-5 typed binding for opening links + external apps. Package `@himalaya/open-url` — type definitions and examples (long declarations abridged; the signatures below are complete): [open-url](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fopen-url).
+
+- `himalaya.open_url.open(url: string, mode?: OpenMode): Promise<{ opened: boolean }>`
+  Open `url`.
+- `himalaya.open_url.canOpen(url: string): Promise<boolean>`
+  True if a handler exists for `url`.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `defaultMode`.
+
+## `pdf`
+
+Tier-5 typed binding for viewing PDF documents. Package `@himalaya/pdf` — type definitions and examples (long declarations abridged; the signatures below are complete): [pdf](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fpdf).
+
+- `himalaya.pdf.isAvailable(): Promise<Availability>`
+  Whether this device can display a PDF in-app right now.
+- `himalaya.pdf.open(url: string, options: OpenPdfOptions = {}): Promise<OpenPdfResult>`
+  Present `url` in a document viewer.
+
+## `photos`
+
+Tier-5 typed binding for the photo library (picker-first). Package `@himalaya/photos` — type definitions and examples (long declarations abridged; the signatures below are complete): [photos](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fphotos).
+
+- `himalaya.photos.pick(options?: PickOptions): Promise<FileHandle[]>`
+  Present the OS photo picker (no permission).
+- `himalaya.photos.saveToLibrary(file: FileHandle | string): Promise<{ saved: boolean }>`
+  Save a file (from files/camera/etc.) into the user's photo library.
+- `himalaya.photos.getSavePermissionStatus(): Promise<PermissionStatus>`
+  Add-to-library permission status (no prompt).
+
+## `presigned_upload`
+
+Tier-5 typed binding for a RAW binary upload to a pre-signed, self-authorizing URL. Package `@himalaya/presigned-upload` — type definitions and examples (long declarations abridged; the signatures below are complete): [presigned-upload](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fpresigned-upload).
+
+- `himalaya.presigned_upload.put(url: string, bytes: { base64: string }, opts?: UploadOptions): Promise<UploadResult>`
+  Upload base64-encoded bytes to a pre-signed URL.
+- `himalaya.presigned_upload.putFile( url: string, ref: FileHandle | string, opts?: UploadOptions, ): Promise<UploadResult>`
+  Upload a stored file's bytes to a pre-signed URL, read straight from the `@himalaya/files` substrate — the bytes never cross the worker bridge, so this is the path for photos and voice notes.
+
+## `push`
+
+Tier-5 typed binding to the platform's push capability. Package `@himalaya/push` — type definitions and examples (long declarations abridged; the signatures below are complete): [push](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fpush).
+
+- `himalaya.push.getPermissionStatus(): Promise<PushPermission>`
+  Current OS notification-permission status (no prompt).
+- `himalaya.push.requestPermission(): Promise<PushPermission>`
+  Request the OS notification permission, prompting if still undetermined.
+- `himalaya.push.openSettings(): Promise<boolean>`
+  Open this app's notification settings in the OS (iOS 16+: the app's Notifications pane; Android 8+: the app's notification settings; earlier: the app's settings page).
+- `himalaya.push.scheduleLocal(options: ScheduleLocalOptions): Promise<{ id: string }>`
+  Schedule a local (on-device) notification.
+- `himalaya.push.cancelLocal(id: string): Promise<void>`
+  Cancel a pending local notification by id.
+- `himalaya.push.cancelAllLocal(): Promise<void>`
+  Cancel every pending local notification this app scheduled.
+- `himalaya.push.setBadge(count: number): Promise<void>`
+  Set the app-icon badge count ("the pimple").
+- `himalaya.push.clearBadge(): Promise<void>`
+  Clear the app-icon badge — exactly `setBadge(0)`.
+- `himalaya.push.getBadge(): Promise<number>`
+  Read the current app-icon badge count.
+- `himalaya.push.getDeviceToken(): Promise<string | null>`
+  The registered remote device token (APNs hex / FCM token), or null if the app has not registered for remote notifications yet.
+- `himalaya.push.listDelivered(): Promise<DeliveredNotification[]>`
+  Notifications currently shown in the system tray / notification center.
+- `himalaya.push.clearDelivered(ids?: string[]): Promise<void>`
+  Remove delivered notifications.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `readNotificationEvent`.
+
+## `release_control`
+
+Tier-5 typed binding for the on-device OTA release picker. Package `@himalaya/release-control` — type definitions and examples (long declarations abridged; the signatures below are complete): [release-control](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Frelease-control).
+
+- `himalaya.release_control.available(): Promise<boolean>`
+  Whether this host exposes the release picker at all.
+- `himalaya.release_control.active(): Promise<ActiveRelease>`
+  The release currently being served, and what decided it.
+- `himalaya.release_control.list(): Promise<ReleaseList>`
+  Published releases for this app, newest first, from serve-control's public trimmed history.
+- `himalaya.release_control.select(releaseId: string | null, opts: SelectOptions = {}): Promise<SelectResult>`
+  Pin this install to `releaseId`, or pass null to clear the pin and follow the rollout ring again ("reset to latest").
+- `himalaya.release_control.resetToLatest(): Promise<SelectResult>`
+  Clear the pin and follow the rollout ring again.
+
+## `secure_storage`
+
+Tier-5 typed binding to the platform's secure-storage capability. Package `@himalaya/secure-storage` — type definitions and examples (long declarations abridged; the signatures below are complete): [secure-storage](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fsecure-storage).
+
+- `himalaya.secure_storage.availability(): Promise<Availability>`
+  Whether this host actually backs secure storage.
+- `himalaya.secure_storage.read(key: string): Promise<string | null>`
+  Read a previously stored value.
+- `himalaya.secure_storage.write( key: string, value: string, options: WriteOptions = {} ): Promise<void>`
+  Persist a value under `key`.
+- `himalaya.secure_storage.remove(key: string): Promise<void>`
+  Remove a key.
+
+## `share`
+
+Tier-5 typed binding for the system share sheet. Package `@himalaya/share` — type definitions and examples (long declarations abridged; the signatures below are complete): [share](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fshare).
+
+- `himalaya.share.share(options: ShareOptions): Promise<{ completed: boolean }>`
+  Resolves `{ completed: true }` when the user completed a share action, or `{ completed: false }` when they dismissed the sheet or the host degraded (e.g.
+- `himalaya.share.availability(): Promise<Availability>`
+  Whether the share sheet is available on this host: `full` (native / Web Share API present), `degraded` (web fallback — copies url/text to the clipboard and reports `completed:false`), or `unavailable`.
+
+## `speaker_diarization`
+
+anonymous speaker segmentation only. Package `@himalaya/speaker-diarization` — type definitions and examples (long declarations abridged; the signatures below are complete): [speaker-diarization](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fspeaker-diarization).
+
+- `himalaya.speaker_diarization.availability(): Promise<DiarizationAvailability>`
+- `himalaya.speaker_diarization.analyzeFile(file: FileHandle): Promise<DiarizationResult>`
+
+## `speech`
+
+Tier-5 typed binding to the platform's speech capability. Package `@himalaya/speech` — type definitions and examples (long declarations abridged; the signatures below are complete): [speech](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fspeech).
+
+- `himalaya.speech.recognizeOnce(options: RecognizeOptions = {}): Promise<RecognizeResult>`
+  Record from the microphone and transcribe a single utterance.
+- `himalaya.speech.speak(options: SpeakOptions): Promise<void>`
+  Speak `text` aloud via the platform speech synthesizer.
+- `himalaya.speech.stop(): Promise<void>`
+  Cancel any in-flight recognition and stop any in-flight synthesis.
+- `himalaya.speech.availability(): Promise<SpeechAvailability>`
+- `himalaya.speech.transcribeFile(file: FileHandle, options: { language?: string } = {}): Promise<TranscriptResult>`
+- `himalaya.speech.streamStart(options: { sessionId: string; language?: string }): Promise<string | null>`
+- `himalaya.speech.streamNext(streamId: string, timeoutMs = 30_000): Promise<SpeechStreamEvent>`
+- `himalaya.speech.streamStop(streamId: string): Promise<void>`
+
+## `system_intents`
+
+Tier-5 typed binding to the platform's system-intents capability. Package `@himalaya/system-intents` — type definitions and examples (long declarations abridged; the signatures below are complete): [system-intents](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fsystem-intents).
+
+- `himalaya.system_intents.donate(options: DonateOptions): Promise<DonateResult>`
+  Donate a screen to the OS assistant for proactive suggestions.
+- `himalaya.system_intents.refreshShortcuts(): Promise<void>`
+  Re-publish the suggested App Shortcuts (e.g.
+
+## `tasks`
+
+Tier-5 typed binding for reminders / to-dos. Package `@himalaya/tasks` — type definitions and examples (long declarations abridged; the signatures below are complete): [tasks](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Ftasks).
+
+- `himalaya.tasks.backend(): Promise<TasksBackend>`
+  Which backend serves this platform — "reminders" (iOS) or "local" (Android).
+- `himalaya.tasks.getPermissionStatus(): Promise<PermissionStatus>`
+- `himalaya.tasks.requestPermission(): Promise<PermissionStatus>`
+- `himalaya.tasks.list(): Promise<Task[]>`
+- `himalaya.tasks.create(task: { title: string; due?: number; notes?: string }): Promise<{ id: string | null }>`
+- `himalaya.tasks.setCompleted(id: string, completed: boolean): Promise<{ updated: boolean }>`
+- `himalaya.tasks.remove(id: string): Promise<{ removed: boolean }>`
+
+## `ui`
+
+Tier-5 typed binding to the platform's imperative popup capability. Package `@himalaya/ui` — type definitions and examples (long declarations abridged; the signatures below are complete): [ui](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fui).
+
+- `himalaya.ui.alert(options: AlertOptions): Promise<AlertResult>`
+  Present a modal alert on the current screen.
+- `himalaya.ui.snackbar(options: SnackbarOptions): Promise<void>`
+  Show a transient snackbar toast.
+
+## `wix_cashier`
+
+Tier-5 typed binding to the platform's native cashier. Package `@himalaya/wix-cashier` — type definitions and examples (long declarations abridged; the signatures below are complete): [wix-cashier](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fwix-cashier).
+
+- `himalaya.wix_cashier.isAvailable(): Promise<Availability>`
+  Whether the device can collect payment natively right now — i.e.
+- `himalaya.wix_cashier.proceedToPayment(config: PaymentConfig): Promise<PaymentResult>`
+  Present the native cashier for one order and resolve with the settlement result.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `normalizeStatus`.
+
+## `wix_platform`
+
+Wix Platform SDK, worker-facing bindings. Package `@himalaya/wix-platform` — type definitions and examples (long declarations abridged; the signatures below are complete): [wix-platform](https://apps.wix.com/_api/himi-serve/authoring/resource/sdks%2Fwix-platform).
+
+- `himalaya.wix_platform.bi.track(evid: number | string, params?: Record<string, string | number>): Promise<BiResult>`
+  Fire a BI beacon with an explicit Frog `evid` + params.
+- `himalaya.wix_platform.bi.pageView(pageName: string): Promise<BiResult>`
+  Page-view beacon (Frog evid 501).
+- `himalaya.wix_platform.bi.click(buttonName: string, pageName?: string): Promise<BiResult>`
+  Click beacon (Frog evid 522).
+- `himalaya.wix_platform.experiments.conduct(spec: string, fallback = "false"): Promise<ExperimentResult>`
+  The app's served variant for `spec` (`himi flags`), or `fallback` when none is assigned.
+- `himalaya.wix_platform.experiments.isEnabled(spec: string): Promise<boolean>`
+  Boolean convenience — true when the variant is exactly "true".
+- `himalaya.wix_platform.experiments.exposure(spec: string, variant: string): Promise<{ ok: boolean }>`
+  Report A/B exposure for `spec`/`variant` — emits the platform's `experiment_exposed` telemetry so outcome events attribute to the variant.
+- `himalaya.wix_platform.flags.isEnabled(spec: string, fallback = false): Promise<boolean>`
+  Whether the app's served flag `spec` is ON (variant `on`/`true`/`new`), else `fallback`.
+- `himalaya.wix_platform.flags.value(spec: string, fallback = ""): Promise<string>`
+  A toggle's raw value (variant string) for non-boolean specs.
+- `himalaya.wix_platform.flags.all(): Promise<Record<string, string>>`
+  All known toggle states (dev/diagnostic).
+- `himalaya.wix_platform.i18n.t(key: string, fallback?: string): Promise<string>`
+  Resolve a translation key for the current locale; `fallback` (or the key) when unknown.
+- `himalaya.wix_platform.i18n.locale(): Promise<string>`
+  Current resolved UI locale (2-letter).
+- `himalaya.wix_platform.ping.register(): Promise<PingRegistration>`
+  Register the device's push token with Wix Ping.
+- `himalaya.wix_platform.ping.status(): Promise<PingRegistration>`
+  Current Ping registration status (no network).
+- `himalaya.wix_platform.deeplink.resolveDeferred(): Promise<{ link: string | null }>`
+  Resolve a deferred (post-install) deep link via Wix Jot.
+- `himalaya.wix_platform.session.headers(): Promise<Record<string, string>>`
+  The Wix mobile aspect-headers the transport attaches to wix-host requests (BSI, x-wix-language, mobile-app-version, x-wix-rpc-caller-id, …).
+- `himalaya.wix_platform.session.signedInstanceStatus(): Promise<SignedInstanceStatus>`
+  Whether a per-business signed instance is minted, and for which metaSite.
+- `himalaya.wix_platform.auth.getIdentity(): Promise<WixIdentity>`
+  Current identity (visitor vs member vs owner) + who.
+- `himalaya.wix_platform.auth.isAuthenticated(): Promise<boolean>`
+  True when a member/owner is signed in.
+- `himalaya.wix_platform.auth.getAccessToken(): Promise<string | null>`
+  The current access/member token (or null when anonymous).
+- `himalaya.wix_platform.auth.signIn(): Promise<WixIdentity>`
+  Sign in (hosted Wix login → member token).
+- `himalaya.wix_platform.auth.signOut(): Promise<WixIdentity>`
+  Sign out — clears the member token (visitor session may persist).
+- `himalaya.wix_platform.auth.signedInstance(businessId: string, type: WixSignedInstanceType = "User"): Promise<string | null>`
+  Mint/return a per-business signed instance for authorized Wix REST calls — the ONE canonical worker-facing signed-instance accessor.
+- `himalaya.wix_platform.site.setActiveSite(msid: string): Promise<{ ok: boolean; msid: string }>`
+  Scope to a business by metaSiteId; resolves after the per-site instance mints.
+- `himalaya.wix_platform.site.activeSite(): Promise<string>`
+  The metaSiteId currently scoped ("" if none).
+- `himalaya.wix_platform.site.getBusinessInfo(): Promise<WixBusinessInfo | null>`
+  The customer's business/site info (identity + locale + contact) from Wix Site Properties v4.
+- `himalaya.wix_platform.monitoring.captureError(message: string, extra?: Record<string, string>): Promise<{ ok: boolean }>`
+  Capture a handled error message (routes to the Sentry telemetry sink).
+- `himalaya.wix_platform.monitoring.captureException(errorClass: string, message: string, extra?: Record<string, string>): Promise<{ ok: boolean }>`
+  Capture an exception with an error class + message (crash-style report).
+- `himalaya.wix_platform.monitoring.setUser(userId: string, traits?: Record<string, string>): Promise<void>`
+  Associate the current user with subsequent crash reports.
+- `himalaya.wix_platform.monitoring.setTag(key: string, value: string): Promise<void>`
+  Set a scope tag attached to subsequent crash reports.
+- `himalaya.wix_platform.monitoring.addBreadcrumb(message: string): Promise<void>`
+  Drop a breadcrumb onto the crash trail.
+
+Not callable from a page (local helpers, live objects, callbacks or pushed events): `isMemberReal`, `site.forSite`.

package/guides/webview-page-sdk.md

@@ -14,7 +14,14 @@ allowlist it, its `logicBundle.declaredCapabilities` must name it, and the binar
 
 ## Page
 
-Install the published umbrella package and import its page entry:
+Building the page outside this platform's packages — in Base44, Lovable, Claude or any other web
+stack? Use [Call native device features from a web page inside a Himi app](web-page-native-sdk.md)
+instead: it has a dependency-free client you paste in, and the
+[Web page SDK reference](https://apps.wix.com/_api/himi-serve/docs/web-page-sdk-reference.md)
+lists every capability and method. The package below is for pages built with the platform's own
+packages.
+
+With `@wix/himalaya` installed, import its page entry:
 
 ```ts
 import { himalaya } from "@wix/himalaya/webview-page";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1297.0",
+  "version": "0.1298.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": [
@@ -70,5 +70,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "431b89a183811f98ed70b97599513b2f1c86754f5f26a8787192d679"
+  "falconPackageHash": "1df7cfb27386e9ed0596e19c100d0c17bf4ec0673aaa35086101644e"
 }