@wix/himalaya-cli 0.1576.0 → 0.1578.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/clipboard/src/index.d.ts

@@ -1,3 +1,5 @@
+import type { FileHandle } from "@wix/himalaya/sdk-types";
+export type { FileHandle } from "@wix/himalaya/sdk-types";
 /** Copy `text` to the clipboard. */
 export declare function writeText(text: string): Promise<void>;
 /** Read the clipboard's text, or null if empty / the read was blocked (no focus,
@@ -7,5 +9,34 @@ export declare function readText(): Promise<string | null>;
  *  web this can't be known without reading, so it returns true pessimistically;
  *  treat it as a hint, not a guarantee. */
 export declare function hasText(): Promise<boolean>;
+/** Largest image writeImage accepts (20 MB). Hosts enforce it too. */
+export declare const MAX_IMAGE_BYTES: number;
+/** Image MIME types writeImage copies. HEIC is iOS/macOS only (Android and web
+ *  reject it `unsupported_type`); web accepts PNG only. The host sniffs the file's
+ *  bytes, so a handle is judged by its content, not its `mimeType` — the binding only
+ *  refuses up front a handle whose type is plainly not an image (e.g. application/pdf). */
+export declare const IMAGE_MIME_TYPES: readonly string[];
+/** Why writeImage rejected. */
+export type ClipboardImageErrorCode = "unsupported_type" | "too_large" | "not_allowed" | "not_found" | "unavailable";
+/** A writeImage rejection: an `Error` named "ClipboardImageError" carrying a stable
+ *  `code`. (A plain Error, not a subclass — Tier-5 bundles target an engine without
+ *  class syntax.) Branch on `isClipboardImageError(e) && e.code === "too_large"`. */
+export interface ClipboardImageError extends Error {
+    name: "ClipboardImageError";
+    code: ClipboardImageErrorCode;
+}
+/** Build a coded writeImage rejection. */
+export declare function clipboardImageError(code: ClipboardImageErrorCode, message?: string): ClipboardImageError;
+/** Whether `e` is a coded writeImage rejection. */
+export declare function isClipboardImageError(e: unknown): e is ClipboardImageError;
+/** Copy an image file the worker already holds to the clipboard. Accepts a
+ *  `FileHandle` (from files / camera / photos) or its substrate `uri`. Rejects with a
+ *  `ClipboardImageError` (see `isClipboardImageError`) whose `code` is `unsupported_type` (not PNG/JPEG/WebP/HEIC, or
+ *  not supported on this host), `too_large` (over 20 MB), `not_allowed` (outside the
+ *  app's files substrate), `not_found`, or `unavailable` (no image clipboard here). */
+export declare function writeImage(file: FileHandle | string): Promise<void>;
+/** Whether the clipboard currently holds an image — without reading it (no iOS paste
+ *  banner). Web cannot know without a permission-gated read, so it answers false. */
+export declare function hasImage(): Promise<boolean>;
 /** Capability version, for bundles that gate on min binary version. */
-export declare const version = 1;
+export declare const version = 2;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/haptic/src/index.d.ts

@@ -1,9 +1,73 @@
-/** Maps to a native impact/notification/selection generator. */
-export type HapticPattern = "selection" | "light" | "medium" | "heavy" | "success" | "warning" | "error";
+/**
+ * Maps to a native impact/notification/selection generator.
+ *
+ * - `rigid` / `soft` — iOS `UIImpactFeedbackGenerator.FeedbackStyle.rigid` / `.soft`.
+ *   Android: `rigid` is a short full-amplitude click (`VibrationEffect.EFFECT_CLICK`-like),
+ *   `soft` a longer low-amplitude tick (`PRIMITIVE_LOW_TICK`-like); on a device without
+ *   amplitude control both are plain one-shots of different length.
+ */
+export type HapticPattern = "selection" | "light" | "medium" | "heavy" | "rigid" | "soft" | "success" | "warning" | "error";
+export interface PlayOptions {
+    /**
+     * 0..1, clamped. Scales the strength of an IMPACT style (`light`, `medium`, `heavy`,
+     * `rigid`, `soft`): iOS `impactOccurred(intensity:)`, Android amplitude where the
+     * vibrator has amplitude control. Ignored for `selection` and the notification styles
+     * (`success`, `warning`, `error`) — those have a fixed system strength — and on web.
+     */
+    intensity?: number;
+}
+export interface HapticStep {
+    pattern: HapticPattern;
+    /** Milliseconds to wait BEFORE this step plays (≥ 0). */
+    delayMs: number;
+    /** Same meaning as {@link PlayOptions.intensity}. */
+    intensity?: number;
+}
+/**
+ * What a verb reports. `ok: false` is honest: `unavailable` (this surface has no haptic
+ * hardware/API — web without `navigator.vibrate`, macOS) or `unsupported_binary` (the
+ * native app predates the verb; nothing played, nothing broke).
+ */
+export type HapticResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "unavailable" | "unsupported_binary";
+};
+/** Most steps one {@link sequence} may carry. */
+export declare const MAX_SEQUENCE_STEPS = 32;
+/** Longest a {@link sequence} or {@link vibrate} pattern may run, in milliseconds. */
+export declare const MAX_DURATION_MS = 10000;
+/** Clamp an intensity into 0..1; `undefined` / non-finite → `undefined` (system default). */
+export declare function clampIntensity(intensity: number | undefined): number | undefined;
 /**
  * Play a haptic feedback pattern. Fire-and-forget; resolves once handed to the
- * platform. A no-op on web and for unknown patterns.
+ * platform. Unknown pattern names keep their historical behaviour (the platform's
+ * default tap). `intensity` applies to impact styles only — see {@link PlayOptions}.
+ */
+export declare function play(pattern?: HapticPattern, options?: PlayOptions): Promise<HapticResult>;
+/**
+ * Play `steps` in order, waiting each step's `delayMs` before it plays. Runs natively
+ * as ONE bridge call (the timing does not depend on the worker), so a drum roll or a
+ * countdown keeps its rhythm. A new `sequence` cancels one still running. Resolves once
+ * the sequence has been scheduled.
+ *
+ * Rejects (`RangeError`) with more than {@link MAX_SEQUENCE_STEPS} steps, a negative or
+ * non-finite delay, or delays totalling over {@link MAX_DURATION_MS}. An empty list just
+ * cancels a running sequence.
+ */
+export declare function sequence(steps: HapticStep[]): Promise<HapticResult>;
+/**
+ * Raw vibration: `patternMs` alternates OFF / ON durations in milliseconds, starting
+ * with an off gap (`[0, 200, 100, 400]` = buzz 200, pause 100, buzz 400).
+ *
+ * Android plays it as `VibrationEffect.createWaveform`. iOS approximates: with Core
+ * Haptics each ON span is a continuous event (a transient one under 30 ms); without it,
+ * each ON span becomes one `heavy` impact at its start. Web uses `navigator.vibrate`.
+ *
+ * Rejects (`RangeError`) on an empty list, a negative or non-finite duration, or a
+ * pattern totalling over {@link MAX_DURATION_MS}.
  */
-export declare function play(pattern?: HapticPattern): Promise<void>;
+export declare function vibrate(patternMs: number[]): Promise<HapticResult>;
 /** Capability version, for bundles that gate on a min binary version. */
-export declare const version = 1;
+export declare const version = 2;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/sdk-types/src/capabilities.generated.d.ts

@@ -8,12 +8,12 @@ export declare const CAPABILITY_REGISTRY: {
     readonly calendar: readonly ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"];
     readonly calls: readonly ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"];
     readonly camera: readonly ["capture", "pickDocument", "prepareImage", "scanQR"];
-    readonly clipboard: readonly ["hasText", "readText", "writeText"];
+    readonly clipboard: readonly ["hasImage", "hasText", "readText", "writeImage", "writeText"];
     readonly contacts: readonly ["getPermissionStatus", "pick", "requestPermission", "search"];
     readonly file_picker: readonly ["pick", "pickDirectoryForExport"];
     readonly files: readonly ["list", "readText", "remove", "stat", "write"];
     readonly godot: readonly ["loadPack", "release", "send"];
-    readonly haptic: readonly ["play"];
+    readonly haptic: readonly ["play", "sequence", "vibrate"];
     readonly health: readonly ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"];
     readonly himi_apps: readonly ["canOpen", "current", "hostInfo", "open"];
     readonly iap: readonly ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"];

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/ui/src/index.d.ts

@@ -6,8 +6,23 @@ export interface AlertOptions {
     confirmLabel?: string;
     /** Cancel button label. OMIT for a single-button alert (no cancel button). */
     cancelLabel?: string;
-    /** Style the confirm button with the `danger` token. */
+    /** Style the confirm button with the `danger` token. A destructive confirm is not the
+     *  affirmative button: its `confirm.actionId` still runs, but without gesture credit. */
     destructive?: boolean;
+    /** The affirmative button's ACTION. Pressing it runs `actionId` as a NEW invocation
+     *  with user-gesture origin (so an app service's `app.<svc>.<action>` may return `_nav` and
+     *  navigate — the "Ready — View" alert). `label` replaces `confirmLabel`. The id is checked when
+     *  you set it, against this worker: a `capability.<id>.*` needs `<id>` allowed, an `app.*` from a
+     *  screen worker needs `app_services` and an exported action, a `tier5.*` must be this worker's
+     *  own; anything else rejects (`action_not_allowed`). Cancel and dismissal run nothing. */
+    confirm?: AlertConfirm;
+}
+/** The affirmative button of an `alert()`: its label and the action its press runs. */
+export interface AlertConfirm {
+    label: string;
+    actionId: string;
+    /** Passed to the action (JSON types kept). */
+    args?: Record<string, unknown>;
 }
 export interface AlertResult {
     /** true ⇒ the user tapped confirm; false ⇒ cancel or the alert was dismissed
@@ -16,7 +31,9 @@ export interface AlertResult {
 }
 /** Present a modal alert on the current screen. Resolves when the user picks a
  *  button. Rejects with `ui_busy` while another alert() is pending, and with
- *  `no_ui_host` if the app has no presenter attached. */
+ *  `no_ui_host` if the app has no presenter attached — or, from an APP SERVICE, when no
+ *  shell is in the foreground (re-show it from `onForeground`). An app service's alert shows on
+ *  whatever screen is open. */
 export declare function alert(options: AlertOptions): Promise<AlertResult>;
 /** Snackbar tone — maps to the app's tone background tokens (`info` → textPrimary, `success`,
  *  `warning`, `danger`). Use `danger` for errors; the hosts also accept `error` as an alias of it. */

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/define-app.d.ts

@@ -561,6 +561,12 @@ export interface RichTemplate {
 export interface PushConfig {
     /** Ping base family, without an APNs environment suffix. */
     pingAppName?: string;
+    /** Wix Ping registration scope (#4708). "site" (default) filters delivery to the
+     *  session's metasite and refuses to register without one; "user" registers the
+     *  device for the signed-in Wix user with NO metasite filter — for an
+     *  account-level app that is not about any single site. Only the "wix-ping"
+     *  registrar reads it. */
+    pingScope?: "site" | "user";
     /** Token registrar. "generic" ⇒ POST the token to `registerUrl`; "wix-ping"
      *  ⇒ the native Wix Ping registrar. */
     registrar: PushRegistrar;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/loyalty/src/index.d.ts

@@ -30,6 +30,20 @@ export interface WixCallOptions {
 /** The per-call header map for `opts`, or undefined when there is nothing to add — so
  *  the no-options path calls the bridge with exactly the 3 arguments it always did. */
 export declare function wixCall<T>(method: string, path: string, body?: unknown, readOptions?: WixCallOptions): Promise<T>;
+export interface WixLoyaltyImage {
+    id?: string;
+    url?: string;
+    height?: number;
+    width?: number;
+    altText?: string;
+    filename?: string;
+}
+export interface WixLoyaltyRewardConfig {
+    tierId?: string;
+    costInPoints?: number;
+    amount?: number;
+    percentage?: number;
+}
 export interface WixLoyaltyProgram {
     id?: string;
     name?: string;
@@ -37,14 +51,33 @@ export interface WixLoyaltyProgram {
     status?: string;
     pointDefinition?: {
         customName?: string;
-        icon?: string;
+        icon?: WixLoyaltyImage;
     };
 }
 export interface WixLoyaltyReward {
     id: string;
     name?: string;
     type?: string;
+    /** Legacy adapter field. REST costs live in the reward's tier configurations. */
     requiredPoints?: number;
+    discountAmount?: {
+        configsByTier?: {
+            tierId?: string;
+            costInPoints?: number;
+            amount?: string;
+        }[];
+    };
+    couponReward?: {
+        fixedAmount?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+        percentage?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+        freeShipping?: {
+            configsByTier?: WixLoyaltyRewardConfig[];
+        };
+    };
     active?: boolean;
 }
 export interface WixLoyaltyTier {
@@ -52,22 +85,47 @@ export interface WixLoyaltyTier {
     id?: string;
     tierDefinition?: {
         name?: string;
-        icon?: string;
+        icon?: WixLoyaltyImage;
     };
     requiredPoints?: number;
 }
-/** GET /loyalty/v1/program → { loyaltyProgram }. */
+export interface WixLoyaltyEarningRule {
+    id?: string;
+    title?: string;
+    status?: string;
+    triggerActivityType?: string;
+    fixedAmount?: {
+        configs?: {
+            tierId?: string;
+            points?: number;
+        }[];
+    };
+    conversionRate?: {
+        field?: string;
+        configs?: {
+            tierId?: string;
+            moneyAmount?: number;
+            points?: number;
+        }[];
+    };
+}
+/** GET /loyalty-programs/v1/program → { loyaltyProgram }. */
 export declare function getLoyaltyProgram(readOptions?: WixCallOptions): Promise<{
     loyaltyProgram?: WixLoyaltyProgram;
     program?: WixLoyaltyProgram;
 }>;
-/** GET /loyalty/v1/rewards → { rewards }. */
+/** GET /loyalty-rewards/v1/rewards → { rewards }. */
 export declare function listLoyaltyRewards(readOptions?: WixCallOptions): Promise<{
     rewards?: WixLoyaltyReward[];
 }>;
-/** GET /loyalty/v1/tiers → { tiers }. The PUBLIC program tier ladder
- * (wix.loyalty.v1.tier) — NOT the private per-customer tiers-program dashboard. */
+/** GET /loyalty-tiers/v1/tiers → { tiers }. The program tier ladder. */
 export declare function listLoyaltyTiers(readOptions?: WixCallOptions): Promise<{
     tiers?: WixLoyaltyTier[];
 }>;
+/** Active and inactive earning rules in their raw REST shape; callers choose visibility.
+ * @scope visitor
+ */
+export declare function listLoyaltyEarningRules(readOptions?: WixCallOptions): Promise<{
+    earningRules?: WixLoyaltyEarningRule[];
+}>;
 export * from "./extensions.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/online-programs/src/index.d.ts

@@ -215,3 +215,90 @@ export declare function joinProgram(programId: string, options?: {
 }): Promise<WixJoinProgramResponse>;
 /** The cashier handle to settle, or "" when no payable order is available. */
 export declare function payableIdOf(participant?: WixJoinedParticipant): string;
+/** `Participant.enrollmentStatus` values the member list filters on. */
+export declare const MEMBER_ENROLLMENT_STATUSES: {
+    readonly joined: "JOINED";
+    readonly suspended: "SUSPENDED";
+    readonly unknown: "UNKNOWN_ENROLLMENT_STATUS";
+};
+/** `Participant.progressStatus` values that still count as a membership once the enrollment is over. */
+export declare const MEMBER_FINISHED_PROGRESS_STATUSES: readonly ["COMPLETED", "FAILED"];
+export interface WixMemberParticipantsQuery {
+    /** The signed-in member's id (`getMyMember().member.id`). Required: without it the query is the roster of everyone. */
+    memberId: string;
+    /** The `pagingMetadata.cursors.next` of the previous page; omit for the first page. */
+    cursor?: string;
+    /** Page size, default 100 (the upstream page cap for this query). */
+    limit?: number;
+}
+export interface WixQueryMemberParticipantsResponse extends WixQueryParticipantsResponse {
+    pagingMetadata?: WixQueryParticipantsResponse["pagingMetadata"] & {
+        cursors?: {
+            next?: string | null;
+        };
+    };
+}
+/**
+ * POST /online-programs/v3/participants/query — the MEMBER'S participations, cursor-paged, with
+ * progress. Joined and suspended enrollments, plus completed/failed ones whose enrollment has
+ * ended, so a finished program still shows its outcome; left, removed and auto-removed
+ * memberships are excluded. The query language has no `programId: {$in}` on this
+ * endpoint, so callers match memberships to displayed programs locally.
+ *
+ * @scope member — requires the signed-in site member; `memberId` must be that member's own id
+ * (`getMyMember().member.id`). An empty `participants` list means the member has no such
+ * membership, never that the read failed: a failure rejects.
+ */
+export declare function queryMemberParticipants(opts: WixMemberParticipantsQuery): Promise<WixQueryMemberParticipantsResponse>;
+export interface WixProgramParticipationStats {
+    programId?: string;
+    participantsCount?: number;
+    autoRemovedCount?: number;
+}
+export interface WixGetParticipationStatsResponse {
+    participationStats?: WixProgramParticipationStats[];
+}
+/** POST /online-programs/v3/participants/stats — participant counts for a batch of programs (one call per page).
+ *  `programIds` must be non-empty (an empty batch returns `{ participationStats: [] }` without a call);
+ *  a program missing from the answer has no count, not zero.
+ *  @scope visitor — counts are public; an anonymous visitor session is enough. */
+export declare function getParticipationStats(programIds: string[]): Promise<WixGetParticipationStatsResponse>;
+/** `JoinApplication.status` — the member's standing BEFORE a participant exists (a private or paid program). */
+export type WixJoinApplicationStatus = "INVITED" | "APPROVAL_PENDING" | "APPROVED" | "PAYMENT_PENDING" | "SUSPENDED" | "DECLINED" | "CANCELLED" | string;
+export interface WixJoinApplication {
+    id?: string;
+    programId?: string;
+    memberId?: string;
+    status?: WixJoinApplicationStatus;
+    paymentStatus?: string;
+    /** Set once the application became a participant. */
+    participantId?: string;
+    createdDate?: string;
+    updatedDate?: string;
+}
+export interface WixGetCurrentJoinApplicationResponse {
+    joinApplication?: WixJoinApplication;
+}
+/** GET /online-programs/participants/v3/join-applications/current/{programId} — the signed-in member's
+ *  own application to ONE program, or none. Used per card only where an application can exist
+ *  (a private or a priced program the member has not joined). An answer with no `joinApplication`
+ *  means the member never applied.
+ *  @scope member — requires the signed-in site member; a visitor session has no application to read. */
+export declare function getCurrentJoinApplication(programId: string): Promise<WixGetCurrentJoinApplicationResponse>;
+export interface WixProgramCategory {
+    id?: string;
+    label?: string;
+    /** Program ids the category is assigned to. */
+    assignedTo?: string[];
+}
+export interface WixListProgramCategoriesResponse {
+    categories?: WixProgramCategory[];
+}
+/** GET /_api/program-categories-service/v3/categories — every program category of the site (the
+ *  category filter's options). `/_api/…` paths ride the same bridge as the public ones (forms,
+ *  bookings-v2 and ecom already do). An empty `categories` list means the site has none.
+ *  @scope member — the One App member programs list calls it with the member's identity. NOT verified
+ *  live here: codegen/wix/auto/lock.json lists only the APP identity (ONLINE_PROGRAMS.CATEGORY_READ), so a
+ *  visitor or member token can get 403. A caller must treat a rejection as "no category filter", never
+ *  as an error screen. */
+export declare function listProgramCategories(): Promise<WixListProgramCategoriesResponse>;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/audio-record.mjs

@@ -23,12 +23,12 @@ var CAPABILITY_REGISTRY = {
   "calendar": ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"],
   "calls": ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"],
   "camera": ["capture", "pickDocument", "prepareImage", "scanQR"],
-  "clipboard": ["hasText", "readText", "writeText"],
+  "clipboard": ["hasImage", "hasText", "readText", "writeImage", "writeText"],
   "contacts": ["getPermissionStatus", "pick", "requestPermission", "search"],
   "file_picker": ["pick", "pickDirectoryForExport"],
   "files": ["list", "readText", "remove", "stat", "write"],
   "godot": ["loadPack", "release", "send"],
-  "haptic": ["play"],
+  "haptic": ["play", "sequence", "vibrate"],
   "health": ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"],
   "himi_apps": ["canOpen", "current", "hostInfo", "open"],
   "iap": ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"],

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/calendar.mjs

@@ -23,12 +23,12 @@ var CAPABILITY_REGISTRY = {
   "calendar": ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"],
   "calls": ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"],
   "camera": ["capture", "pickDocument", "prepareImage", "scanQR"],
-  "clipboard": ["hasText", "readText", "writeText"],
+  "clipboard": ["hasImage", "hasText", "readText", "writeImage", "writeText"],
   "contacts": ["getPermissionStatus", "pick", "requestPermission", "search"],
   "file_picker": ["pick", "pickDirectoryForExport"],
   "files": ["list", "readText", "remove", "stat", "write"],
   "godot": ["loadPack", "release", "send"],
-  "haptic": ["play"],
+  "haptic": ["play", "sequence", "vibrate"],
   "health": ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"],
   "himi_apps": ["canOpen", "current", "hostInfo", "open"],
   "iap": ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"],

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/calls.mjs

@@ -23,12 +23,12 @@ var CAPABILITY_REGISTRY = {
   "calendar": ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"],
   "calls": ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"],
   "camera": ["capture", "pickDocument", "prepareImage", "scanQR"],
-  "clipboard": ["hasText", "readText", "writeText"],
+  "clipboard": ["hasImage", "hasText", "readText", "writeImage", "writeText"],
   "contacts": ["getPermissionStatus", "pick", "requestPermission", "search"],
   "file_picker": ["pick", "pickDirectoryForExport"],
   "files": ["list", "readText", "remove", "stat", "write"],
   "godot": ["loadPack", "release", "send"],
-  "haptic": ["play"],
+  "haptic": ["play", "sequence", "vibrate"],
   "health": ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"],
   "himi_apps": ["canOpen", "current", "hostInfo", "open"],
   "iap": ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"],

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/clipboard.mjs

@@ -26,11 +26,68 @@ async function hasText() {
   const r = await dispatch("capability.clipboard.hasText");
   return r?.has === true;
 }
-var version = 1;
+var MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+var IMAGE_MIME_TYPES = ["image/png", "image/jpeg", "image/webp", "image/heic"];
+var CODES = ["unsupported_type", "too_large", "not_allowed", "not_found", "unavailable"];
+function clipboardImageError(code, message) {
+  const text = !message ? code : message.startsWith(code) ? message : `${code}: ${message}`;
+  const err = new Error(text);
+  err.name = "ClipboardImageError";
+  err.code = code;
+  return err;
+}
+function isClipboardImageError(e) {
+  return e instanceof Error && e.name === "ClipboardImageError" && CODES.includes(e.code);
+}
+function codeOf(err) {
+  const msg = err instanceof Error ? err.message : String(err ?? "");
+  let best = null;
+  for (const c of CODES) {
+    const m = new RegExp(`(^|[^a-z_])${c}([^a-z_]|$)`).exec(msg);
+    if (!m) continue;
+    const at = m.index + m[1].length;
+    if (!best || at < best.at) best = { code: c, at };
+  }
+  return best?.code ?? null;
+}
+function plainlyNotAnImage(mimeType) {
+  const mime = (mimeType ?? "").toLowerCase().trim();
+  return mime !== "" && mime !== "application/octet-stream" && !mime.startsWith("image/");
+}
+async function writeImage(file) {
+  const handle = typeof file === "string" ? null : file;
+  const uri = typeof file === "string" ? file : file?.uri;
+  if (typeof uri !== "string" || uri.length === 0) throw clipboardImageError("not_allowed", "no file uri");
+  if (handle) {
+    if (plainlyNotAnImage(handle.mimeType)) throw clipboardImageError("unsupported_type", String(handle.mimeType));
+    if (typeof handle.sizeBytes === "number" && handle.sizeBytes > MAX_IMAGE_BYTES) throw clipboardImageError("too_large", `${handle.sizeBytes} bytes`);
+  }
+  const params = { uri };
+  if (handle?.mimeType) params.mimeType = handle.mimeType;
+  if (handle?.ownerScope) params.ownerScope = handle.ownerScope;
+  try {
+    await dispatch("capability.clipboard.writeImage", params);
+  } catch (err) {
+    const code = codeOf(err);
+    if (code) throw clipboardImageError(code, err instanceof Error ? err.message : String(err));
+    throw err;
+  }
+}
+async function hasImage() {
+  const r = await dispatch("capability.clipboard.hasImage");
+  return r?.has === true;
+}
+var version = 2;
 export {
+  IMAGE_MIME_TYPES,
+  MAX_IMAGE_BYTES,
+  clipboardImageError,
+  hasImage,
   hasText,
+  isClipboardImageError,
   readText,
   version,
+  writeImage,
   writeText
 };
 //# sourceMappingURL=clipboard.mjs.map

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/contacts.mjs

@@ -23,12 +23,12 @@ var CAPABILITY_REGISTRY = {
   "calendar": ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"],
   "calls": ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"],
   "camera": ["capture", "pickDocument", "prepareImage", "scanQR"],
-  "clipboard": ["hasText", "readText", "writeText"],
+  "clipboard": ["hasImage", "hasText", "readText", "writeImage", "writeText"],
   "contacts": ["getPermissionStatus", "pick", "requestPermission", "search"],
   "file_picker": ["pick", "pickDirectoryForExport"],
   "files": ["list", "readText", "remove", "stat", "write"],
   "godot": ["loadPack", "release", "send"],
-  "haptic": ["play"],
+  "haptic": ["play", "sequence", "vibrate"],
   "health": ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"],
   "himi_apps": ["canOpen", "current", "hostInfo", "open"],
   "iap": ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"],

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/haptic.mjs

@@ -14,12 +14,81 @@ function dispatch(handlerId, params, _options) {
 }
 
 // ../../core/sdk/haptic/src/index.ts
-async function play(pattern = "light") {
-  await dispatch("capability.haptic.play", { pattern });
+var MAX_SEQUENCE_STEPS = 32;
+var MAX_DURATION_MS = 1e4;
+function clampIntensity(intensity) {
+  if (intensity === void 0 || typeof intensity !== "number" || !Number.isFinite(intensity)) return void 0;
+  return Math.min(1, Math.max(0, intensity));
 }
-var version = 1;
+var UNKNOWN_ACTION = /unknown[_ ]?(action|handler)|ActionError\.unknown|^unknown\(|no handler/i;
+function toResult(payload) {
+  const p = payload;
+  if (p && p.ok === false) {
+    return { ok: false, reason: p.reason === "unsupported_binary" ? "unsupported_binary" : "unavailable" };
+  }
+  return { ok: true };
+}
+async function settle(pending) {
+  try {
+    return toResult(await pending);
+  } catch (e) {
+    if (UNKNOWN_ACTION.test(String(e?.message ?? e))) return { ok: false, reason: "unsupported_binary" };
+    throw e;
+  }
+}
+async function play(pattern = "light", options = {}) {
+  const params = { pattern };
+  const intensity = clampIntensity(options.intensity);
+  if (intensity !== void 0) params.intensity = intensity;
+  return toResult(await dispatch("capability.haptic.play", params));
+}
+async function sequence(steps) {
+  if (!Array.isArray(steps)) throw new TypeError("sequence: steps must be an array");
+  if (steps.length > MAX_SEQUENCE_STEPS) {
+    throw new RangeError(`sequence: at most ${MAX_SEQUENCE_STEPS} steps (got ${steps.length})`);
+  }
+  let total = 0;
+  const wire = steps.map((s, i) => {
+    const delayMs = Number(s?.delayMs ?? 0);
+    if (!Number.isFinite(delayMs) || delayMs < 0) throw new RangeError(`sequence: step ${i} has an invalid delayMs`);
+    total += delayMs;
+    const out = {
+      pattern: String(s?.pattern ?? "light"),
+      delayMs: Math.round(delayMs)
+    };
+    const intensity = clampIntensity(s?.intensity);
+    if (intensity !== void 0) out.intensity = intensity;
+    return out;
+  });
+  if (total > MAX_DURATION_MS) {
+    throw new RangeError(`sequence: total delay ${total}ms exceeds ${MAX_DURATION_MS}ms`);
+  }
+  return settle(dispatch("capability.haptic.sequence", { steps: JSON.stringify(wire) }));
+}
+async function vibrate(patternMs) {
+  if (!Array.isArray(patternMs) || patternMs.length === 0) {
+    throw new RangeError("vibrate: patternMs must be a non-empty array");
+  }
+  let total = 0;
+  const wire = patternMs.map((ms, i) => {
+    const n = Number(ms);
+    if (!Number.isFinite(n) || n < 0) throw new RangeError(`vibrate: duration ${i} is invalid`);
+    total += n;
+    return Math.round(n);
+  });
+  if (total > MAX_DURATION_MS) {
+    throw new RangeError(`vibrate: pattern totals ${total}ms, over ${MAX_DURATION_MS}ms`);
+  }
+  return settle(dispatch("capability.haptic.vibrate", { pattern: wire.join(",") }));
+}
+var version = 2;
 export {
+  MAX_DURATION_MS,
+  MAX_SEQUENCE_STEPS,
+  clampIntensity,
   play,
-  version
+  sequence,
+  version,
+  vibrate
 };
 //# sourceMappingURL=haptic.mjs.map

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/location.mjs

@@ -23,12 +23,12 @@ var CAPABILITY_REGISTRY = {
   "calendar": ["createEvent", "deleteEvent", "getPermissionStatus", "listEvents", "requestPermission", "updateEvent"],
   "calls": ["answer", "availability", "getPermissionStatus", "getState", "hangup", "listCalls", "offer", "receiveSignal", "reject", "requestPermission", "setMuted", "setRingback", "setSpeaker", "signalNext", "signalStart", "signalStop", "start", "subscribeEvents"],
   "camera": ["capture", "pickDocument", "prepareImage", "scanQR"],
-  "clipboard": ["hasText", "readText", "writeText"],
+  "clipboard": ["hasImage", "hasText", "readText", "writeImage", "writeText"],
   "contacts": ["getPermissionStatus", "pick", "requestPermission", "search"],
   "file_picker": ["pick", "pickDirectoryForExport"],
   "files": ["list", "readText", "remove", "stat", "write"],
   "godot": ["loadPack", "release", "send"],
-  "haptic": ["play"],
+  "haptic": ["play", "sequence", "vibrate"],
   "health": ["availability", "getPermissionStatus", "query", "requestPermission", "saveWorkout"],
   "himi_apps": ["canOpen", "current", "hostInfo", "open"],
   "iap": ["appBinding", "consume", "entitlements", "finishTransaction", "getPaywallConfig", "getProducts", "getUnfinishedTransactions", "purchase", "purchaseForVerification", "restore"],