@wix/himalaya-cli 0.1451.0 → 0.1453.0

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

@@ -0,0 +1,79 @@
+export type WebViewRuntime = {
+    postToPage(msg: unknown, instanceId?: string): void;
+    onPageMessage(cb: (msg: unknown, instanceId?: unknown) => void): void;
+    onPageLifecycle?(cb: (envelope: unknown, instanceId?: unknown) => void): void;
+};
+export interface PageCapabilityRequest {
+    v: 1;
+    id: string;
+    capability: string;
+    method: string;
+    args: unknown[];
+}
+export interface PageCapabilityResponse {
+    v: 1;
+    id: string;
+    ok: boolean;
+    result?: unknown;
+    /** `true` when the call answers as a stream: chunks follow as `{ v: 1, sid: id, … }`. */
+    stream?: true;
+    error?: {
+        message: string;
+        code?: string;
+    };
+}
+/** What every `onPageRequest` handler receives beside its args. */
+export interface PageCtx {
+    /** The instance the host stamped on the request (`""` for the full-screen page). */
+    readonly instanceId: string;
+    readonly requestId: string;
+    /** Live: `false` between an `inactive` and the next `active` lifecycle of this instance. */
+    readonly active: boolean;
+}
+export type PageRequestHandler = (args: unknown[], ctx: PageCtx) => unknown;
+export interface PageLifecycleEvent {
+    instanceId: string;
+    state: string;
+    detail?: unknown;
+}
+/** Page-sourced console output. UNTRUSTED: the page can forge it (RFC 0073 §5.3). */
+export interface PageConsoleEvent {
+    instanceId: string;
+    level: string;
+    args: unknown[];
+}
+export interface PageStream {
+    /** Send one chunk. A no-op once the stream ended, errored, or the page cancelled it. */
+    next(data: unknown): void;
+    end(): void;
+    error(e: unknown): void;
+    /** Called once if the page cancels (`break` out of its iterator) or the instance unmounts. */
+    onCancel(cb: () => void): void;
+    readonly closed: boolean;
+}
+export interface ExposedPageCapability {
+    module: Record<string, unknown>;
+    methods: readonly string[];
+}
+export declare const PAGE_HANDSHAKE_CAPABILITY = "himalaya";
+export declare const PAGE_HANDSHAKE_METHOD = "capabilities";
+export declare const NAMESPACE_PATTERN: RegExp;
+export declare function pageRequest(value: unknown): PageCapabilityRequest | null;
+export declare function pageError(value: unknown): {
+    message: string;
+    code?: string;
+};
+export interface PageDispatcher {
+    readonly runtime: WebViewRuntime;
+    /** Whether the runtime routes by instance id (W2/W4/W6 hosts) or has one page (`""`). */
+    readonly instanceAware: boolean;
+    setRawHandler(cb: (msg: unknown, instanceId: string) => void): void;
+    expose(capabilities: Readonly<Record<string, ExposedPageCapability>>): void;
+    addNamespace(namespace: string, handlers: Readonly<Record<string, PageRequestHandler>>): void;
+    subscribeLifecycle(cb: (e: PageLifecycleEvent) => void): () => void;
+    subscribeConsole(cb: (e: PageConsoleEvent) => void): () => void;
+    post(instanceId: string, msg: unknown): void;
+    emit(target: string, event: string, data: unknown): void;
+    openStream(instanceId: string, requestId: string): PageStream;
+}
+export declare function createPageDispatcher(runtime: WebViewRuntime): PageDispatcher;

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

@@ -1,3 +1,5 @@
+import { type ExposedPageCapability, type PageConsoleEvent, type PageLifecycleEvent, type PageRequestHandler, type PageStream } from "./dispatcher.js";
+export { PAGE_HANDSHAKE_CAPABILITY, PAGE_HANDSHAKE_METHOD, type ExposedPageCapability, type PageCapabilityRequest, type PageCapabilityResponse, type PageConsoleEvent, type PageCtx, type PageLifecycleEvent, type PageRequestHandler, type PageStream, } from "./dispatcher.js";
 /**
  * Push a message from the worker to the hosting webview page. Delivered to every
  * `window.HimalayaWorker.onMessage(cb)` handler the page registered. `msg` is
@@ -7,35 +9,43 @@
  */
 export declare function postToPage(msg: unknown): void;
 /**
- * Register a handler for messages the page posts via `window.HimalayaWorker.post(msg)`.
- * The latest registered handler wins. Call this once during the bundle's setup.
- */
-export declare function onPageMessage(cb: (msg: unknown) => void): void;
-export interface PageCapabilityRequest {
-    v: 1;
-    id: string;
-    capability: string;
-    method: string;
-    args: unknown[];
-}
-export interface PageCapabilityResponse {
-    v: 1;
-    id: string;
-    ok: boolean;
-    result?: unknown;
-    error?: {
-        message: string;
-        code?: string;
-    };
-}
-/** `call("himalaya", "capabilities")` answers `{ v: 1, capabilities: { <id>: [<method>…] } }`:
- *  exactly the allowlist this worker was given. Reserved, so no real capability can take it. */
-export declare const PAGE_HANDSHAKE_CAPABILITY = "himalaya";
-export declare const PAGE_HANDSHAKE_METHOD = "capabilities";
-export interface ExposedPageCapability {
-    module: Record<string, unknown>;
-    methods: readonly string[];
-}
+ * Register a handler for messages the page posts via `window.HimalayaWorker.post(msg)` that no
+ * responder (`exposeCapabilitiesToPage`, `onPageRequest`) claims. The latest registered handler
+ * wins. `instanceId` is the embedded WebView the host says the message came from (`""` for the
+ * full-screen page). Call this once during the bundle's setup.
+ */
+export declare function onPageMessage(cb: (msg: unknown, instanceId: string) => void): void;
+/**
+ * Answer page requests `call(namespace, method, args)` from `@wix/himalaya/webview-page` (or
+ * `himalaya.<namespace>.<method>(…)`) with worker code. A handler gets `(args, ctx)` and returns a value or a promise; a throw answers
+ * `ok: false`. To stream, return `openPageStream(ctx.instanceId, ctx.requestId)`.
+ *
+ * Throws when `namespace` is `"himalaya"`, already registered, already exposed, or not
+ * `/^[a-z][a-z0-9_]{0,63}$/`. A method the namespace lacks answers `code: "unknown_method"`.
+ */
+export declare function onPageRequest(namespace: string, handlers: Readonly<Record<string, PageRequestHandler>>): void;
+/**
+ * Push an event to one page instance, or `"*"` for every instance that has sent a message or
+ * mounted and not unmounted. `event` is `"<namespace>.<event>"`, split on the first dot; the page
+ * receives it through `himalaya.<namespace>.on("<event>", cb)`.
+ */
+export declare function emitToPage(instanceId: string, event: `${string}.${string}`, data: unknown): void;
+/**
+ * Open a stream answer for an in-flight `onPageRequest` call. Return the handle from the handler;
+ * the page then iterates the chunks. After `end`, `error`, or a page cancel, `next` is a no-op.
+ */
+export declare function openPageStream(instanceId: string, requestId: string): PageStream;
+/**
+ * Observe host lifecycle envelopes (`mounted | loaded | active | inactive | crashed | reloaded |
+ * navBlocked | unmounted`). They arrive only on the host's lifecycle primitive, never from a page.
+ * On a runtime without instance support, nothing is delivered. Returns an unsubscribe function.
+ */
+export declare function onPageLifecycle(cb: (e: PageLifecycleEvent) => void): () => void;
+/**
+ * Observe `console_forwarding` output of the embedded pages. UNTRUSTED page data: a page can forge
+ * these, so never treat them as host events. Returns an unsubscribe function.
+ */
+export declare function onPageConsole(cb: (e: PageConsoleEvent) => void): () => void;
 /**
  * Expose selected typed @himalaya/* modules to the hosting page.
  *
@@ -47,7 +57,8 @@ export interface ExposedPageCapability {
  *   });
  *
  * The bundle still has to declare `webview` plus every exposed capability. Importing only
- * selected modules keeps native permissions and `himi dist` additions opt-in.
+ * selected modules keeps native permissions and `himi dist` additions opt-in. The page handshake
+ * (`call("himalaya", "capabilities")`) answers this allowlist plus every `onPageRequest` namespace.
  */
 export declare function exposeCapabilitiesToPage(capabilities: Readonly<Record<string, ExposedPageCapability>>): void;
 export declare const version = 1;

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

@@ -38,55 +38,61 @@ import type * as ThemeSdk from "@wix/himalaya/theme";
 import type * as UiSdk from "@wix/himalaya/ui";
 import type * as WixCashierSdk from "@wix/himalaya/wix-cashier";
 import type * as WixChatSdk from "@wix/himalaya/wix-chat";
+import type { PageClient } from "./client.js";
 type PageModule<T> = {
     readonly [P in keyof T as T[P] extends (...args: any[]) => any ? P : T[P] extends readonly unknown[] ? never : T[P] extends object ? keyof PageModule<T[P]> extends never ? never : P : never]: T[P] extends (...args: infer A) => infer R ? (...args: A) => R : T[P] extends readonly unknown[] ? never : T[P] extends object ? PageModule<T[P]> : never;
 };
+/** `himalaya.<ns>.on(event, cb)`: events the worker pushes with `emitToPage(iid, "<ns>.<event>", data)`. */
+type PageEvents = {
+    on(event: string, handler: (data: unknown) => void): () => void;
+};
 /** Every typed request/response capability a trusted WebView page can ask its companion worker for.
  * Availability is still opt-in: the worker imports a subset and its logic-bundle manifest declares
  * that same subset; every other namespace/method is ignored. */
 export interface HimalayaPageCapabilities {
-    readonly "app_info": PageModule<typeof AppInfoSdk>;
-    readonly "audio_record": PageModule<typeof AudioRecordSdk>;
-    readonly "base44": PageModule<typeof Base44Sdk>;
-    readonly "biometrics": PageModule<typeof BiometricsSdk>;
-    readonly "browser_auth": PageModule<typeof BrowserAuthSdk>;
-    readonly "calendar": PageModule<typeof CalendarSdk>;
-    readonly "calls": PageModule<typeof CallsSdk>;
-    readonly "camera": PageModule<typeof CameraSdk>;
-    readonly "clipboard": PageModule<typeof ClipboardSdk>;
-    readonly "contacts": PageModule<typeof ContactsSdk>;
-    readonly "file_picker": PageModule<typeof FilePickerSdk>;
-    readonly "files": PageModule<typeof FilesSdk>;
-    readonly "godot": PageModule<typeof GodotSdk>;
-    readonly "haptic": PageModule<typeof HapticSdk>;
-    readonly "health": PageModule<typeof HealthSdk>;
-    readonly "himi_apps": PageModule<typeof HimiAppsSdk>;
-    readonly "iap": PageModule<typeof IapSdk>;
-    readonly "keyboard": PageModule<typeof KeyboardSdk>;
-    readonly "live_activity": PageModule<typeof LiveActivitySdk>;
-    readonly "local_database": PageModule<typeof LocalDatabaseSdk>;
-    readonly "location": PageModule<typeof LocationSdk>;
-    readonly "media_playback": PageModule<typeof MediaPlaybackSdk>;
-    readonly "motion": PageModule<typeof MotionSdk>;
-    readonly "on_device_ai": PageModule<typeof OnDeviceAiSdk>;
-    readonly "open_url": PageModule<typeof OpenUrlSdk>;
-    readonly "pdf": PageModule<typeof PdfSdk>;
-    readonly "photos": PageModule<typeof PhotosSdk>;
-    readonly "presigned_upload": PageModule<typeof PresignedUploadSdk>;
-    readonly "push": PageModule<typeof PushSdk>;
-    readonly "release_control": PageModule<typeof ReleaseControlSdk>;
-    readonly "secure_storage": PageModule<typeof SecureStorageSdk>;
-    readonly "share": PageModule<typeof ShareSdk>;
-    readonly "speaker_diarization": PageModule<typeof SpeakerDiarizationSdk>;
-    readonly "speech": PageModule<typeof SpeechSdk>;
-    readonly "system_intents": PageModule<typeof SystemIntentsSdk>;
-    readonly "tasks": PageModule<typeof TasksSdk>;
-    readonly "theme": PageModule<typeof ThemeSdk>;
-    readonly "ui": PageModule<typeof UiSdk>;
-    readonly "wix_cashier": PageModule<typeof WixCashierSdk>;
-    readonly "wix_chat": PageModule<typeof WixChatSdk>;
+    readonly "app_info": PageModule<typeof AppInfoSdk> & PageEvents;
+    readonly "audio_record": PageModule<typeof AudioRecordSdk> & PageEvents;
+    readonly "base44": PageModule<typeof Base44Sdk> & PageEvents;
+    readonly "biometrics": PageModule<typeof BiometricsSdk> & PageEvents;
+    readonly "browser_auth": PageModule<typeof BrowserAuthSdk> & PageEvents;
+    readonly "calendar": PageModule<typeof CalendarSdk> & PageEvents;
+    readonly "calls": PageModule<typeof CallsSdk> & PageEvents;
+    readonly "camera": PageModule<typeof CameraSdk> & PageEvents;
+    readonly "clipboard": PageModule<typeof ClipboardSdk> & PageEvents;
+    readonly "contacts": PageModule<typeof ContactsSdk> & PageEvents;
+    readonly "file_picker": PageModule<typeof FilePickerSdk> & PageEvents;
+    readonly "files": PageModule<typeof FilesSdk> & PageEvents;
+    readonly "godot": PageModule<typeof GodotSdk> & PageEvents;
+    readonly "haptic": PageModule<typeof HapticSdk> & PageEvents;
+    readonly "health": PageModule<typeof HealthSdk> & PageEvents;
+    readonly "himi_apps": PageModule<typeof HimiAppsSdk> & PageEvents;
+    readonly "iap": PageModule<typeof IapSdk> & PageEvents;
+    readonly "keyboard": PageModule<typeof KeyboardSdk> & PageEvents;
+    readonly "live_activity": PageModule<typeof LiveActivitySdk> & PageEvents;
+    readonly "local_database": PageModule<typeof LocalDatabaseSdk> & PageEvents;
+    readonly "location": PageModule<typeof LocationSdk> & PageEvents;
+    readonly "media_playback": PageModule<typeof MediaPlaybackSdk> & PageEvents;
+    readonly "motion": PageModule<typeof MotionSdk> & PageEvents;
+    readonly "on_device_ai": PageModule<typeof OnDeviceAiSdk> & PageEvents;
+    readonly "open_url": PageModule<typeof OpenUrlSdk> & PageEvents;
+    readonly "pdf": PageModule<typeof PdfSdk> & PageEvents;
+    readonly "photos": PageModule<typeof PhotosSdk> & PageEvents;
+    readonly "presigned_upload": PageModule<typeof PresignedUploadSdk> & PageEvents;
+    readonly "push": PageModule<typeof PushSdk> & PageEvents;
+    readonly "release_control": PageModule<typeof ReleaseControlSdk> & PageEvents;
+    readonly "secure_storage": PageModule<typeof SecureStorageSdk> & PageEvents;
+    readonly "share": PageModule<typeof ShareSdk> & PageEvents;
+    readonly "speaker_diarization": PageModule<typeof SpeakerDiarizationSdk> & PageEvents;
+    readonly "speech": PageModule<typeof SpeechSdk> & PageEvents;
+    readonly "system_intents": PageModule<typeof SystemIntentsSdk> & PageEvents;
+    readonly "tasks": PageModule<typeof TasksSdk> & PageEvents;
+    readonly "theme": PageModule<typeof ThemeSdk> & PageEvents;
+    readonly "ui": PageModule<typeof UiSdk> & PageEvents;
+    readonly "wix_cashier": PageModule<typeof WixCashierSdk> & PageEvents;
+    readonly "wix_chat": PageModule<typeof WixChatSdk> & PageEvents;
 }
+/** `window.himalaya` and the package's `himalaya` export: the namespaces plus the client's own members. */
 export type HimalayaPageSdk = HimalayaPageCapabilities & {
     readonly version: 1;
-};
+} & Readonly<Pick<PageClient, "call" | "on" | "enabledCapabilities" | "isEnabled" | "probe">>;
 export {};

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/sdk/webview-page/src/client.d.ts

@@ -0,0 +1,68 @@
+export interface WebViewPageRequest {
+    v: 1;
+    id: string;
+    capability: string;
+    method: string;
+    args: unknown[];
+}
+export interface WebViewPageError {
+    message: string;
+    code?: string;
+}
+export interface WebViewPageResponse {
+    v: 1;
+    id: string;
+    ok: boolean;
+    result?: unknown;
+    /** The answer is a stream: `call()` resolves to an AsyncIterable of the chunks. */
+    stream?: boolean;
+    error?: WebViewPageError;
+}
+/** `emitToPage(iid, "<ns>.<ev>", data)` on the worker. */
+export interface WebViewPageEvent {
+    v: 1;
+    ev: string;
+    ns: string;
+    data?: unknown;
+}
+/** One envelope of a streamed answer; `sid` is the request id. */
+export type WebViewPageStreamEnvelope = {
+    v: 1;
+    sid: string;
+    chunk: unknown;
+} | {
+    v: 1;
+    sid: string;
+    end: true;
+} | {
+    v: 1;
+    sid: string;
+    error: WebViewPageError;
+};
+export interface HimalayaWorkerBridge {
+    post(message: unknown): boolean;
+    onMessage(handler: (message: unknown) => void): void;
+}
+export type PageEventHandler = (data: unknown) => void;
+export interface PageClient {
+    call<T>(capability: string, method: string, args?: unknown[], timeoutMs?: number): Promise<T>;
+    /** Subscribe to `namespace.event` pushed by the worker. Returns the unsubscribe function. */
+    on(namespace: string, event: string, handler: PageEventHandler): () => void;
+    enabledCapabilities(timeoutMs?: number): Promise<Record<string, string[]> | null>;
+    isEnabled(capability: string, method: string, timeoutMs?: number): Promise<boolean>;
+    probe(capability: string, method: string, args?: unknown[], timeoutMs?: number): Promise<boolean>;
+    /** `himalaya.<capability>` — a proxy whose members call, plus `.on(event, cb)`. */
+    namespace(capability: string): object;
+    /**
+     * Merge this client into a host's `himalaya` object (the RFC 0038 shim's) and return what to
+     * install as `window.himalaya`: `target` gains `call`, `on`, `enabledCapabilities`, `isEnabled`,
+     * `probe` and `version`, is frozen, and any other name resolves to a namespace proxy. Existing
+     * members of `target` (e.g. the shim's `general`) win.
+     */
+    merge<T extends object>(target: T): T;
+}
+/**
+ * A page client over the bridge `getBridge()` returns (`undefined` outside a worker-backed
+ * WebView). Calls and listeners re-attach when the page's bridge object changes.
+ */
+export declare function createPageClient(getBridge: () => HimalayaWorkerBridge | undefined): PageClient;

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

@@ -1,27 +1,16 @@
 import type { HimalayaPageSdk } from "./capabilities.generated.js";
 export type { HimalayaPageCapabilities, HimalayaPageSdk } from "./capabilities.generated.js";
-export interface WebViewPageRequest {
-    v: 1;
-    id: string;
-    capability: string;
-    method: string;
-    args: unknown[];
-}
-export interface WebViewPageError {
-    message: string;
-    code?: string;
-}
-export interface WebViewPageResponse {
-    v: 1;
-    id: string;
-    ok: boolean;
-    result?: unknown;
-    error?: WebViewPageError;
-}
+import { type PageEventHandler } from "./client.js";
+export type { PageEventHandler, WebViewPageError, WebViewPageEvent, WebViewPageRequest, WebViewPageResponse, WebViewPageStreamEnvelope, } from "./client.js";
 /** Invoke one method through the companion worker. Primarily useful to generated bindings.
  *  A call that shows native UI (a permission prompt, the share sheet) answers only when the user
- *  is done with it: pass a long `timeoutMs` (e.g. 120_000) rather than the 30-second default. */
+ *  is done with it: pass a long `timeoutMs` (e.g. 120_000) rather than the 30-second default.
+ *  A method the worker answers as a stream resolves to an `AsyncIterable` of its chunks:
+ *  `for await (const chunk of await call(…))`; `break` cancels it on the worker. */
 export declare function call<T>(capability: string, method: string, args?: unknown[], timeoutMs?: number): Promise<T>;
+/** Subscribe to `namespace.event`, pushed by the worker's `emitToPage(iid, "<namespace>.<event>", data)`.
+ *  Same as `himalaya.<namespace>.on(event, handler)`. Returns the unsubscribe function. */
+export declare function on(namespace: string, event: string, handler: PageEventHandler): () => void;
 /**
  * The capabilities and methods this page's companion worker answers, as `{ <id>: [<method>…] }`;
  * `null` outside the app, when the app is older than the handshake, or nothing answered in
@@ -33,12 +22,13 @@ export declare function enabledCapabilities(timeoutMs?: number): Promise<Record<
  *  enabledCapabilities() — nothing is called. `false` when there is no list. */
 export declare function isEnabled(capability: string, method: string, timeoutMs?: number): Promise<boolean>;
 /** For an app older than the handshake: CALL `capability.method` and report whether it answered
- *  (even with an error). It runs the method, so pass only a read-only one. */
+ *  (even with an error other than `unknown_method`). It runs the method, so pass only a read-only one. */
 export declare function probe(capability: string, method: string, args?: unknown[], timeoutMs?: number): Promise<boolean>;
 /**
  * Typed SDK proxy for every request/response capability in CAPABILITY_REGISTRY.
  * A namespace is usable only when this screen's companion worker explicitly imported and
- * exposed it and the bundle + host both declared it.
+ * exposed it and the bundle + host both declared it. Built by the same `merge` a host uses for the
+ * injected client, so `himalaya.call/on/probe/…` are the client's members here too.
  */
 export declare const himalaya: HimalayaPageSdk;
 /** Convenience named export; equivalent to `himalaya.health`. */
@@ -79,5 +69,7 @@ export declare const health: {
             id: string;
         }>;
     };
+} & {
+    on(event: string, handler: (data: unknown) => void): () => void;
 };
 export declare const version = 1;