@lowdefy/client 5.6.0 → 6.0.0

package/dist/Client.js

@@ -24,7 +24,29 @@ const Client = ({ auth, Components, config: rawConfig, jsMap, lowdefy, resetCont
     reset: false,
     setReset: ()=>undefined
 }, router, stage, types, window })=>{
-    const config = serializer.deserialize(rawConfig);
+    // Memoize on the fetched config objects, not the per-render wrapper — the
+    // engine memoizes dynamic page contexts by config object identity, so the
+    // deserialized config must be stable across re-renders and only change when
+    // a new page fetch delivers new config.
+    const config = React.useMemo(()=>serializer.deserialize(rawConfig), [
+        rawConfig.pageConfig,
+        rawConfig.rootConfig
+    ]);
+    // Dynamic pages rebuild their engine context per fetch — remount the page
+    // tree with the rebuilt context instead of reconciling mounted blocks
+    // against it, which React can silently drop. Static pages keep their
+    // context and tree across navigations, so their key stays stable.
+    const buildRef = React.useRef({
+        config: null,
+        build: 0
+    });
+    if (buildRef.current.config !== config) {
+        buildRef.current = {
+            config,
+            build: buildRef.current.build + 1
+        };
+    }
+    const contextKey = config.pageConfig.dynamic === true ? `${config.pageConfig.id}:${buildRef.current.build}` : config.pageConfig.id;
     initLowdefyContext({
         auth,
         Components,
@@ -51,7 +73,7 @@ const Client = ({ auth, Components, config: rawConfig, jsMap, lowdefy, resetCont
             }
         }
     }), /*#__PURE__*/ React.createElement(Context, {
-        key: config.pageConfig.id,
+        key: contextKey,
         config: config.pageConfig,
         jsMap: jsMap,
         lowdefy: lowdefy,

package/dist/Context.js

@@ -26,6 +26,15 @@ const ShortcutEffect = ({ context })=>{
     ]);
     return null;
 };
+const WebSocketsEffect = ({ context })=>{
+    useEffect(()=>{
+        context._internal.WebSockets.subscribeAll();
+        return ()=>context._internal.WebSockets.unsubscribeAll();
+    }, [
+        context
+    ]);
+    return null;
+};
 const Context = ({ children, config, jsMap, lowdefy, resetContext })=>{
     const context = getContext({
         config,
@@ -53,6 +62,8 @@ const Context = ({ children, config, jsMap, lowdefy, resetContext })=>{
         if (loadingOnInit) return '';
         return /*#__PURE__*/ React.createElement(React.Fragment, null, /*#__PURE__*/ React.createElement(ShortcutEffect, {
             context: context
+        }), /*#__PURE__*/ React.createElement(WebSocketsEffect, {
+            context: context
         }), children(context));
     });
 };

package/dist/adapters/Head.js

@@ -0,0 +1,32 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React, { useEffect } from 'react';
+// Replaces next/head for the single use in @lowdefy/client's Head.js:
+// <Component><title>{properties.title}</title></Component>.
+// Extracts the title text and sets document.title; renders nothing.
+function Head({ children }) {
+    useEffect(()=>{
+        React.Children.forEach(children, (child)=>{
+            if (child?.type === 'title') {
+                const text = React.Children.toArray(child.props.children).join('');
+                if (text) {
+                    document.title = text;
+                }
+            }
+        });
+    });
+    return null;
+}
+export default Head;

package/dist/adapters/Link.js

@@ -0,0 +1,63 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
+import { type } from '@lowdefy/helpers';
+import { createUrl } from './url.js';
+// Replaces next/link for the contract used by @lowdefy/client's
+// createLinkComponent: href as { pathname, query } or string, replace,
+// scroll, onClick fired before navigation. Modified clicks (new tab,
+// middle click, download) fall through to native browser handling.
+function createLinkComponent({ router }) {
+    function Link({ children, href, onClick, replace, scroll, ...props }) {
+        const hrefObject = type.isString(href) ? {
+            pathname: href
+        } : href ?? {};
+        const { pathname, query } = hrefObject;
+        const url = createUrl({
+            basePath: router.basePath,
+            pathname,
+            query
+        });
+        function handleClick(event) {
+            if (onClick) {
+                onClick(event);
+            }
+            if (event.defaultPrevented || event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey || props.target === '_blank') {
+                return;
+            }
+            event.preventDefault();
+            if (replace) {
+                router.replace({
+                    pathname,
+                    query,
+                    scroll
+                });
+            } else {
+                router.push({
+                    pathname,
+                    query,
+                    scroll
+                });
+            }
+        }
+        return /*#__PURE__*/ React.createElement("a", {
+            ...props,
+            href: url,
+            onClick: handleClick
+        }, children);
+    }
+    return Link;
+}
+export default createLinkComponent;

package/dist/adapters/createRouter.js

@@ -0,0 +1,115 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { createUrl, parsePageId } from './url.js';
+// History-API router backing the @lowdefy/client router contract:
+// push({ pathname, query }), back(), basePath — plus subscribe() for the
+// page component and sessionStorage-backed scroll restoration.
+function createRouter({ basePath = '', window }) {
+    const listeners = new Set();
+    let entryKey = window.history.state?.lowdefyKey ?? `k${Date.now().toString(36)}`;
+    if ('scrollRestoration' in window.history) {
+        window.history.scrollRestoration = 'manual';
+    }
+    if (!window.history.state?.lowdefyKey) {
+        window.history.replaceState({
+            lowdefyKey: entryKey
+        }, '', window.location.href);
+    }
+    function readScrollPositions() {
+        try {
+            return JSON.parse(window.sessionStorage.getItem('lowdefy_scroll') ?? '{}');
+        } catch (e) {
+            return {};
+        }
+    }
+    function saveScrollPosition() {
+        try {
+            const positions = readScrollPositions();
+            positions[entryKey] = {
+                x: window.scrollX,
+                y: window.scrollY
+            };
+            window.sessionStorage.setItem('lowdefy_scroll', JSON.stringify(positions));
+        } catch (e) {
+        // sessionStorage unavailable (private mode) — scroll restoration degrades gracefully.
+        }
+    }
+    function restoreScrollPosition() {
+        const position = readScrollPositions()[entryKey];
+        window.requestAnimationFrame(()=>{
+            window.scrollTo(position?.x ?? 0, position?.y ?? 0);
+        });
+    }
+    function getLocation() {
+        return {
+            pageId: parsePageId(window.location.href, basePath),
+            pathname: window.location.pathname,
+            search: window.location.search
+        };
+    }
+    function notify() {
+        const location = getLocation();
+        listeners.forEach((listener)=>listener(location));
+    }
+    function navigate({ forceReload, pathname, query, replace = false, scroll = true }) {
+        const url = createUrl({
+            basePath,
+            pathname,
+            query
+        });
+        if (forceReload) {
+            window.location.assign(url);
+            return;
+        }
+        saveScrollPosition();
+        entryKey = `k${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+        if (replace) {
+            window.history.replaceState({
+                lowdefyKey: entryKey
+            }, '', url);
+        } else {
+            window.history.pushState({
+                lowdefyKey: entryKey
+            }, '', url);
+        }
+        notify();
+        if (scroll) {
+            window.requestAnimationFrame(()=>{
+                window.scrollTo(0, 0);
+            });
+        }
+    }
+    window.addEventListener('popstate', (event)=>{
+        saveScrollPosition();
+        entryKey = event.state?.lowdefyKey ?? `k${Date.now().toString(36)}`;
+        notify();
+        restoreScrollPosition();
+    });
+    return {
+        basePath,
+        back: ()=>window.history.back(),
+        getLocation,
+        push: async (args)=>navigate(args),
+        replace: async (args)=>navigate({
+                ...args,
+                replace: true
+            }),
+        subscribe: (listener)=>{
+            listeners.add(listener);
+            return ()=>listeners.delete(listener);
+        }
+    };
+}
+export default createRouter;

package/dist/adapters/url.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+function serializeQuery(query) {
+    if (type.isNone(query) || query === '') {
+        return '';
+    }
+    if (type.isString(query)) {
+        return query;
+    }
+    return new URLSearchParams(query).toString();
+}
+function createUrl({ basePath = '', pathname, query }) {
+    const serializedQuery = serializeQuery(query);
+    return `${basePath}${pathname}${serializedQuery ? `?${serializedQuery}` : ''}`;
+}
+function parsePageId(url, basePath = '') {
+    const pathname = new URL(url, 'http://localhost').pathname;
+    const stripped = basePath && pathname.startsWith(basePath) ? pathname.slice(basePath.length) : pathname;
+    const pageId = stripped.replace(/^\//, '').replace(/\/$/, '');
+    return pageId === '' ? null : pageId;
+}
+export { createUrl, parsePageId, serializeQuery };

package/dist/block/Block.js

@@ -19,7 +19,7 @@ import MountEvents from '../MountEvents.js';
 const Block = ({ block, Blocks, context, lowdefy, parentLoading })=>{
     const [updates, setUpdate] = useState(0);
     const loggedErrorsRef = useRef(new Set());
-    lowdefy._internal.updaters[block.id] = ()=>setUpdate(updates + 1);
+    context._internal.updaters[block.id] = ()=>setUpdate(updates + 1);
     const handleError = (error)=>{
         if (lowdefy._internal.handleError) {
             lowdefy._internal.handleError(error);

package/dist/createLinkComponent.js

@@ -1,6 +1,21 @@
-import React from 'react';
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import React from 'react';
 import { createLink } from '@lowdefy/engine';
 import { type } from '@lowdefy/helpers';
+import { createUrl } from './adapters/url.js';
 const createLinkComponent = (lowdefy, Link)=>{
     const { window } = lowdefy._internal.globals;
     const backLink = ({ ariaLabel, children, className, id, onClick = ()=>{}, rel, style })=>/*#__PURE__*/ React.createElement("a", {
@@ -37,7 +52,11 @@ const createLinkComponent = (lowdefy, Link)=>{
                 "aria-label": ariaLabel,
                 className: className,
                 style: style,
-                href: `${window.location.origin}${lowdefy.basePath}${pathname}${query ? `?${query}` : ''}`,
+                href: `${window.location.origin}${createUrl({
+                    basePath: lowdefy.basePath,
+                    pathname,
+                    query
+                })}`,
                 rel: rel ?? 'noopener noreferrer',
                 target: "_blank",
                 onClick: async (...params)=>{

package/dist/initLowdefyContext.js

@@ -16,6 +16,7 @@
 import createCallAPI from './createCallAPI.js';
 import createAuthMethods from './auth/createAuthMethods.js';
 import createCallRequest from './createCallRequest.js';
+import createWebSocketClient from './websocket/createWebSocketClient.js';
 import createIcon from './createIcon.js';
 import createShortcutBadge from './createShortcutBadge.js';
 import createLinkComponent from './createLinkComponent.js';
@@ -50,8 +51,7 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
                 },
                 dispatch: ()=>undefined
             },
-            router,
-            updaters: {}
+            router
         };
         lowdefy.apiResponses = {};
         lowdefy.basePath = router.basePath;
@@ -63,6 +63,7 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
         lowdefy._internal.callAPI = createCallAPI(lowdefy);
         lowdefy._internal.auth = createAuthMethods(lowdefy, auth);
         lowdefy._internal.callRequest = createCallRequest(lowdefy);
+        lowdefy._internal.websocketClient = createWebSocketClient(lowdefy);
         lowdefy._internal.components.Link = createLinkComponent(lowdefy, Components.Link);
         lowdefy._internal.link = setupLink(lowdefy);
         lowdefy._internal.translate = (key, values)=>translate({
@@ -70,7 +71,6 @@ function initLowdefyContext({ auth, Components, config, lowdefy, router, stage,
                 values,
                 i18n: lowdefy.i18n
             });
-        lowdefy._internal.updateBlock = (blockId)=>lowdefy._internal.updaters[blockId] && lowdefy._internal.updaters[blockId]();
         lowdefy._internal.logger = createBrowserLogger();
         lowdefy._internal.handleError = createHandleError(lowdefy);
         lowdefy._internal.components.handleError = lowdefy._internal.handleError;

package/dist/setupLink.js

@@ -13,14 +13,23 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { createLink } from '@lowdefy/engine';
+import { createUrl } from './adapters/url.js';
 function setupLink(lowdefy) {
     const { router } = lowdefy._internal;
     const { window } = lowdefy._internal.globals;
     const backLink = ()=>router.back();
     const disabledLink = ()=>{};
-    const newOriginLink = ({ url, query, newTab })=>{
+    // `href` wins over `url`, and is used verbatim — the same precedence the anchor
+    // renderer applies (createLinkComponent.js). createLink only ever sets one of
+    // them, and it gives `url` a protocol before we see it while leaving `href`
+    // untouched, which is what makes `href` the way to link somewhere `url` cannot
+    // reach: a root-relative path, a fragment, a scheme-less same-origin target.
+    // urlQuery is not appended to an `href` for that reason — it is passed through
+    // as written, query string included.
+    const newOriginLink = ({ href, url, query, newTab })=>{
+        const target = href ?? `${url}${query ? `?${query}` : ''}`;
         if (newTab) {
-            const handle = window.open(`${url}${query ? `?${query}` : ''}`, '_blank');
+            const handle = window.open(target, '_blank');
             if (!handle) {
                 lowdefy._internal.displayMessage({
                     content: lowdefy._internal.translate('client.popupBlocked'),
@@ -31,18 +40,26 @@ function setupLink(lowdefy) {
             }
             return handle.focus();
         }
-        return window.location.assign(`${url}${query ? `?${query}` : ''}`);
+        return window.location.assign(target);
     };
-    const sameOriginLink = ({ newTab, pathname, query, setInput })=>{
+    // `replace` swaps the current history entry instead of pushing one and
+    // `scroll` (default true) controls the router's scroll-to-top - together they
+    // let a same-page Link reflect state into the url without moving the page.
+    const sameOriginLink = ({ newTab, pathname, query, replace, scroll, setInput })=>{
         if (newTab) {
-            return window.open(`${window.location.origin}${lowdefy.basePath}${pathname}${query ? `?${query}` : ''}`, '_blank').focus();
-        } else {
-            setInput();
-            return router.push({
+            return window.open(`${window.location.origin}${createUrl({
+                basePath: lowdefy.basePath,
                 pathname,
                 query
-            });
+            })}`, '_blank').focus();
         }
+        setInput();
+        const navigate = replace ? router.replace : router.push;
+        return navigate({
+            pathname,
+            query,
+            scroll
+        });
     };
     const noLink = ()=>{
         throw new Error(`Invalid Link.`);

package/dist/useDarkMode.js

@@ -121,7 +121,7 @@ function useDarkMode({ antd, configDarkMode }) {
         darkComponents
     ]);
     // Keep the <html> background and color-scheme in sync with the resolved mode.
-    // The _document.js pre-hydration inline script sets initial values before
+    // The server templates' pre-hydration inline script sets initial values before
     // hydration; this effect takes over once React is active and updates on every
     // dark/light toggle.
     const darkBg = darkToken?.colorBgLayout;

package/dist/websocket/createWebSocketClient.js

@@ -0,0 +1,273 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ const ACK_TIMEOUT_MS = 10 * 1000;
+const IDLE_CLOSE_GRACE_MS = 5 * 1000;
+const RECONNECT_BASE_MS = 500;
+const RECONNECT_CAP_MS = 15 * 1000;
+// One websocket per browser tab, shared by all channels, created lazily on
+// the first subscribe or publish. Connections are ephemeral in production
+// (serverless platforms close them at function max duration), so reconnect
+// with backoff and resubscribe is the steady state, not an edge case.
+function createWebSocketClient(lowdefy) {
+    const { window } = lowdefy._internal.globals;
+    // websocketId → { payload, handlers }
+    const subscriptions = new Map();
+    // websocketId → { resolve, reject, timer } for pending subscribe acks
+    const pendingSubscribes = new Map();
+    // requestId → { resolve, reject, timer } for pending publish acks
+    const pendingPublishes = new Map();
+    // Frames queued while the socket is (re)connecting.
+    const sendQueue = [];
+    let socket = null;
+    let openPromise = null;
+    let reconnectAttempt = 0;
+    let reconnectTimer = null;
+    let idleTimer = null;
+    let closedByClient = false;
+    let publishCounter = 0;
+    function url() {
+        const { location } = window;
+        const scheme = location.protocol === 'https:' ? 'wss' : 'ws';
+        return `${scheme}://${location.host}${lowdefy.basePath ?? ''}/api/websocket`;
+    }
+    function clearIdleTimer() {
+        if (idleTimer) {
+            clearTimeout(idleTimer);
+            idleTimer = null;
+        }
+    }
+    function scheduleIdleClose() {
+        clearIdleTimer();
+        if (subscriptions.size > 0) {
+            return;
+        }
+        // Grace period so rapid page navigation doesn't thrash connections.
+        idleTimer = setTimeout(()=>{
+            if (subscriptions.size === 0 && socket) {
+                closedByClient = true;
+                socket.close();
+                socket = null;
+                openPromise = null;
+            }
+        }, IDLE_CLOSE_GRACE_MS);
+    }
+    function send(frame) {
+        const message = JSON.stringify(frame);
+        if (socket && socket.readyState === window.WebSocket.OPEN) {
+            socket.send(message);
+            return;
+        }
+        sendQueue.push(message);
+        connect();
+    }
+    function flushQueue() {
+        while(sendQueue.length > 0 && socket && socket.readyState === window.WebSocket.OPEN){
+            socket.send(sendQueue.shift());
+        }
+    }
+    function resubscribeAll() {
+        subscriptions.forEach(({ payload }, websocketId)=>{
+            socket.send(JSON.stringify({
+                type: 'subscribe',
+                websocketId,
+                payload
+            }));
+        });
+    }
+    function handleFrame(frame) {
+        const { message, payload, requestId, websocketId } = frame;
+        const subscription = subscriptions.get(websocketId);
+        switch(frame.type){
+            case 'message':
+                subscription?.handlers.onMessage(payload);
+                return;
+            case 'subscribed':
+                {
+                    const pending = pendingSubscribes.get(websocketId);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        pendingSubscribes.delete(websocketId);
+                        pending.resolve();
+                    }
+                    subscription?.handlers.onConnected();
+                    return;
+                }
+            case 'unsubscribed':
+                return;
+            case 'published':
+                {
+                    const pending = pendingPublishes.get(requestId);
+                    if (pending) {
+                        clearTimeout(pending.timer);
+                        pendingPublishes.delete(requestId);
+                        pending.resolve();
+                    }
+                    return;
+                }
+            case 'error':
+                {
+                    const error = new Error(message ?? 'WebSocket error.');
+                    if (requestId && pendingPublishes.has(requestId)) {
+                        const pending = pendingPublishes.get(requestId);
+                        clearTimeout(pending.timer);
+                        pendingPublishes.delete(requestId);
+                        pending.reject(error);
+                        return;
+                    }
+                    if (websocketId && pendingSubscribes.has(websocketId)) {
+                        const pending = pendingSubscribes.get(websocketId);
+                        clearTimeout(pending.timer);
+                        pendingSubscribes.delete(websocketId);
+                        subscriptions.delete(websocketId);
+                        pending.reject(error);
+                        return;
+                    }
+                    if (subscription) {
+                        subscription.handlers.onError(error.message);
+                        return;
+                    }
+                    lowdefy._internal.logger.warn(error);
+                    return;
+                }
+            default:
+        }
+    }
+    function handleClose() {
+        socket = null;
+        openPromise = null;
+        subscriptions.forEach(({ handlers })=>{
+            handlers.onDisconnected();
+        });
+        if (closedByClient) {
+            closedByClient = false;
+            return;
+        }
+        if (subscriptions.size === 0 && sendQueue.length === 0) {
+            return;
+        }
+        // Capped exponential backoff with full jitter.
+        const base = Math.min(RECONNECT_BASE_MS * 2 ** reconnectAttempt, RECONNECT_CAP_MS);
+        const delay = Math.random() * base;
+        reconnectAttempt += 1;
+        reconnectTimer = setTimeout(()=>{
+            reconnectTimer = null;
+            connect();
+        }, delay);
+    }
+    function connect() {
+        if (openPromise) {
+            return openPromise;
+        }
+        clearIdleTimer();
+        openPromise = new Promise((resolve, reject)=>{
+            const ws = new window.WebSocket(url());
+            ws.onopen = ()=>{
+                socket = ws;
+                reconnectAttempt = 0;
+                resubscribeAll();
+                flushQueue();
+                resolve();
+            };
+            ws.onmessage = (event)=>{
+                let frame;
+                try {
+                    frame = JSON.parse(event.data);
+                } catch (e) {
+                    return;
+                }
+                handleFrame(frame);
+            };
+            ws.onclose = ()=>{
+                if (socket !== ws) {
+                    // Never opened — treat as a failed connect and retry.
+                    openPromise = null;
+                    reject(new Error('WebSocket connection failed.'));
+                }
+                handleClose();
+            };
+            ws.onerror = ()=>{
+            // onclose always follows onerror — reconnect is handled there.
+            };
+        });
+        // Connection errors surface through subscribe/publish ack timeouts.
+        openPromise.catch(()=>{});
+        return openPromise;
+    }
+    function subscribe({ handlers, payload, websocketId }) {
+        clearIdleTimer();
+        subscriptions.set(websocketId, {
+            handlers,
+            payload
+        });
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                pendingSubscribes.delete(websocketId);
+                subscriptions.delete(websocketId);
+                reject(new Error(`Subscribe to "${websocketId}" timed out.`));
+            }, ACK_TIMEOUT_MS);
+            pendingSubscribes.set(websocketId, {
+                resolve,
+                reject,
+                timer
+            });
+            send({
+                type: 'subscribe',
+                websocketId,
+                payload
+            });
+        });
+    }
+    function unsubscribe({ websocketId }) {
+        if (!subscriptions.has(websocketId)) {
+            return;
+        }
+        subscriptions.delete(websocketId);
+        if (socket && socket.readyState === window.WebSocket.OPEN) {
+            socket.send(JSON.stringify({
+                type: 'unsubscribe',
+                websocketId
+            }));
+        }
+        scheduleIdleClose();
+    }
+    function publish({ payload, websocketId }) {
+        publishCounter += 1;
+        const requestId = `p${publishCounter}`;
+        return new Promise((resolve, reject)=>{
+            const timer = setTimeout(()=>{
+                pendingPublishes.delete(requestId);
+                reject(new Error(`Publish to "${websocketId}" timed out.`));
+            }, ACK_TIMEOUT_MS);
+            pendingPublishes.set(requestId, {
+                resolve,
+                reject,
+                timer
+            });
+            send({
+                type: 'publish',
+                websocketId,
+                requestId,
+                payload
+            });
+        });
+    }
+    return {
+        connect,
+        publish,
+        subscribe,
+        unsubscribe
+    };
+}
+export default createWebSocketClient;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/client",
-  "version": "5.6.0",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "Lowdefy Client",
   "homepage": "https://lowdefy.com",
@@ -35,26 +35,26 @@
   "dependencies": {
     "@ant-design/icons": "6.1.0",
     "antd": "6.3.1",
-    "@lowdefy/block-utils": "5.6.0",
-    "@lowdefy/engine": "5.6.0",
-    "@lowdefy/errors": "5.6.0",
-    "@lowdefy/helpers": "5.6.0",
-    "@lowdefy/layout": "5.6.0",
-    "@lowdefy/logger": "5.6.0",
-    "dayjs": "1.11.19",
+    "@lowdefy/block-utils": "6.0.0",
+    "@lowdefy/engine": "6.0.0",
+    "@lowdefy/errors": "6.0.0",
+    "@lowdefy/helpers": "6.0.0",
+    "@lowdefy/layout": "6.0.0",
+    "@lowdefy/logger": "6.0.0",
+    "dayjs": "1.11.20",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "tinykeys": "^3.0.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/jest-yaml-transform": "5.6.0",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@lowdefy/jest-yaml-transform": "6.0.0",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "@testing-library/dom": "8.19.1",
     "@testing-library/react": "13.4.0",
-    "@testing-library/user-event": "14.4.3",
+    "@testing-library/user-event": "14.6.1",
     "copyfiles": "2.4.1",
     "jest": "28.1.3",
     "jest-environment-jsdom": "28.1.3",