@wix/himalaya-cli 0.1544.0 → 0.1545.0

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

@@ -1,7 +1,10 @@
 /**
  * Hint the platform that worker state is at a meaningful boundary worth
- * writing to disk. Optionally supply a `snapshot` — an opaque JSON-friendly
- * value the platform can include alongside the auto-generated state dump.
+ * writing to disk. Optionally supply a JSON-friendly map from registered service
+ * names to their next state, for a flush before an action commits that state.
+ * Omit it to flush current state. Unknown services, read-lifecycle services,
+ * transient fields and fields declared `notPersisted` are excluded. Keep authored
+ * metadata inside its service state; arbitrary top-level metadata is not persisted.
  *
  * Returns immediately; the actual write is async and platform-managed.
  */

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

@@ -1,4 +1,6 @@
 import type { Component } from "@wix/himalaya/core";
+export { createReadController, initialReadStatus } from './read.js';
+export type { ReadMetadata, ReadStatus, ReadSnapshot } from './read.js';
 export interface ServiceDefinition<S> {
     /** Initial state for the service. Must be JSON-serializable. */
     state: S;
@@ -15,6 +17,18 @@ export interface ServiceDefinition<S> {
      * Runtimes that honour it set `himalaya.hydrationOptOut`; an older one ignores the option.
      */
     notHydrated?: readonly (keyof S & string)[];
+    /** Applies a presentation decorator after a retained read snapshot is committed. */
+    readPresentation?: (state: any) => any;
+    /** Explicitly safe read action, invoked on reconnect while this screen is visible.
+     * statusPath addresses a ReadStatus in this service (e.g. "readStatus"). */
+    readLifecycle?: {
+        refreshAction: string;
+        statusPath: string;
+    };
+    /** Data governed by a separate cache policy must not also enter the generic
+     * worker snapshot. These keys are neither persisted nor hydrated by a runtime with
+     * `himalaya.readLifecycleVersion >= 1`; an older runtime ignores the option. */
+    notPersisted?: readonly (keyof S & string)[];
     /**
      * Keys that start each VISIT from `state`: when a cached embed shows the screen again (its warm worker
      * reclaimed), these go back to their declared values before the screen reloads. For the same kind of

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

@@ -0,0 +1,60 @@
+/** The provenance of one policy-approved read. Times are Unix milliseconds. */
+export interface ReadMetadata {
+    source: 'cache' | 'network' | 'local';
+    fetchedAt: number;
+    expiresAt?: number;
+    cacheable: boolean;
+}
+export interface ReadStatus {
+    hasSnapshot: boolean;
+    fromCache: boolean;
+    refreshing: boolean;
+    stale: boolean;
+    offline: boolean;
+    lastSuccessAt?: number;
+    expiresAt?: number;
+    error: string;
+    /** Authored local content has no server freshness claim and is never persisted as a response. */
+    hasLocalContent?: boolean;
+}
+export interface ReadSnapshot<T> {
+    data: T;
+    metadata: ReadMetadata;
+}
+export declare const initialReadStatus: () => ReadStatus;
+/** Read-only lifecycle. The adapter owns policy and identity scoping; this controller
+ * never persists data or queues an action. A snapshot may legitimately contain [] or null.
+ * Change the key when route/query/identity changes; late completions then cannot publish.
+ */
+export declare function createReadController<T>(options: {
+    cached?(key: string): Promise<ReadSnapshot<T> | undefined>;
+    fetch(key: string): Promise<ReadSnapshot<T>>;
+    publish(data: T | undefined, status: ReadStatus): void;
+    online?(): boolean;
+    clearOnError?(error: unknown): boolean;
+    /** A domain-safe explanation (never a raw response body) for an unavailable read. */
+    errorMessage?(error: unknown): string;
+    now?(): number;
+    allowLocal?: boolean;
+}): {
+    load: (nextKey: string) => Promise<void>;
+    refresh: () => Promise<void>;
+    getStatus: () => {
+        hasSnapshot: boolean;
+        fromCache: boolean;
+        refreshing: boolean;
+        stale: boolean;
+        offline: boolean;
+        lastSuccessAt?: number;
+        expiresAt?: number;
+        error: string;
+        /** Authored local content has no server freshness claim and is never persisted as a response. */
+        hasLocalContent?: boolean;
+    };
+    /** Revision for adapters that coalesce the read and their final state projection. */
+    getRevision: () => number;
+    connectivityChanged(connected: boolean): void;
+    replace(snapshot: ReadSnapshot<T>, nextKey?: string): void;
+    invalidate(): void;
+    dispose(): void;
+};

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 export interface WixActivityCounter {

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

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

@@ -2,9 +2,49 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
+/**
+ * Every path below is RELATIVE, starting with `/`. That is the wixApi bridge's
+ * contract — "paths are relative to https://www.wixapis.com" — and what the other
+ * 27 call sites across `@himalaya/wix-*` do.
+ *
+ * This domain used to spell its three paths as absolute `https://www.wixapis.com/…`
+ * URLs. Native tolerates that (its request policy allows any `wixapis.com` host),
+ * so it worked everywhere anyone looked. The web preview does not: its bridge
+ * is host-locked to the gateway and refuses an absolute URL outright, and
+ * `*.wixapis.com` deliberately does NOT get the owner-host exemption — the gateway
+ * is precisely the thing you are supposed to reach with a relative path. So every
+ * analytics call returned `400 absolute_urls_not_allowed`, and owner-lite's
+ * Analytics and Build-a-report screens showed that raw JSON in their error arm on
+ * the web preview while both worked on device.
+ *
+ * Keep them relative. An absolute URL here is not a style choice — it is a screen
+ * that only works on half its surfaces.
+ */
+export interface WixCallOptions {
+    site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
+}
 /**
  * The zone these helpers can actually honour: the requested one where ECMA-402
  * exists, UTC where it does not. Callers must send THIS to the API, not the zone
@@ -138,7 +178,7 @@ export interface GetSiteAnalyticsOptions {
  * that materially changes the result and the list was already at its readable
  * limit.
  */
-export declare function getSiteAnalytics(opts: GetSiteAnalyticsOptions): Promise<WixAnalyticsResponse>;
+export declare function getSiteAnalytics(opts: GetSiteAnalyticsOptions, options?: WixCallOptions): Promise<WixAnalyticsResponse>;
 /**
  * The site's IANA time zone, for `timeZone` / `interval.timezone`.
  *
@@ -148,7 +188,7 @@ export declare function getSiteAnalytics(opts: GetSiteAnalyticsOptions): Promise
  * hand-rolling the same raw `wixApi` request. A deliberate trade-off, recorded so
  * the next reader does not take it for an accident.
  */
-export declare function getSiteTimeZone(): Promise<string | undefined>;
+export declare function getSiteTimeZone(options?: WixCallOptions): Promise<string | undefined>;
 export type SemanticFieldType = "STRING" | "NUMBER" | "BOOLEAN" | "DATE" | "DATE_TIME" | "OBJECT" | "ARRAY";
 export type FilterPrefix = "IS" | "NOT";
 export type FilterCondition = "EQUAL" | "GREATER_THAN" | "GREATER_THAN_OR_EQUAL" | "LESS_THAN" | "LESS_THAN_OR_EQUAL" | "NULL" | "EMPTY" | "START_WITH" | "END_WITH" | "CONTAINS_ANY" | "CONTAINS_ALL" | "RANGE_II" | "RANGE_IE" | "RANGE_EI" | "RANGE_EE";

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 /** Send a typed request through the host's authenticated Wix API bridge.
  * The host supplies the owner session; callers supply the HTTP method, gateway path and optional body.

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/blog-v3/src/extensions.d.ts

@@ -1,6 +1,7 @@
+import { type WixCallOptions } from "./index.js";
 import type { WixPost, WixRichContent, WixDraftPostWrite, WixDraftPost, WixGetDraftPostResponse, WixCreateDraftPostResponse, WixUpdateDraftPostResponse, WixDeleteDraftPostResponse } from "./index.js";
 /** Fetch a single draft post by id — the editor/settings prefill source. */
-export declare function getDraftPost(postId: string): Promise<WixGetDraftPostResponse>;
+export declare function getDraftPost(postId: string, options?: WixCallOptions): Promise<WixGetDraftPostResponse>;
 /** A published post that MAY carry its body. The generated `WixPost` is the
  * list projection (no body), so the body-bearing fields live here on the read
  * shape `getPost` returns once the body fieldsets are requested. */
@@ -49,7 +50,7 @@ export interface WixGetPostRequest {
  * `catch`, or an `allSettled` filter), so rejecting is what routes them into the
  * graceful degrade they already implement. The originating failure travels as
  * `cause`, so the 404-vs-network distinction is not lost. */
-export declare function getPost(postId: string, req?: WixGetPostRequest): Promise<WixGetPostResponse>;
+export declare function getPost(postId: string, req?: WixGetPostRequest, readOptions?: WixCallOptions): Promise<WixGetPostResponse>;
 export interface WixBlogCategory {
     id: string;
     label?: string;
@@ -67,7 +68,7 @@ export declare function queryCategories(req?: {
         limit?: number;
         offset?: number;
     };
-}): Promise<WixQueryCategoriesResponse>;
+}, opts?: WixCallOptions): Promise<WixQueryCategoriesResponse>;
 /** Create a draft post — POST /draft-posts. `title` + `richContent` are the core fields. */
 export declare function createDraftPost(draftPost: WixDraftPostWrite): Promise<WixCreateDraftPostResponse>;
 /** Update a draft post — PATCH /draft-posts/{id}. Only the supplied fields change.
@@ -110,6 +111,6 @@ export interface WixQueryDraftPostsResponse {
         offset?: number;
     };
 }
-export declare function queryDraftPosts(req?: WixQueryDraftPostsRequest): Promise<WixQueryDraftPostsResponse>;
+export declare function queryDraftPosts(req?: WixQueryDraftPostsRequest, opts?: WixCallOptions): Promise<WixQueryDraftPostsResponse>;
 /** Cancel a post's schedule — PATCH /draft-posts/{id} {action:"UPDATE_CANCEL_SCHEDULE"}. */
 export declare function cancelScheduleDraftPost(postId: string): Promise<WixUpdateDraftPostResponse>;

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 export interface WixBlogPaging {

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/bookings-v2/src/extensions.d.ts

@@ -125,7 +125,7 @@ export interface WixQueryServicesResponse {
  *  PUBLIC GA route (audience MEMBERS_AND_VISITORS), so a visitor/consumer token can
  *  read it — NOT the owner/BO `_api/` gateway (which fails for visitors, #463). Takes
  *  the standard query envelope (filter/sort/paging). */
-export declare function queryServices(req?: WixQueryServicesRequest): Promise<WixQueryServicesResponse>;
+export declare function queryServices(req?: WixQueryServicesRequest, readOptions?: WixCallOptions): Promise<WixQueryServicesResponse>;
 /** One service category, as the categories query returns it. `sortOrder` is the business's
  *  own order; the response is already in it. */
 export interface WixServiceCategory {
@@ -151,7 +151,7 @@ export interface WixGetServiceResponse {
  *  ("STAFF_MEMBER_DETAILS", "DISCOUNT_INFO_DETAILS"), each sent as a repeated
  *  `conditionalFields` query parameter. Without `options` the request is the one this
  *  function always sent. */
-export declare function getService(serviceId: string, options?: WixGetServiceOptions): Promise<WixGetServiceResponse>;
+export declare function getService(serviceId: string, options?: WixGetServiceOptions & WixCallOptions): Promise<WixGetServiceResponse>;
 /** Writable service fields for create/update, in the ERGONOMIC shape a form has. The helpers
  *  below encode it onto the Bookings v2 entity — they never send these flat fields as-is,
  *  because v2 silently ignores a flat `price`/`duration` (HTTP 200, revision bumps, nothing
@@ -370,7 +370,7 @@ export interface WixServiceAvailabilityOptions {
  * worked. Narrow the window instead, until the level can be confirmed against a
  * schema or a live call.
  */
-export declare function queryServiceAvailability(serviceId: string, startDate: string, endDate: string, options?: WixServiceAvailabilityOptions): Promise<WixQueryAvailabilityResponse>;
+export declare function queryServiceAvailability(serviceId: string, startDate: string, endDate: string, options?: WixServiceAvailabilityOptions, readOptions?: WixCallOptions): Promise<WixQueryAvailabilityResponse>;
 export interface WixResource {
     id?: string;
     name?: string;
@@ -514,7 +514,7 @@ export interface WixGetBookingFullResponse {
  *  booking (payment/intake/location/staff/attendance). The booking-detail data source.
  *  Owner-scoped: needs an owner/BO session; a visitor or member token gets 403. A
  *  member-facing screen reads its own bookings via `queryBookings` instead. */
-export declare function getBookingFull(bookingId: string): Promise<WixGetBookingFullResponse>;
+export declare function getBookingFull(bookingId: string, options?: WixCallOptions): Promise<WixGetBookingFullResponse>;
 /** Set attendance for a booking (class/course check-in / no-show) —
  *  POST /bookings/v1/bookings/{id}/setAttendance. Body repeats bookingId +
  *  attendanceInfo {attendanceStatus, numberOfAttendees}. Confirmed against the

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -21,7 +32,17 @@ export declare function chatWebError(code: ChatWebErrorCode, message: string, ca
 /** Returns whether a value is a typed Wix chat SDK error. */
 export declare function isChatWebError(e: unknown): e is ChatWebError;
 export type ChatRole = "owner" | "member";
-export interface ChatOptions {
+export interface WixCallOptions {
+    /** Cache-only reads never use the network; reload waits for a successful server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
+}
+export interface ChatOptions extends WixCallOptions {
     /** `owner` (default) mints with isForUnifiedList=true; `member` with false. */
     role?: ChatRole;
     /** A caller-supplied chatToken; skips the mint. Never stored by this module. */

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

@@ -2,6 +2,17 @@ declare global {
     var himalaya: {
         wixApi?: {
             call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+            read?: (method: string, path: string, body: unknown, headers: Record<string, string> | undefined, options: {
+                cache: string;
+            }) => Promise<{
+                data: unknown;
+                cache: {
+                    source: "cache" | "network";
+                    fetchedAt: number;
+                    expiresAt?: number;
+                    cacheable: boolean;
+                };
+            }>;
         };
     };
 }
@@ -14,6 +25,14 @@ declare global {
  *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
 export interface WixCallOptions {
     site?: string;
+    /** Explicit cache reads never touch the network; reload waits for a server response. */
+    cache?: "default" | "only-if-cached" | "reload";
+    onCacheResult?: (metadata: {
+        source: "cache" | "network";
+        fetchedAt: number;
+        expiresAt?: number;
+        cacheable: boolean;
+    }) => void;
 }
 export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
 /** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or