@everysk/apps-sdk 0.1.0-beta.0

package/dist/contexts/appConfigContext/useAppConfig.js

@@ -0,0 +1,30 @@
+import { AppConfigContext } from "./index.js";
+import { useContext } from "react";
+//#region src/contexts/appConfigContext/useAppConfig.ts
+/**
+* useAppConfig
+*
+* Convenience hook that reads the current application configuration from `AppConfigContext`.
+*
+* Behavior:
+* - Returns the `AppConfigContextType` value provided by `<AppConfigProvider>`.
+* - Throws a descriptive error if called outside of an `<AppConfigProvider>` scope, to fail fast and
+*   avoid undefined configuration usage throughout the app.
+*
+* Usage:
+* ```ts
+* const { appId, appEnvironmentVar } = useAppConfig();
+* ```
+*
+* @throws {Error}
+*  Throws if the hook is used outside of `<AppConfigProvider>`.
+*/
+var useAppConfig = () => {
+	const context = useContext(AppConfigContext);
+	if (!context) throw new Error("useAppConfig must be used within <AppConfigProvider>.");
+	return context;
+};
+//#endregion
+export { useAppConfig };
+
+//# sourceMappingURL=useAppConfig.js.map

package/dist/contexts/appConfigContext/useAppConfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAppConfig.js","names":[],"sources":["../../../src/contexts/appConfigContext/useAppConfig.ts"],"sourcesContent":["import { useContext } from \"react\";\n\nimport { AppConfigContext } from \".\";\n\n/**\n * useAppConfig\n *\n * Convenience hook that reads the current application configuration from `AppConfigContext`.\n *\n * Behavior:\n * - Returns the `AppConfigContextType` value provided by `<AppConfigProvider>`.\n * - Throws a descriptive error if called outside of an `<AppConfigProvider>` scope, to fail fast and\n *   avoid undefined configuration usage throughout the app.\n *\n * Usage:\n * ```ts\n * const { appId, appEnvironmentVar } = useAppConfig();\n * ```\n *\n * @throws {Error}\n *  Throws if the hook is used outside of `<AppConfigProvider>`.\n */\n\nexport const useAppConfig = () => {\n    const context = useContext(AppConfigContext);\n    if (!context) {\n        throw new Error(\"useAppConfig must be used within <AppConfigProvider>.\");\n    }\n    return context;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAuBA,IAAa,qBAAqB;CAC9B,MAAM,UAAU,WAAW,gBAAgB;CAC3C,IAAI,CAAC,SACD,MAAM,IAAI,MAAM,uDAAuD;CAE3E,OAAO;AACX"}

package/dist/contexts/webSocketContext/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const NOTIFICATION_EVENT = "notification";
+export declare const JOIN_EVENT = "join";
+export declare const APP_NOTIFICATION_EVENT_TYPE = "USER_APP_NOTIFICATION";
+//# sourceMappingURL=constants.d.ts.map

package/dist/contexts/webSocketContext/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,iBAAiB,CAAC;AACjD,eAAO,MAAM,UAAU,SAAS,CAAC;AACjC,eAAO,MAAM,2BAA2B,0BAA0B,CAAC"}

package/dist/contexts/webSocketContext/constants.js

@@ -0,0 +1,8 @@
+//#region src/contexts/webSocketContext/constants.ts
+var NOTIFICATION_EVENT = "notification";
+var JOIN_EVENT = "join";
+var APP_NOTIFICATION_EVENT_TYPE = "USER_APP_NOTIFICATION";
+//#endregion
+export { APP_NOTIFICATION_EVENT_TYPE, JOIN_EVENT, NOTIFICATION_EVENT };
+
+//# sourceMappingURL=constants.js.map

package/dist/contexts/webSocketContext/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":[],"sources":["../../../src/contexts/webSocketContext/constants.ts"],"sourcesContent":["export const NOTIFICATION_EVENT = \"notification\";\nexport const JOIN_EVENT = \"join\";\nexport const APP_NOTIFICATION_EVENT_TYPE = \"USER_APP_NOTIFICATION\";\n"],"mappings":";AAAA,IAAa,qBAAqB;AAClC,IAAa,aAAa;AAC1B,IAAa,8BAA8B"}

package/dist/contexts/webSocketContext/handler.d.ts

@@ -0,0 +1,43 @@
+import type { WebSocketNotification, WebSocketStatus, WebsocketsConfig } from "./types";
+type StatusListener = (status: Exclude<WebSocketStatus, "idle">) => void;
+type WebSocketHandlerConfig = WebsocketsConfig & {
+    onStatusChange?: StatusListener;
+};
+/**
+ * WebSocketHandler
+ *
+ * Low-level Socket.IO wrapper with a pub/sub layer.
+ *
+ * - Connects to the notification server.
+ * - Joins the per-user channel.
+ * - Forwards notifications to registered listeners.
+ *
+ * API:
+ * - `listen(callback)`: register a notification listener; returns an unsubscribe function.
+ * - `close()`: disconnect the socket and clear all listeners.
+ */
+export declare class WebSocketHandler {
+    private _socket;
+    private _everyskUID;
+    private _listeners;
+    constructor({ appConnectionURL, appChannelID, everyskUID, onStatusChange }: WebSocketHandlerConfig);
+    private _isEcho;
+    /**
+     * listen
+     *
+     * Registers a listener that receives every incoming notification.
+     *
+     * @param {(msg: WebSocketNotification) => void} callback - Invoked for each notification.
+     * @returns {() => void} Unsubscribe function.
+     */
+    listen(callback: (msg: WebSocketNotification) => void): () => void;
+    /**
+     * close
+     *
+     * Clears all listeners and disconnects the socket.
+     * After calling this, the handler should be considered unusable.
+     */
+    close(): void;
+}
+export {};
+//# sourceMappingURL=handler.d.ts.map

package/dist/contexts/webSocketContext/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/handler.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAWxF,KAAK,cAAc,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,eAAe,EAAE,MAAM,CAAC,KAAK,IAAI,CAAC;AAEzE,KAAK,sBAAsB,GAAG,gBAAgB,GAAG;IAC7C,cAAc,CAAC,EAAE,cAAc,CAAC;CACnC,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,qBAAa,gBAAgB;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAwD;gBAE9D,EAAE,gBAAgB,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,EAAE,sBAAsB;IAoClG,OAAO,CAAC,OAAO;IAUf;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,EAAE,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,GAAG,MAAM,IAAI;IAKlE;;;;;OAKG;IACH,KAAK,IAAI,IAAI;CAKhB"}

package/dist/contexts/webSocketContext/handler.js

@@ -0,0 +1,87 @@
+import { JOIN_EVENT, NOTIFICATION_EVENT } from "./constants.js";
+import { io } from "socket.io-client";
+//#region src/contexts/webSocketContext/handler.ts
+function isWebSocketNotification(value) {
+	return typeof value === "object" && value !== null && typeof value["event_type"] === "string";
+}
+/**
+* WebSocketHandler
+*
+* Low-level Socket.IO wrapper with a pub/sub layer.
+*
+* - Connects to the notification server.
+* - Joins the per-user channel.
+* - Forwards notifications to registered listeners.
+*
+* API:
+* - `listen(callback)`: register a notification listener; returns an unsubscribe function.
+* - `close()`: disconnect the socket and clear all listeners.
+*/
+var WebSocketHandler = class {
+	_socket;
+	_everyskUID;
+	_listeners = /* @__PURE__ */ new Set();
+	constructor({ appConnectionURL, appChannelID, everyskUID, onStatusChange }) {
+		this._everyskUID = everyskUID;
+		this._socket = io(appConnectionURL, {
+			auth: {
+				appChannelID,
+				everyskUID
+			},
+			transports: ["websocket"]
+		});
+		this._socket.on("connect", () => {
+			this._socket.emit(JOIN_EVENT, appChannelID);
+			onStatusChange?.("connected");
+		});
+		this._socket.on("connect_error", (error) => {
+			console.error("Socket.IO connection error:", error);
+			onStatusChange?.("error");
+		});
+		this._socket.on("disconnect", (reason) => {
+			console.error("Socket.IO disconnected:", reason);
+			onStatusChange?.(reason === "io server disconnect" ? "error" : "connecting");
+		});
+		this._socket.on(NOTIFICATION_EVENT, (msg) => {
+			if (!isWebSocketNotification(msg)) return;
+			if (this._isEcho(msg)) return;
+			this._listeners.forEach((callback) => {
+				try {
+					callback(msg);
+				} catch (error) {
+					console.error("Socket.IO notification listener threw:", error);
+				}
+			});
+		});
+	}
+	_isEcho(msg) {
+		return false;
+	}
+	/**
+	* listen
+	*
+	* Registers a listener that receives every incoming notification.
+	*
+	* @param {(msg: WebSocketNotification) => void} callback - Invoked for each notification.
+	* @returns {() => void} Unsubscribe function.
+	*/
+	listen(callback) {
+		this._listeners.add(callback);
+		return () => this._listeners.delete(callback);
+	}
+	/**
+	* close
+	*
+	* Clears all listeners and disconnects the socket.
+	* After calling this, the handler should be considered unusable.
+	*/
+	close() {
+		this._listeners.clear();
+		this._socket.removeAllListeners();
+		this._socket.disconnect();
+	}
+};
+//#endregion
+export { WebSocketHandler };
+
+//# sourceMappingURL=handler.js.map

package/dist/contexts/webSocketContext/handler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.js","names":[],"sources":["../../../src/contexts/webSocketContext/handler.ts"],"sourcesContent":["import { io, type Socket } from \"socket.io-client\";\n\nimport type { WebSocketNotification, WebSocketStatus, WebsocketsConfig } from \"./types\";\n\nfunction isWebSocketNotification(value: unknown): value is WebSocketNotification {\n    return (\n        typeof value === \"object\" &&\n        value !== null &&\n        typeof (value as Record<string, unknown>)[\"event_type\"] === \"string\"\n    );\n}\nimport { JOIN_EVENT, NOTIFICATION_EVENT } from \"./constants\";\n\ntype StatusListener = (status: Exclude<WebSocketStatus, \"idle\">) => void;\n\ntype WebSocketHandlerConfig = WebsocketsConfig & {\n    onStatusChange?: StatusListener;\n};\n\n/**\n * WebSocketHandler\n *\n * Low-level Socket.IO wrapper with a pub/sub layer.\n *\n * - Connects to the notification server.\n * - Joins the per-user channel.\n * - Forwards notifications to registered listeners.\n *\n * API:\n * - `listen(callback)`: register a notification listener; returns an unsubscribe function.\n * - `close()`: disconnect the socket and clear all listeners.\n */\nexport class WebSocketHandler {\n    private _socket: Socket;\n    private _everyskUID: string;\n    private _listeners: Set<(msg: WebSocketNotification) => void> = new Set();\n\n    constructor({ appConnectionURL, appChannelID, everyskUID, onStatusChange }: WebSocketHandlerConfig) {\n        this._everyskUID = everyskUID;\n\n        this._socket = io(appConnectionURL, {\n            auth: { appChannelID, everyskUID },\n            transports: [\"websocket\"],\n        });\n\n        this._socket.on(\"connect\", () => {\n            this._socket.emit(JOIN_EVENT, appChannelID);\n            onStatusChange?.(\"connected\");\n        });\n\n        this._socket.on(\"connect_error\", (error) => {\n            console.error(\"Socket.IO connection error:\", error);\n            onStatusChange?.(\"error\");\n        });\n\n        this._socket.on(\"disconnect\", (reason: string) => {\n            console.error(\"Socket.IO disconnected:\", reason);\n            onStatusChange?.(reason === \"io server disconnect\" ? \"error\" : \"connecting\");\n        });\n\n        this._socket.on(NOTIFICATION_EVENT, (msg: unknown) => {\n            if (!isWebSocketNotification(msg)) return;\n            if (this._isEcho(msg)) return;\n            this._listeners.forEach((callback) => {\n                try {\n                    callback(msg);\n                } catch (error) {\n                    console.error(\"Socket.IO notification listener threw:\", error);\n                }\n            });\n        });\n    }\n\n    private _isEcho(msg: WebSocketNotification): boolean {\n        // Echo-cancellation is disabled by default.\n        // Set ECHO_UID_FIELD to the message field that carries the originating uid\n        // once the server team confirms the field name.\n        const ECHO_UID_FIELD: string | null = null;\n        if (!ECHO_UID_FIELD) return false;\n        const originating = (msg as Record<string, unknown>)[ECHO_UID_FIELD];\n        return originating === this._everyskUID;\n    }\n\n    /**\n     * listen\n     *\n     * Registers a listener that receives every incoming notification.\n     *\n     * @param {(msg: WebSocketNotification) => void} callback - Invoked for each notification.\n     * @returns {() => void} Unsubscribe function.\n     */\n    listen(callback: (msg: WebSocketNotification) => void): () => void {\n        this._listeners.add(callback);\n        return () => this._listeners.delete(callback);\n    }\n\n    /**\n     * close\n     *\n     * Clears all listeners and disconnects the socket.\n     * After calling this, the handler should be considered unusable.\n     */\n    close(): void {\n        this._listeners.clear();\n        this._socket.removeAllListeners();\n        this._socket.disconnect();\n    }\n}\n"],"mappings":";;;AAIA,SAAS,wBAAwB,OAAgD;CAC7E,OACI,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAAkC,kBAAkB;AAEpE;;;;;;;;;;;;;;AAsBA,IAAa,mBAAb,MAA8B;CAC1B;CACA;CACA,6BAAgE,IAAI,IAAI;CAExE,YAAY,EAAE,kBAAkB,cAAc,YAAY,kBAA0C;EAChG,KAAK,cAAc;EAEnB,KAAK,UAAU,GAAG,kBAAkB;GAChC,MAAM;IAAE;IAAc;GAAW;GACjC,YAAY,CAAC,WAAW;EAC5B,CAAC;EAED,KAAK,QAAQ,GAAG,iBAAiB;GAC7B,KAAK,QAAQ,KAAK,YAAY,YAAY;GAC1C,iBAAiB,WAAW;EAChC,CAAC;EAED,KAAK,QAAQ,GAAG,kBAAkB,UAAU;GACxC,QAAQ,MAAM,+BAA+B,KAAK;GAClD,iBAAiB,OAAO;EAC5B,CAAC;EAED,KAAK,QAAQ,GAAG,eAAe,WAAmB;GAC9C,QAAQ,MAAM,2BAA2B,MAAM;GAC/C,iBAAiB,WAAW,yBAAyB,UAAU,YAAY;EAC/E,CAAC;EAED,KAAK,QAAQ,GAAG,qBAAqB,QAAiB;GAClD,IAAI,CAAC,wBAAwB,GAAG,GAAG;GACnC,IAAI,KAAK,QAAQ,GAAG,GAAG;GACvB,KAAK,WAAW,SAAS,aAAa;IAClC,IAAI;KACA,SAAS,GAAG;IAChB,SAAS,OAAO;KACZ,QAAQ,MAAM,0CAA0C,KAAK;IACjE;GACJ,CAAC;EACL,CAAC;CACL;CAEA,QAAgB,KAAqC;EAK5B,OAAO;CAGhC;;;;;;;;;CAUA,OAAO,UAA4D;EAC/D,KAAK,WAAW,IAAI,QAAQ;EAC5B,aAAa,KAAK,WAAW,OAAO,QAAQ;CAChD;;;;;;;CAQA,QAAc;EACV,KAAK,WAAW,MAAM;EACtB,KAAK,QAAQ,mBAAmB;EAChC,KAAK,QAAQ,WAAW;CAC5B;AACJ"}

package/dist/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.d.ts

@@ -0,0 +1,19 @@
+import type { AppNotification } from "../../types";
+/**
+ * useAppNotificationSubscription
+ *
+ * Convenience wrapper around `useWebSocketSubscription` that only invokes the handler
+ * for `event_type === "USER_APP_NOTIFICATION"` messages. All other WebSocket events are ignored.
+ *
+ * @param {(msg: AppNotification) => void} handler
+ *  Callback invoked for each app-targeted notification.
+ *
+ * Example:
+ * ```ts
+ * useAppNotificationSubscription((msg) => {
+ *   queryClient.invalidateQueries({ queryKey: ["portfolios"] });
+ * });
+ * ```
+ */
+export declare const useAppNotificationSubscription: (handler: (msg: AppNotification) => void) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAyB,MAAM,aAAa,CAAC;AAW1E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,8BAA8B,GAAI,SAAS,CAAC,GAAG,EAAE,eAAe,KAAK,IAAI,SAMrF,CAAC"}

package/dist/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js

@@ -0,0 +1,31 @@
+import "../../constants.js";
+import { useWebSocketSubscription } from "../useWebSocketSubscription/index.js";
+//#region src/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.ts
+function isAppNotification(msg) {
+	return msg.event_type === "USER_APP_NOTIFICATION" && typeof msg["user_app_id"] === "string" && typeof msg["payload"] === "object" && msg["payload"] !== null;
+}
+/**
+* useAppNotificationSubscription
+*
+* Convenience wrapper around `useWebSocketSubscription` that only invokes the handler
+* for `event_type === "USER_APP_NOTIFICATION"` messages. All other WebSocket events are ignored.
+*
+* @param {(msg: AppNotification) => void} handler
+*  Callback invoked for each app-targeted notification.
+*
+* Example:
+* ```ts
+* useAppNotificationSubscription((msg) => {
+*   queryClient.invalidateQueries({ queryKey: ["portfolios"] });
+* });
+* ```
+*/
+var useAppNotificationSubscription = (handler) => {
+	useWebSocketSubscription((msg) => {
+		if (isAppNotification(msg)) handler(msg);
+	});
+};
+//#endregion
+export { useAppNotificationSubscription };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/contexts/webSocketContext/hooks/useAppNotificationSubscription/index.ts"],"sourcesContent":["import { useWebSocketSubscription } from \"../useWebSocketSubscription\";\nimport { APP_NOTIFICATION_EVENT_TYPE } from \"../../constants\";\nimport type { AppNotification, WebSocketNotification } from \"../../types\";\n\nfunction isAppNotification(msg: WebSocketNotification): msg is AppNotification {\n    return (\n        msg.event_type === APP_NOTIFICATION_EVENT_TYPE &&\n        typeof msg[\"user_app_id\"] === \"string\" &&\n        typeof msg[\"payload\"] === \"object\" &&\n        msg[\"payload\"] !== null\n    );\n}\n\n/**\n * useAppNotificationSubscription\n *\n * Convenience wrapper around `useWebSocketSubscription` that only invokes the handler\n * for `event_type === \"USER_APP_NOTIFICATION\"` messages. All other WebSocket events are ignored.\n *\n * @param {(msg: AppNotification) => void} handler\n *  Callback invoked for each app-targeted notification.\n *\n * Example:\n * ```ts\n * useAppNotificationSubscription((msg) => {\n *   queryClient.invalidateQueries({ queryKey: [\"portfolios\"] });\n * });\n * ```\n */\nexport const useAppNotificationSubscription = (handler: (msg: AppNotification) => void) => {\n    useWebSocketSubscription((msg: WebSocketNotification) => {\n        if (isAppNotification(msg)) {\n            handler(msg);\n        }\n    });\n};\n"],"mappings":";;;AAIA,SAAS,kBAAkB,KAAoD;CAC3E,OACI,IAAI,eAAA,2BACJ,OAAO,IAAI,mBAAmB,YAC9B,OAAO,IAAI,eAAe,YAC1B,IAAI,eAAe;AAE3B;;;;;;;;;;;;;;;;;AAkBA,IAAa,kCAAkC,YAA4C;CACvF,0BAA0B,QAA+B;EACrD,IAAI,kBAAkB,GAAG,GACrB,QAAQ,GAAG;CAEnB,CAAC;AACL"}

package/dist/contexts/webSocketContext/hooks/useWebSocket/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * useWebSocket
+ *
+ * Convenience hook that reads the WebSocket API from `WebSocketContext`.
+ *
+ * Returns: `{ subscribe, lastMessage, status }` (see `WebSocketContextType`).
+ *
+ * @throws {Error} If used outside of `<WebSocketProvider>`.
+ */
+export declare const useWebSocket: () => import("../../types").WebSocketContextType;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/webSocketContext/hooks/useWebSocket/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/contexts/webSocketContext/hooks/useWebSocket/index.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,kDAIxB,CAAC"}

package/dist/contexts/webSocketContext/hooks/useWebSocket/index.js

@@ -0,0 +1,21 @@
+import { WebSocketContext } from "../../index.js";
+import { useContext } from "react";
+//#region src/contexts/webSocketContext/hooks/useWebSocket/index.ts
+/**
+* useWebSocket
+*
+* Convenience hook that reads the WebSocket API from `WebSocketContext`.
+*
+* Returns: `{ subscribe, lastMessage, status }` (see `WebSocketContextType`).
+*
+* @throws {Error} If used outside of `<WebSocketProvider>`.
+*/
+var useWebSocket = () => {
+	const context = useContext(WebSocketContext);
+	if (!context) throw new Error("useWebSocket must be used within <WebSocketProvider>.");
+	return context;
+};
+//#endregion
+export { useWebSocket };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/webSocketContext/hooks/useWebSocket/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/contexts/webSocketContext/hooks/useWebSocket/index.ts"],"sourcesContent":["import { useContext } from \"react\";\n\nimport { WebSocketContext } from \"../..\";\n\n/**\n * useWebSocket\n *\n * Convenience hook that reads the WebSocket API from `WebSocketContext`.\n *\n * Returns: `{ subscribe, lastMessage, status }` (see `WebSocketContextType`).\n *\n * @throws {Error} If used outside of `<WebSocketProvider>`.\n */\nexport const useWebSocket = () => {\n    const context = useContext(WebSocketContext);\n    if (!context) throw new Error(\"useWebSocket must be used within <WebSocketProvider>.\");\n    return context;\n};\n"],"mappings":";;;;;;;;;;;;AAaA,IAAa,qBAAqB;CAC9B,MAAM,UAAU,WAAW,gBAAgB;CAC3C,IAAI,CAAC,SAAS,MAAM,IAAI,MAAM,uDAAuD;CACrF,OAAO;AACX"}

package/dist/contexts/webSocketContext/hooks/useWebSocketSubscription/index.d.ts

@@ -0,0 +1,30 @@
+import type { WebSocketNotification } from "../../types";
+/**
+ * useWebSocketSubscription
+ *
+ * High-level helper hook that subscribes to all WebSocket notifications on mount
+ * and unsubscribes on unmount.
+ *
+ * Why this exists:
+ * - Enforces the correct subscription pattern (`useEffect` + cleanup).
+ * - Prevents accidental duplicate subscriptions from re-renders.
+ * - Uses a ref-backed handler so the subscription is not recreated when the callback
+ *   identity changes — the latest handler is always called without re-subscribing.
+ *
+ * Filtering (e.g. by `msg.event_type`) is intentionally left to the consumer.
+ * See `useAppNotificationSubscription` for a typed convenience wrapper.
+ *
+ * @param {(msg: WebSocketNotification) => void} handler
+ *  Callback invoked for every received notification.
+ *
+ * Example:
+ * ```ts
+ * useWebSocketSubscription((msg) => {
+ *   if (msg.event_type === "WORKFLOW_EXECUTION_COMPLETED") {
+ *     queryClient.invalidateQueries({ queryKey: ["workflows"] });
+ *   }
+ * });
+ * ```
+ */
+export declare const useWebSocketSubscription: (handler: (msg: WebSocketNotification) => void) => void;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/webSocketContext/hooks/useWebSocketSubscription/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/contexts/webSocketContext/hooks/useWebSocketSubscription/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,wBAAwB,GAAI,SAAS,CAAC,GAAG,EAAE,qBAAqB,KAAK,IAAI,SAYrF,CAAC"}

package/dist/contexts/webSocketContext/hooks/useWebSocketSubscription/index.js

@@ -0,0 +1,44 @@
+import { useWebSocket } from "../useWebSocket/index.js";
+import { useEffect, useRef } from "react";
+//#region src/contexts/webSocketContext/hooks/useWebSocketSubscription/index.ts
+/**
+* useWebSocketSubscription
+*
+* High-level helper hook that subscribes to all WebSocket notifications on mount
+* and unsubscribes on unmount.
+*
+* Why this exists:
+* - Enforces the correct subscription pattern (`useEffect` + cleanup).
+* - Prevents accidental duplicate subscriptions from re-renders.
+* - Uses a ref-backed handler so the subscription is not recreated when the callback
+*   identity changes — the latest handler is always called without re-subscribing.
+*
+* Filtering (e.g. by `msg.event_type`) is intentionally left to the consumer.
+* See `useAppNotificationSubscription` for a typed convenience wrapper.
+*
+* @param {(msg: WebSocketNotification) => void} handler
+*  Callback invoked for every received notification.
+*
+* Example:
+* ```ts
+* useWebSocketSubscription((msg) => {
+*   if (msg.event_type === "WORKFLOW_EXECUTION_COMPLETED") {
+*     queryClient.invalidateQueries({ queryKey: ["workflows"] });
+*   }
+* });
+* ```
+*/
+var useWebSocketSubscription = (handler) => {
+	const { subscribe } = useWebSocket();
+	const handlerRef = useRef(handler);
+	useEffect(() => {
+		handlerRef.current = handler;
+	});
+	useEffect(() => {
+		return subscribe((msg) => handlerRef.current(msg));
+	}, [subscribe]);
+};
+//#endregion
+export { useWebSocketSubscription };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/webSocketContext/hooks/useWebSocketSubscription/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/contexts/webSocketContext/hooks/useWebSocketSubscription/index.ts"],"sourcesContent":["import { useEffect, useRef } from \"react\";\n\nimport { useWebSocket } from \"../useWebSocket\";\nimport type { WebSocketNotification } from \"../../types\";\n\n/**\n * useWebSocketSubscription\n *\n * High-level helper hook that subscribes to all WebSocket notifications on mount\n * and unsubscribes on unmount.\n *\n * Why this exists:\n * - Enforces the correct subscription pattern (`useEffect` + cleanup).\n * - Prevents accidental duplicate subscriptions from re-renders.\n * - Uses a ref-backed handler so the subscription is not recreated when the callback\n *   identity changes — the latest handler is always called without re-subscribing.\n *\n * Filtering (e.g. by `msg.event_type`) is intentionally left to the consumer.\n * See `useAppNotificationSubscription` for a typed convenience wrapper.\n *\n * @param {(msg: WebSocketNotification) => void} handler\n *  Callback invoked for every received notification.\n *\n * Example:\n * ```ts\n * useWebSocketSubscription((msg) => {\n *   if (msg.event_type === \"WORKFLOW_EXECUTION_COMPLETED\") {\n *     queryClient.invalidateQueries({ queryKey: [\"workflows\"] });\n *   }\n * });\n * ```\n */\nexport const useWebSocketSubscription = (handler: (msg: WebSocketNotification) => void) => {\n    const { subscribe } = useWebSocket();\n    const handlerRef = useRef(handler);\n\n    useEffect(() => {\n        handlerRef.current = handler;\n    });\n\n    useEffect(() => {\n        const unsubscribe = subscribe((msg: WebSocketNotification) => handlerRef.current(msg));\n        return unsubscribe;\n    }, [subscribe]);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,IAAa,4BAA4B,YAAkD;CACvF,MAAM,EAAE,cAAc,aAAa;CACnC,MAAM,aAAa,OAAO,OAAO;CAEjC,gBAAgB;EACZ,WAAW,UAAU;CACzB,CAAC;CAED,gBAAgB;EAEZ,OADoB,WAAW,QAA+B,WAAW,QAAQ,GAAG,CAC7E;CACX,GAAG,CAAC,SAAS,CAAC;AAClB"}

package/dist/contexts/webSocketContext/index.d.ts

@@ -0,0 +1,3 @@
+import type { WebSocketContextType } from "./types";
+export declare const WebSocketContext: import("react").Context<WebSocketContextType | null>;
+//# sourceMappingURL=index.d.ts.map

package/dist/contexts/webSocketContext/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/index.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,eAAO,MAAM,gBAAgB,sDAAmD,CAAC"}

package/dist/contexts/webSocketContext/index.js

@@ -0,0 +1,7 @@
+import { createContext } from "react";
+//#region src/contexts/webSocketContext/index.tsx
+var WebSocketContext = createContext(null);
+//#endregion
+export { WebSocketContext };
+
+//# sourceMappingURL=index.js.map

package/dist/contexts/webSocketContext/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../../src/contexts/webSocketContext/index.tsx"],"sourcesContent":["import { createContext } from \"react\";\n\nimport type { WebSocketContextType } from \"./types\";\n\nexport const WebSocketContext = createContext<WebSocketContextType | null>(null);\n"],"mappings":";;AAIA,IAAa,mBAAmB,cAA2C,IAAI"}

package/dist/contexts/webSocketContext/provider.d.ts

@@ -0,0 +1,39 @@
+import type { WebSocketProviderProps } from "./types";
+/**
+ * WebSocketProvider
+ *
+ * React context provider that exposes a receive-only pub/sub API backed by Socket.IO.
+ *
+ * What this provider does:
+ * - Fetches `/api/websockets_config` once on mount to get the connection URL, channel id,
+ *   and session uid. Socket.IO handles reconnection internally — the config is not re-fetched.
+ * - Opens a `WebSocketHandler` instance that connects and joins the per-user channel.
+ * - Exposes `subscribe`, `lastMessage`, and `status` via `WebSocketContext`.
+ *
+ * Why the pending buffer exists (`pendingRef`):
+ * - The handler is created asynchronously (after the config fetch resolves).
+ * - Consumers that call `subscribe` before the handler is ready have their callbacks buffered
+ *   and registered once the handler initializes, ensuring no early subscriptions are lost.
+ *
+ * Subscribe buffering behavior:
+ * - If `subscribe(fn)` is called before the handler exists, `fn` is stored with a `null` placeholder.
+ * - Once the handler is ready, all pending callbacks are registered and their unsubscribe functions
+ *   stored back into the map.
+ * - The returned cleanup always works: it calls the real unsubscribe if available, or removes
+ *   the entry from the pending map.
+ *
+ * Usage:
+ * ```tsx
+ * <WebSocketProvider>
+ *   <YourPage />
+ * </WebSocketProvider>
+ * ```
+ *
+ * Context value (WebSocketContextType):
+ * @returns {object}
+ *  - `subscribe(fn)`: register a listener; returns an unsubscribe function.
+ *  - `lastMessage`: the most recently received notification (or null).
+ *  - `status`: current connection status ("connecting" | "connected" | "error").
+ */
+export declare const WebSocketProvider: ({ children }: WebSocketProviderProps) => import("react").JSX.Element;
+//# sourceMappingURL=provider.d.ts.map

package/dist/contexts/webSocketContext/provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/contexts/webSocketContext/provider.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAA+C,sBAAsB,EAAmB,MAAM,SAAS,CAAC;AAEpH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,iBAAiB,GAAI,cAAc,sBAAsB,gCA+ErE,CAAC"}

package/dist/contexts/webSocketContext/provider.js

@@ -0,0 +1,121 @@
+import { useAppAlert } from "../appAlertContext/useAppAlert.js";
+import { useAxios } from "../../hooks/useAxios.js";
+import { WebSocketContext } from "./index.js";
+import { getWebsocketsConfig } from "../../api/websocketsConfig.js";
+import { WebSocketHandler } from "./handler.js";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/contexts/webSocketContext/provider.tsx
+/**
+* WebSocketProvider
+*
+* React context provider that exposes a receive-only pub/sub API backed by Socket.IO.
+*
+* What this provider does:
+* - Fetches `/api/websockets_config` once on mount to get the connection URL, channel id,
+*   and session uid. Socket.IO handles reconnection internally — the config is not re-fetched.
+* - Opens a `WebSocketHandler` instance that connects and joins the per-user channel.
+* - Exposes `subscribe`, `lastMessage`, and `status` via `WebSocketContext`.
+*
+* Why the pending buffer exists (`pendingRef`):
+* - The handler is created asynchronously (after the config fetch resolves).
+* - Consumers that call `subscribe` before the handler is ready have their callbacks buffered
+*   and registered once the handler initializes, ensuring no early subscriptions are lost.
+*
+* Subscribe buffering behavior:
+* - If `subscribe(fn)` is called before the handler exists, `fn` is stored with a `null` placeholder.
+* - Once the handler is ready, all pending callbacks are registered and their unsubscribe functions
+*   stored back into the map.
+* - The returned cleanup always works: it calls the real unsubscribe if available, or removes
+*   the entry from the pending map.
+*
+* Usage:
+* ```tsx
+* <WebSocketProvider>
+*   <YourPage />
+* </WebSocketProvider>
+* ```
+*
+* Context value (WebSocketContextType):
+* @returns {object}
+*  - `subscribe(fn)`: register a listener; returns an unsubscribe function.
+*  - `lastMessage`: the most recently received notification (or null).
+*  - `status`: current connection status ("connecting" | "connected" | "error").
+*/
+var WebSocketProvider = ({ children }) => {
+	const { api } = useAxios();
+	const { showAlert } = useAppAlert();
+	const apiRef = useRef(api);
+	const showAlertRef = useRef(showAlert);
+	useEffect(() => {
+		apiRef.current = api;
+	});
+	useEffect(() => {
+		showAlertRef.current = showAlert;
+	});
+	const handlerRef = useRef(null);
+	const unsubscribeProviderRef = useRef(null);
+	const [lastMessage, setLastMessage] = useState(null);
+	const [status, setStatus] = useState("idle");
+	const pendingRef = useRef(/* @__PURE__ */ new Map());
+	useEffect(() => {
+		let cancelled = false;
+		const pending = pendingRef.current;
+		getWebsocketsConfig(apiRef.current).then((config) => {
+			if (cancelled) return;
+			setStatus("connecting");
+			const handler = new WebSocketHandler({
+				...config,
+				onStatusChange: (s) => setStatus(s)
+			});
+			handlerRef.current = handler;
+			unsubscribeProviderRef.current = handler.listen((message) => setLastMessage(message));
+			for (const [fn, unsub] of pending.entries()) if (!unsub) {
+				const realUnsub = handler.listen(fn);
+				pending.set(fn, realUnsub);
+			}
+		}).catch((error) => {
+			if (cancelled) return;
+			console.error("Failed to initialize WebSocket connection:", error);
+			setStatus("error");
+			showAlertRef.current({
+				message: "Real-time notifications are unavailable. Please refresh the page.",
+				severity: "error"
+			});
+		});
+		return () => {
+			cancelled = true;
+			unsubscribeProviderRef.current?.();
+			unsubscribeProviderRef.current = null;
+			handlerRef.current?.close();
+			handlerRef.current = null;
+			pending.clear();
+		};
+	}, []);
+	const subscribe = useCallback((fn) => {
+		if (handlerRef.current) return handlerRef.current.listen(fn);
+		pendingRef.current.set(fn, null);
+		return () => {
+			const maybeUnsub = pendingRef.current.get(fn);
+			if (maybeUnsub) maybeUnsub();
+			pendingRef.current.delete(fn);
+		};
+	}, []);
+	const value = useMemo(() => ({
+		subscribe,
+		lastMessage,
+		status
+	}), [
+		subscribe,
+		lastMessage,
+		status
+	]);
+	return /* @__PURE__ */ jsx(WebSocketContext.Provider, {
+		value,
+		children
+	});
+};
+//#endregion
+export { WebSocketProvider };
+
+//# sourceMappingURL=provider.js.map

package/dist/contexts/webSocketContext/provider.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider.js","names":[],"sources":["../../../src/contexts/webSocketContext/provider.tsx"],"sourcesContent":["import { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\n\nimport { getWebsocketsConfig } from \"@/api/websocketsConfig\";\nimport { useAxios } from \"@/hooks/useAxios\";\nimport { useAppAlert } from \"@/contexts/appAlertContext/useAppAlert\";\nimport { WebSocketContext } from \".\";\nimport { WebSocketHandler } from \"./handler\";\nimport type { WebSocketContextType, WebSocketNotification, WebSocketProviderProps, WebSocketStatus } from \"./types\";\n\n/**\n * WebSocketProvider\n *\n * React context provider that exposes a receive-only pub/sub API backed by Socket.IO.\n *\n * What this provider does:\n * - Fetches `/api/websockets_config` once on mount to get the connection URL, channel id,\n *   and session uid. Socket.IO handles reconnection internally — the config is not re-fetched.\n * - Opens a `WebSocketHandler` instance that connects and joins the per-user channel.\n * - Exposes `subscribe`, `lastMessage`, and `status` via `WebSocketContext`.\n *\n * Why the pending buffer exists (`pendingRef`):\n * - The handler is created asynchronously (after the config fetch resolves).\n * - Consumers that call `subscribe` before the handler is ready have their callbacks buffered\n *   and registered once the handler initializes, ensuring no early subscriptions are lost.\n *\n * Subscribe buffering behavior:\n * - If `subscribe(fn)` is called before the handler exists, `fn` is stored with a `null` placeholder.\n * - Once the handler is ready, all pending callbacks are registered and their unsubscribe functions\n *   stored back into the map.\n * - The returned cleanup always works: it calls the real unsubscribe if available, or removes\n *   the entry from the pending map.\n *\n * Usage:\n * ```tsx\n * <WebSocketProvider>\n *   <YourPage />\n * </WebSocketProvider>\n * ```\n *\n * Context value (WebSocketContextType):\n * @returns {object}\n *  - `subscribe(fn)`: register a listener; returns an unsubscribe function.\n *  - `lastMessage`: the most recently received notification (or null).\n *  - `status`: current connection status (\"connecting\" | \"connected\" | \"error\").\n */\nexport const WebSocketProvider = ({ children }: WebSocketProviderProps) => {\n    const { api } = useAxios();\n    const { showAlert } = useAppAlert();\n\n    // Refs keep the latest values accessible inside the mount-only effect without\n    // making it re-run when api or showAlert change.\n    const apiRef = useRef(api);\n    const showAlertRef = useRef(showAlert);\n    useEffect(() => { apiRef.current = api; });\n    useEffect(() => { showAlertRef.current = showAlert; });\n\n    const handlerRef = useRef<WebSocketHandler | null>(null);\n    const unsubscribeProviderRef = useRef<(() => void) | null>(null);\n    const [lastMessage, setLastMessage] = useState<WebSocketNotification | null>(null);\n    const [status, setStatus] = useState<WebSocketStatus>(\"idle\");\n\n    const pendingRef = useRef(new Map<(m: WebSocketNotification) => void, (() => void) | null>());\n\n    useEffect(() => {\n        let cancelled = false;\n        const pending = pendingRef.current;\n\n        getWebsocketsConfig(apiRef.current)\n            .then((config) => {\n                if (cancelled) return;\n\n                setStatus(\"connecting\");\n                const handler = new WebSocketHandler({\n                    ...config,\n                    onStatusChange: (s) => setStatus(s),\n                });\n                handlerRef.current = handler;\n\n                unsubscribeProviderRef.current = handler.listen((message) => setLastMessage(message));\n\n                for (const [fn, unsub] of pending.entries()) {\n                    if (!unsub) {\n                        const realUnsub = handler.listen(fn);\n                        pending.set(fn, realUnsub);\n                    }\n                }\n            })\n            .catch((error) => {\n                if (cancelled) return;\n                console.error(\"Failed to initialize WebSocket connection:\", error);\n                setStatus(\"error\");\n                showAlertRef.current({ message: \"Real-time notifications are unavailable. Please refresh the page.\", severity: \"error\" });\n            });\n\n        return () => {\n            cancelled = true;\n            unsubscribeProviderRef.current?.();\n            unsubscribeProviderRef.current = null;\n            handlerRef.current?.close();\n            handlerRef.current = null;\n            pending.clear();\n        };\n    }, []); // mount-only — Socket.IO handles reconnection; no re-init needed when api changes\n\n    const subscribe = useCallback((fn: (m: WebSocketNotification) => void) => {\n        if (handlerRef.current) {\n            return handlerRef.current.listen(fn);\n        }\n\n        pendingRef.current.set(fn, null);\n\n        return () => {\n            const maybeUnsub = pendingRef.current.get(fn);\n            if (maybeUnsub) maybeUnsub();\n            pendingRef.current.delete(fn);\n        };\n    }, []);\n\n    const value: WebSocketContextType = useMemo(\n        () => ({ subscribe, lastMessage, status }),\n        [subscribe, lastMessage, status]\n    );\n\n    return <WebSocketContext.Provider value={value}>{children}</WebSocketContext.Provider>;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,qBAAqB,EAAE,eAAuC;CACvE,MAAM,EAAE,QAAQ,SAAS;CACzB,MAAM,EAAE,cAAc,YAAY;CAIlC,MAAM,SAAS,OAAO,GAAG;CACzB,MAAM,eAAe,OAAO,SAAS;CACrC,gBAAgB;EAAE,OAAO,UAAU;CAAK,CAAC;CACzC,gBAAgB;EAAE,aAAa,UAAU;CAAW,CAAC;CAErD,MAAM,aAAa,OAAgC,IAAI;CACvD,MAAM,yBAAyB,OAA4B,IAAI;CAC/D,MAAM,CAAC,aAAa,kBAAkB,SAAuC,IAAI;CACjF,MAAM,CAAC,QAAQ,aAAa,SAA0B,MAAM;CAE5D,MAAM,aAAa,uBAAO,IAAI,IAA6D,CAAC;CAE5F,gBAAgB;EACZ,IAAI,YAAY;EAChB,MAAM,UAAU,WAAW;EAE3B,oBAAoB,OAAO,OAAO,CAAC,CAC9B,MAAM,WAAW;GACd,IAAI,WAAW;GAEf,UAAU,YAAY;GACtB,MAAM,UAAU,IAAI,iBAAiB;IACjC,GAAG;IACH,iBAAiB,MAAM,UAAU,CAAC;GACtC,CAAC;GACD,WAAW,UAAU;GAErB,uBAAuB,UAAU,QAAQ,QAAQ,YAAY,eAAe,OAAO,CAAC;GAEpF,KAAK,MAAM,CAAC,IAAI,UAAU,QAAQ,QAAQ,GACtC,IAAI,CAAC,OAAO;IACR,MAAM,YAAY,QAAQ,OAAO,EAAE;IACnC,QAAQ,IAAI,IAAI,SAAS;GAC7B;EAER,CAAC,CAAC,CACD,OAAO,UAAU;GACd,IAAI,WAAW;GACf,QAAQ,MAAM,8CAA8C,KAAK;GACjE,UAAU,OAAO;GACjB,aAAa,QAAQ;IAAE,SAAS;IAAqE,UAAU;GAAQ,CAAC;EAC5H,CAAC;EAEL,aAAa;GACT,YAAY;GACZ,uBAAuB,UAAU;GACjC,uBAAuB,UAAU;GACjC,WAAW,SAAS,MAAM;GAC1B,WAAW,UAAU;GACrB,QAAQ,MAAM;EAClB;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,YAAY,aAAa,OAA2C;EACtE,IAAI,WAAW,SACX,OAAO,WAAW,QAAQ,OAAO,EAAE;EAGvC,WAAW,QAAQ,IAAI,IAAI,IAAI;EAE/B,aAAa;GACT,MAAM,aAAa,WAAW,QAAQ,IAAI,EAAE;GAC5C,IAAI,YAAY,WAAW;GAC3B,WAAW,QAAQ,OAAO,EAAE;EAChC;CACJ,GAAG,CAAC,CAAC;CAEL,MAAM,QAA8B,eACzB;EAAE;EAAW;EAAa;CAAO,IACxC;EAAC;EAAW;EAAa;CAAM,CACnC;CAEA,OAAO,oBAAC,iBAAiB,UAAlB;EAAkC;EAAQ;CAAoC,CAAA;AACzF"}

package/dist/contexts/webSocketContext/types.d.ts

@@ -0,0 +1,41 @@
+import type { ReactNode } from "react";
+export type WebsocketsConfig = {
+    appConnectionURL: string;
+    appChannelID: string;
+    everyskUID: string;
+};
+export type WebSocketStatus = "idle" | "connecting" | "connected" | "error";
+export type AppNotificationPayload = {
+    [key: string]: unknown;
+};
+/**
+ * WebSocketNotification
+ *
+ * Base type for all Socket.IO notifications.
+ * `event_type` discriminates between notification kinds (e.g. "USER_APP_NOTIFICATION",
+ * "WORKFLOW_EXECUTION_COMPLETED"). Other fields vary per event_type.
+ */
+export type WebSocketNotification = {
+    event_type: string;
+    [key: string]: unknown;
+};
+/**
+ * AppNotification
+ *
+ * Narrowed type for event_type === "USER_APP_NOTIFICATION".
+ * Has a nested `payload` with app-level metadata.
+ */
+export type AppNotification = WebSocketNotification & {
+    event_type: "USER_APP_NOTIFICATION";
+    user_app_id: string;
+    payload: AppNotificationPayload;
+};
+export type WebSocketContextType = {
+    subscribe: (listener: (msg: WebSocketNotification) => void) => () => void;
+    lastMessage: WebSocketNotification | null;
+    status: WebSocketStatus;
+};
+export type WebSocketProviderProps = {
+    children?: ReactNode;
+};
+//# sourceMappingURL=types.d.ts.map