@lowdefy/engine 5.6.0 → 6.1.0

package/dist/Actions.js

@@ -13,29 +13,40 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ActionError, ConfigError, UserError } from '@lowdefy/errors';
-import { type } from '@lowdefy/helpers';
+import { projectCaughtError, type } from '@lowdefy/helpers';
 import getActionMethods from './actions/getActionMethods.js';
+import { isDecodedServerError } from './decodeServerError.js';
+import { isStopChain } from './stopChain.js';
+const CONTROL_KEYS = [
+    ':if',
+    ':switch',
+    ':return'
+];
+function isControl(item) {
+    return type.isObject(item) && CONTROL_KEYS.some((key)=>key in item);
+}
 let Actions = class Actions {
     logActionError({ error, action }) {
         const handleError = this.context._internal.lowdefy._internal.handleError;
-        const actionId = action?.id || '';
-        // Deduplicate by error message + action id
-        const errorKey = `${error?.message || ''}:${actionId}`;
-        if (this.loggedActionErrors.has(errorKey)) {
-            return;
-        }
-        this.loggedActionErrors.add(errorKey);
-        // User-facing errors log to browser console only, never to terminal
+        // User-facing errors log to browser console only, never to terminal. This line
+        // bypasses handleError, so it dedups here.
         if (error instanceof UserError) {
+            const errorKey = `${error.message}:${action?.id || ''}`;
+            if (this.loggedActionErrors.has(errorKey)) {
+                return;
+            }
+            this.loggedActionErrors.add(errorKey);
             this.context._internal.lowdefy._internal.logger.error(error);
             return;
         }
-        // Lowdefy errors - use handleError (-> terminal)
+        // Not deduped here: every server failure carries the same generic message, so a
+        // message + action key would hide each later failure of the action. handleError
+        // dedups on the message it displays plus the server's requestId.
         if (handleError) {
             handleError(error);
         }
     }
-    async callAsyncAction({ action, arrayIndices, block, event, index, responses }) {
+    async callAsyncAction({ action, arrayIndices, block, event, index, parseScope, responses }) {
         try {
             const response = await this.callAction({
                 action,
@@ -43,6 +54,7 @@ let Actions = class Actions {
                 block,
                 event,
                 index,
+                parseScope,
                 responses
             });
             responses[action.id] = response;
@@ -52,16 +64,46 @@ let Actions = class Actions {
             this.logActionError(err);
         }
     }
-    async callActionLoop({ actions, arrayIndices, block, event, progress, responses }) {
-        for (const [index, action] of actions.entries()){
+    // Returns true when a ':return' control or an action ended the list, so callers can
+    // end the event.
+    async callActionLoop({ actions, arrayIndices, block, controls, counters, event, parseScope, progress, responses }) {
+        for (const [position, action] of actions.entries()){
+            if (isControl(action)) {
+                const returned = await this.callControl({
+                    arrayIndices,
+                    block,
+                    control: action,
+                    controls,
+                    counters,
+                    event,
+                    parseScope,
+                    progress,
+                    responses
+                });
+                if (returned === true) {
+                    this.recordSkippedActions({
+                        actions: actions.slice(position + 1),
+                        counters,
+                        responses
+                    });
+                    return true;
+                }
+                continue;
+            }
+            const index = counters.action;
+            counters.action += 1;
             try {
                 if (action.async === true) {
+                    // Fire and forget - the response is never awaited here, so an 'async: true'
+                    // action cannot end the chain even if it returns a stopChain marker. The
+                    // following steps have already run by the time it resolves.
                     this.callAsyncAction({
                         action,
                         arrayIndices,
                         block,
                         event,
                         index,
+                        parseScope,
                         progress,
                         responses
                     });
@@ -72,10 +114,23 @@ let Actions = class Actions {
                         block,
                         event,
                         index,
+                        parseScope,
                         progress,
                         responses
                     });
                     responses[action.id] = response;
+                    // An action that navigated the browser away ends the chain, reported as a
+                    // success. Same halt the ':return' control uses above - remaining steps are
+                    // recorded as skipped, and callActions is never entered through its catch,
+                    // so 'catch:' actions do not run and no error message displays.
+                    if (response.stoppedChain === true) {
+                        this.recordSkippedActions({
+                            actions: actions.slice(position + 1),
+                            counters,
+                            responses
+                        });
+                        return true;
+                    }
                 }
             } catch (err) {
                 // err is already {error, action, index} from callAction
@@ -83,27 +138,264 @@ let Actions = class Actions {
                 throw err;
             }
         }
+        return false;
+    }
+    async callControl({ arrayIndices, block, control, controls, counters, event, parseScope, progress, responses }) {
+        const index = counters.control;
+        counters.control += 1;
+        if (':return' in control) {
+            const value = this.evaluateControlValue({
+                arrayIndices,
+                block,
+                event,
+                input: control[':return'],
+                node: control,
+                parseScope,
+                responses
+            });
+            controls.push({
+                index,
+                type: ':return',
+                taken: value
+            });
+            return true;
+        }
+        if (':if' in control) {
+            const condition = this.evaluateControlValue({
+                arrayIndices,
+                block,
+                event,
+                input: control[':if'],
+                node: control,
+                parseScope,
+                responses
+            });
+            // JS truthiness, matching the routine ':if' - not skip's strict === true.
+            if (condition) {
+                controls.push({
+                    index,
+                    type: ':if',
+                    taken: 'then'
+                });
+                const returned = await this.callActionLoop({
+                    actions: control[':then'],
+                    arrayIndices,
+                    block,
+                    controls,
+                    counters,
+                    event,
+                    parseScope,
+                    progress,
+                    responses
+                });
+                this.recordSkippedActions({
+                    actions: control[':else'] ?? [],
+                    counters,
+                    responses
+                });
+                return returned;
+            }
+            controls.push({
+                index,
+                type: ':if',
+                taken: 'else'
+            });
+            this.recordSkippedActions({
+                actions: control[':then'],
+                counters,
+                responses
+            });
+            return this.callActionLoop({
+                actions: control[':else'] ?? [],
+                arrayIndices,
+                block,
+                controls,
+                counters,
+                event,
+                parseScope,
+                progress,
+                responses
+            });
+        }
+        // ':switch' - cases are evaluated in order and lazily: the first truthy ':case' wins,
+        // later cases are never evaluated, matching the routine ':switch'.
+        let matched = false;
+        let returned = false;
+        for (const [casePosition, caseObject] of control[':switch'].entries()){
+            if (!matched) {
+                const condition = this.evaluateControlValue({
+                    arrayIndices,
+                    block,
+                    event,
+                    input: caseObject[':case'],
+                    node: caseObject,
+                    parseScope,
+                    responses
+                });
+                if (condition) {
+                    matched = true;
+                    controls.push({
+                        index,
+                        type: ':switch',
+                        taken: casePosition
+                    });
+                    returned = await this.callActionLoop({
+                        actions: caseObject[':then'],
+                        arrayIndices,
+                        block,
+                        controls,
+                        counters,
+                        event,
+                        parseScope,
+                        progress,
+                        responses
+                    });
+                    continue;
+                }
+            }
+            this.recordSkippedActions({
+                actions: caseObject[':then'],
+                counters,
+                responses
+            });
+        }
+        if (matched) {
+            this.recordSkippedActions({
+                actions: control[':default'] ?? [],
+                counters,
+                responses
+            });
+            return returned;
+        }
+        controls.push({
+            index,
+            type: ':switch',
+            taken: 'default'
+        });
+        return this.callActionLoop({
+            actions: control[':default'] ?? [],
+            arrayIndices,
+            block,
+            controls,
+            counters,
+            event,
+            parseScope,
+            progress,
+            responses
+        });
+    }
+    evaluateControlValue({ arrayIndices, block, event, input, node, parseScope, responses }) {
+        const { output, errors: parserErrors } = this.context._internal.parser.parse({
+            ...parseScope,
+            actions: responses,
+            event,
+            arrayIndices,
+            input,
+            location: block.blockId
+        });
+        if (parserErrors.length > 0) {
+            const error = parserErrors[0];
+            // Report against the nearest node's '~k' when the operator carries none.
+            if (type.isNone(error.configKey)) {
+                error.configKey = node['~k'];
+            }
+            // Controls are anonymous - no responses entry, so only {error} is thrown.
+            throw {
+                error
+            };
+        }
+        return output;
+    }
+    // Records actions the chain does not execute for a control-flow reason as skipped,
+    // without parsing their operators. Controls record no responses entry, but still
+    // consume a control index so reached controls keep their depth-first numbering.
+    recordSkippedActions({ actions, counters, responses }) {
+        for (const action of actions){
+            if (isControl(action)) {
+                counters.control += 1;
+                if (':if' in action) {
+                    this.recordSkippedActions({
+                        actions: action[':then'],
+                        counters,
+                        responses
+                    });
+                    this.recordSkippedActions({
+                        actions: action[':else'] ?? [],
+                        counters,
+                        responses
+                    });
+                }
+                if (':switch' in action) {
+                    action[':switch'].forEach((caseObject)=>{
+                        this.recordSkippedActions({
+                            actions: caseObject[':then'],
+                            counters,
+                            responses
+                        });
+                    });
+                    this.recordSkippedActions({
+                        actions: action[':default'] ?? [],
+                        counters,
+                        responses
+                    });
+                }
+                continue;
+            }
+            responses[action.id] = {
+                type: action.type,
+                skipped: true,
+                index: counters.action
+            };
+            counters.action += 1;
+        }
     }
     async callActions({ actions, arrayIndices, block, catchActions, event, eventName, progress }) {
         const startTimestamp = new Date();
         const responses = {};
+        // Only events with controls gain a 'controls' array - flat chains keep their result shape.
+        const hasControls = actions.some(isControl) || catchActions.some(isControl);
+        const controls = hasControls ? [] : undefined;
+        const counters = {
+            action: 0,
+            control: 0
+        };
         try {
             await this.callActionLoop({
                 actions,
                 arrayIndices,
                 block,
+                controls,
+                counters,
                 event,
+                parseScope: {
+                    error: null
+                },
                 responses,
                 progress
             });
         } catch (error) {
             this.logActionError(error);
+            // A server error is already the wire shape, generic unless the author wrote
+            // it. A client-side error was built in the browser from data it already
+            // holds, so it keeps its real message - only its fields are narrowed.
+            const thrown = error.error;
+            const caught = isDecodedServerError(thrown) ? thrown : Object.assign(projectCaughtError(thrown), {
+                actionId: error.action?.id
+            });
+            // Catch actions restart action numbering, matching flat-chain history; the control
+            // counter continues so every control entry keeps a unique index within the event.
+            counters.action = 0;
             try {
                 await this.callActionLoop({
                     actions: catchActions,
                     arrayIndices,
                     block,
+                    controls,
+                    counters,
                     event,
+                    parseScope: {
+                        error: caught
+                    },
                     responses,
                     progress
                 });
@@ -112,6 +404,9 @@ let Actions = class Actions {
                 return {
                     blockId: block.blockId,
                     bounced: false,
+                    ...controls && {
+                        controls
+                    },
                     endTimestamp: new Date(),
                     error,
                     errorCatch,
@@ -125,6 +420,9 @@ let Actions = class Actions {
             return {
                 blockId: block.blockId,
                 bounced: false,
+                ...controls && {
+                    controls
+                },
                 endTimestamp: new Date(),
                 error,
                 event,
@@ -137,6 +435,9 @@ let Actions = class Actions {
         return {
             blockId: block.blockId,
             bounced: false,
+            ...controls && {
+                controls
+            },
             endTimestamp: new Date(),
             event,
             eventName,
@@ -145,7 +446,7 @@ let Actions = class Actions {
             success: true
         };
     }
-    async callAction({ action, arrayIndices, block, event, index, progress, responses }) {
+    async callAction({ action, arrayIndices, block, event, index, parseScope, progress, responses }) {
         if (!this.actions[action.type]) {
             const error = new ConfigError(`Invalid action type "${action.type}" at "${block.blockId}".`, {
                 configKey: action['~k']
@@ -157,6 +458,7 @@ let Actions = class Actions {
             };
         }
         const { output: parsedAction, errors: parserErrors } = this.context._internal.parser.parse({
+            ...parseScope,
             actions: responses,
             event,
             arrayIndices,
@@ -217,6 +519,7 @@ let Actions = class Actions {
                 type: action.type
             };
             const { output: parsedMessages, errors: parserErrors } = this.context._internal.parser.parse({
+                ...parseScope,
                 actions: responses,
                 event,
                 arrayIndices,
@@ -251,6 +554,17 @@ let Actions = class Actions {
             message: messages.success,
             status: 'success'
         });
+        // Unwrap here, after the success message: an action that ends the chain is a
+        // success like any other. Only the inner value reaches '_actions.<id>.response',
+        // so the marker never becomes app-visible state.
+        if (isStopChain(response)) {
+            return {
+                type: action.type,
+                response: response.response,
+                index,
+                stoppedChain: true
+            };
+        }
         return {
             type: action.type,
             response,
@@ -273,6 +587,7 @@ let Actions = class Actions {
         this.callAction = this.callAction.bind(this);
         this.callActionLoop = this.callActionLoop.bind(this);
         this.callActions = this.callActions.bind(this);
+        this.callControl = this.callControl.bind(this);
         this.displayMessage = this.displayMessage.bind(this);
         this.logActionError = this.logActionError.bind(this);
         this.actions = context._internal.lowdefy._internal.actions;

package/dist/Block.js

@@ -442,7 +442,10 @@ let Block = class Block {
                 value: type.isNone(this.value) ? null : this.value,
                 visible: this.visibleEval.output
             };
-            this.context._internal.lowdefy._internal.updateBlock(this.id);
+            // Updaters register per context — a context under construction has none,
+            // so construction-time evals never setState mounted components from a
+            // previous context.
+            this.context._internal.updaters[this.id]?.();
         });
         const { id, blockId, class: blockClass, events, layout, loading, properties, required, skeleton, style, validate, visible, type: blockType, slots } = blockConfig;
         this.context = context;

package/dist/WebSockets.js

@@ -0,0 +1,242 @@
+/*
+  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 { serializer, type } from '@lowdefy/helpers';
+import Events from './Events.js';
+const DEFAULT_MAX_MESSAGES = 100;
+const DEFAULT_THROTTLE_RENDER = 250;
+const MIN_THROTTLE_RENDER = 100;
+let WebSockets = class WebSockets {
+    client() {
+        return this.context._internal.lowdefy._internal.websocketClient;
+    }
+    initChannelState(websocketId) {
+        this.context.websockets[websocketId] = {
+            connected: false,
+            error: null,
+            lastMessage: null,
+            messageCount: 0,
+            messages: []
+        };
+    }
+    getEvents(websocketId, config) {
+        if (!this.subscriptionEvents[websocketId]) {
+            this.subscriptionEvents[websocketId] = new Events({
+                arrayIndices: [],
+                block: {
+                    blockId: `subscription:${websocketId}`,
+                    events: config.events ?? {}
+                },
+                context: this.context
+            });
+        }
+        return this.subscriptionEvents[websocketId];
+    }
+    flush({ websocketId, maxMessages }) {
+        const buffer = this.buffers[websocketId];
+        const channel = this.context.websockets[websocketId];
+        if (!buffer || buffer.length === 0 || !channel) {
+            return;
+        }
+        const batch = buffer.splice(0, buffer.length);
+        channel.messages.push(...batch);
+        if (channel.messages.length > maxMessages) {
+            channel.messages.splice(0, channel.messages.length - maxMessages);
+        }
+        channel.lastMessage = batch[batch.length - 1];
+        channel.messageCount += batch.length;
+        this.context._internal.update();
+        this.subscriptionEvents[websocketId]?.triggerEvent({
+            name: 'onMessage',
+            event: {
+                messages: batch
+            }
+        });
+    }
+    handleMessage({ websocketId, maxMessages, serializedPayload, throttleMs }) {
+        if (!this.active.has(websocketId)) {
+            return;
+        }
+        const data = serializer.deserialize(serializedPayload)?.data;
+        this.buffers[websocketId].push(data);
+        // Leading-edge throttle: the first message in a window renders
+        // immediately, the rest batch until the window closes.
+        if (!this.flushTimers[websocketId]) {
+            this.flush({
+                websocketId,
+                maxMessages
+            });
+            const arm = ()=>{
+                this.flushTimers[websocketId] = setTimeout(()=>{
+                    if ((this.buffers[websocketId] ?? []).length > 0) {
+                        this.flush({
+                            websocketId,
+                            maxMessages
+                        });
+                        arm();
+                        return;
+                    }
+                    this.flushTimers[websocketId] = null;
+                }, throttleMs);
+            };
+            arm();
+        }
+    }
+    async subscribe({ actions, arrayIndices, event, websocketId }) {
+        if (!type.isString(websocketId)) {
+            throw new Error('Subscribe requires a websocketId.');
+        }
+        if (this.active.has(websocketId)) {
+            return;
+        }
+        const config = this.subscriptionConfig[websocketId] ?? {
+            client: {},
+            events: {},
+            payload: {},
+            websocketId
+        };
+        if (!this.context.websockets[websocketId]) {
+            this.initChannelState(websocketId);
+        }
+        const { output: payload, errors: parserErrors } = this.context._internal.parser.parse({
+            actions,
+            arrayIndices,
+            event,
+            input: config.payload ?? {},
+            location: `subscription:${websocketId}`
+        });
+        if (parserErrors.length > 0) {
+            throw parserErrors[0];
+        }
+        const events = this.getEvents(websocketId, config);
+        const channel = this.context.websockets[websocketId];
+        const throttleMs = Math.max(config.client?.throttleRender ?? DEFAULT_THROTTLE_RENDER, MIN_THROTTLE_RENDER);
+        const maxMessages = config.client?.maxMessages ?? DEFAULT_MAX_MESSAGES;
+        this.active.add(websocketId);
+        this.buffers[websocketId] = [];
+        try {
+            await this.client().subscribe({
+                websocketId,
+                payload: serializer.serialize(payload),
+                handlers: {
+                    onConnected: ()=>{
+                        channel.connected = true;
+                        channel.error = null;
+                        this.context._internal.update();
+                        events.triggerEvent({
+                            name: 'onSubscribe',
+                            event: {}
+                        });
+                    },
+                    onDisconnected: ()=>{
+                        channel.connected = false;
+                        this.context._internal.update();
+                    },
+                    onError: (message)=>{
+                        channel.error = {
+                            message
+                        };
+                        this.context._internal.update();
+                        events.triggerEvent({
+                            name: 'onError',
+                            event: {
+                                message
+                            }
+                        });
+                    },
+                    onMessage: (serializedPayload)=>{
+                        this.handleMessage({
+                            websocketId,
+                            maxMessages,
+                            serializedPayload,
+                            throttleMs
+                        });
+                    }
+                }
+            });
+        } catch (error) {
+            this.active.delete(websocketId);
+            channel.error = {
+                message: error.message
+            };
+            this.context._internal.update();
+            throw error;
+        }
+    }
+    subscribeAll() {
+        Object.keys(this.subscriptionConfig).forEach((websocketId)=>{
+            this.subscribe({
+                websocketId
+            }).catch((error)=>{
+                this.context._internal.lowdefy._internal.handleError(error);
+            });
+        });
+    }
+    unsubscribe({ websocketId }) {
+        if (!type.isString(websocketId)) {
+            throw new Error('Unsubscribe requires a websocketId.');
+        }
+        if (!this.active.has(websocketId)) {
+            return;
+        }
+        this.active.delete(websocketId);
+        if (this.flushTimers[websocketId]) {
+            clearTimeout(this.flushTimers[websocketId]);
+            this.flushTimers[websocketId] = null;
+        }
+        this.buffers[websocketId] = [];
+        this.client().unsubscribe({
+            websocketId
+        });
+        this.initChannelState(websocketId);
+        this.context._internal.update();
+    }
+    unsubscribeAll() {
+        [
+            ...this.active
+        ].forEach((websocketId)=>{
+            this.unsubscribe({
+                websocketId
+            });
+        });
+    }
+    async publish({ payload, websocketId }) {
+        if (!type.isString(websocketId)) {
+            throw new Error('Publish requires a websocketId.');
+        }
+        await this.client().publish({
+            websocketId,
+            payload: serializer.serialize(payload ?? {})
+        });
+    }
+    constructor(context){
+        this.context = context;
+        this.subscriptionConfig = {};
+        this.subscriptionEvents = {};
+        this.buffers = {};
+        this.flushTimers = {};
+        this.active = new Set();
+        this.publish = this.publish.bind(this);
+        this.subscribe = this.subscribe.bind(this);
+        this.subscribeAll = this.subscribeAll.bind(this);
+        this.unsubscribe = this.unsubscribe.bind(this);
+        this.unsubscribeAll = this.unsubscribeAll.bind(this);
+        this.context.websockets = {};
+        (this.context._internal.rootBlock.subscriptions ?? []).forEach((subscription)=>{
+            this.subscriptionConfig[subscription.websocketId] = subscription;
+            this.initChannelState(subscription.websocketId);
+        });
+    }
+};
+export default WebSockets;

package/dist/actions/createPublish.js

@@ -0,0 +1,23 @@
+/*
+  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.
+*/ function createPublish({ context }) {
+    return function publish({ payload, websocketId }) {
+        return context._internal.WebSockets.publish({
+            payload,
+            websocketId
+        });
+    };
+}
+export default createPublish;

package/dist/actions/createSubscribe.js

@@ -0,0 +1,25 @@
+/*
+  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.
+*/ function createSubscribe({ actions, arrayIndices, context, event }) {
+    return function subscribe({ websocketId }) {
+        return context._internal.WebSockets.subscribe({
+            actions,
+            arrayIndices,
+            event,
+            websocketId
+        });
+    };
+}
+export default createSubscribe;

package/dist/actions/createUnsubscribe.js

@@ -0,0 +1,22 @@
+/*
+  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.
+*/ function createUnsubscribe({ context }) {
+    return function unsubscribe({ websocketId }) {
+        return context._internal.WebSockets.unsubscribe({
+            websocketId
+        });
+    };
+}
+export default createUnsubscribe;

package/dist/actions/getActionMethods.js

@@ -29,12 +29,15 @@ import createLink from './createLink.js';
 import createLogin from './createLogin.js';
 import createLogout from './createLogout.js';
 import createDisplayMessage from './createDisplayMessage.js';
+import createPublish from './createPublish.js';
 import createRequest from './createRequest.js';
 import createReset from './createReset.js';
 import createResetValidation from './createResetValidation.js';
 import createSetGlobal from './createSetGlobal.js';
 import createSetState from './createSetState.js';
+import createSubscribe from './createSubscribe.js';
 import createTranslate from './createTranslate.js';
+import createUnsubscribe from './createUnsubscribe.js';
 import createUpdateSession from './createUpdateSession.js';
 import createValidate from './createValidate.js';
 function getActionMethods(props) {
@@ -56,12 +59,15 @@ function getActionMethods(props) {
         link: createLink(props),
         login: createLogin(props),
         logout: createLogout(props),
+        publish: createPublish(props),
         request: createRequest(props),
         reset: createReset(props),
         resetValidation: createResetValidation(props),
         setGlobal: createSetGlobal(props),
         setState: createSetState(props),
+        subscribe: createSubscribe(props),
         translate: createTranslate(props),
+        unsubscribe: createUnsubscribe(props),
         updateSession: createUpdateSession(props),
         validate: createValidate(props)
     };

package/dist/callAPIHandler.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer } from '@lowdefy/helpers';
+import decodeServerError from './decodeServerError.js';
 async function callAPIHandler(context, { blockId, params }) {
     if (!context._internal.lowdefy.apiResponses[params.endpointId]) {
         context._internal.lowdefy.apiResponses[params.endpointId] = [];
@@ -55,7 +56,10 @@ async function callAPIHandler(context, { blockId, params }) {
         throw error;
     }
     const { error, response, status, success } = apiResponse;
-    api.error = serializer.deserialize(error);
+    // Decoded once so the stored and the thrown error are the same object: the
+    // dev error is keyed by that object.
+    const decodedError = decodeServerError(error);
+    api.error = decodedError;
     api.loading = false;
     api.response = serializer.deserialize(response);
     api.status = status;
@@ -64,7 +68,7 @@ async function callAPIHandler(context, { blockId, params }) {
     api.responseTime = api.endTimestamp - api.startTimestamp;
     context._internal.update();
     if (!success) {
-        throw serializer.deserialize(error);
+        throw decodedError;
     }
     return api;
 }

package/dist/decodeServerError.js

@@ -0,0 +1,43 @@
+/*
+  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 { serializer, type } from '@lowdefy/helpers';
+// The decoded error is stored as `request.error` / `api.error` and rethrown,
+// and config reads it through `_actions`, `_request_details` and `_error`. Any
+// property on it - enumerable or not - is one operator change away from config,
+// so the dev server's full error is kept beside it here, keyed by the error
+// itself, where only the dev tools look.
+const devErrors = new WeakMap();
+// A catch list's `_error` passes a server error through as decoded, but
+// projects a client-side error. The two can share a name and class, so the
+// engine tells them apart by identity.
+const decoded = new WeakSet();
+function decodeServerError(payload) {
+    if (type.isNone(payload)) return payload;
+    const { devError, ...rest } = payload;
+    const error = serializer.deserialize(rest);
+    if (!type.isNone(devError)) {
+        devErrors.set(error, serializer.deserialize(devError));
+    }
+    decoded.add(error);
+    return error;
+}
+function getDevError(error) {
+    return devErrors.get(error);
+}
+function isDecodedServerError(error) {
+    return decoded.has(error);
+}
+export { getDevError, isDecodedServerError };
+export default decodeServerError;

package/dist/getContext.js

@@ -17,8 +17,9 @@ import Actions from './Actions.js';
 import Slots from './Slots.js';
 import Requests from './Requests.js';
 import State from './State.js';
+import WebSockets from './WebSockets.js';
 const blockData = (config)=>{
-    const { slots, blockId, blocks, events, field, id, layout, pageId, properties, requests, required, style, type, validate, visible } = config;
+    const { slots, blockId, blocks, events, field, id, layout, pageId, properties, requests, required, style, subscriptions, type, validate, visible } = config;
     const result = {
         slots,
         blockId,
@@ -32,6 +33,7 @@ const blockData = (config)=>{
         requests,
         required,
         style,
+        subscriptions,
         type,
         validate,
         visible
@@ -55,12 +57,24 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
         throw new Error('A page must be provided to get context.');
     }
     const { id } = config;
-    if (lowdefy.contexts[id] && !resetContext.reset) {
+    // Dynamic pages are server-resolved per request — a context memoized across
+    // navigations would render the previous request's content. Rebuild when a
+    // new config object arrives (a fresh fetch), but stay memoized across
+    // re-renders of the same config: getContext runs in the render body, so
+    // rebuilding per render would loop.
+    const sameDynamicConfig = config.dynamic !== true || lowdefy.contexts[id]?._internal.pageConfig === config;
+    if (lowdefy.contexts[id] && !resetContext.reset && sameDynamicConfig) {
         // memoize context if already created, eg between page transitions, unless the reset flag is raised
         lowdefy.contexts[id]._internal.update();
         return lowdefy.contexts[id];
     }
-    resetContext.setReset(false); // lower context reset flag.
+    // Lower the context reset flag — only when raised: setReset is a React
+    // state setter on the Reload component, and getContext runs in the render
+    // body, so skip the redundant cross-component setState on rebuilds where
+    // the flag is already down.
+    if (resetContext.reset) {
+        resetContext.setReset(false);
+    }
     if (!lowdefy.inputs[id]) {
         lowdefy.inputs[id] = {};
     }
@@ -73,8 +87,16 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
         state: {},
         _internal: {
             lowdefy,
+            // Config object reference for dynamic page memoization — identity marks
+            // which fetch this context was built from.
+            pageConfig: config,
             rootBlock: blockData(config),
-            update: ()=>{}
+            update: ()=>{},
+            // React updaters register here per block id when the context's Block
+            // components mount — scoped per context so rebuilding over a live
+            // context (dynamic page navigation, reset) never notifies the previous
+            // context's still-mounted components.
+            updaters: {}
         }
     };
     const _internal = ctx._internal;
@@ -85,6 +107,7 @@ function getContext({ config, jsMap = {}, lowdefy, resetContext = {
     _internal.State = new State(ctx);
     _internal.Actions = new Actions(ctx);
     _internal.Requests = new Requests(ctx);
+    _internal.WebSockets = new WebSockets(ctx);
     _internal.RootSlots = new Slots({
         slots: {
             root: {

package/dist/index.js

@@ -15,11 +15,13 @@
 */ import Actions from './Actions.js';
 import Slots from './Slots.js';
 import createLink from './createLink.js';
+import decodeServerError, { getDevError } from './decodeServerError.js';
 import Events from './Events.js';
 import getContext from './getContext.js';
 import getHomePathname from './getHomePathname.js';
 import Requests from './Requests.js';
 import resolveTarget from './resolveTarget.js';
 import State from './State.js';
-export { Actions, Slots, createLink, Events, getHomePathname, Requests, resolveTarget, State };
+import stopChain from './stopChain.js';
+export { Actions, Slots, createLink, decodeServerError, Events, getDevError, getHomePathname, Requests, resolveTarget, State, stopChain };
 export default getContext;

package/dist/resolveTarget.js

@@ -14,6 +14,14 @@
   limitations under the License.
 */ import { type, urlQuery as urlQueryFn } from '@lowdefy/helpers';
 import getHomePathname from './getHomePathname.js';
+// The target's own urlQuery combines with any query the url string already
+// carries, matching the grammar semantics createLink resolved before.
+function combineQuery(ownQuery, query) {
+    return [
+        ownQuery,
+        query
+    ].filter((part)=>part !== '').join('&');
+}
 // Classifies a `url` grammar value into a page or external target. basePath is
 // stripped here, never applied - the single application boundary is createUrl.
 function classifyUrl({ lowdefy, url, query }) {
@@ -24,16 +32,10 @@ function classifyUrl({ lowdefy, url, query }) {
         const questionMark = url.indexOf('?');
         const pathname = questionMark === -1 ? url : url.slice(0, questionMark);
         const ownQuery = questionMark === -1 ? '' : url.slice(questionMark + 1);
-        // The target's own urlQuery combines with any query the string carries,
-        // matching the grammar semantics createLink resolves today.
-        const combined = [
-            ownQuery,
-            query
-        ].filter((part)=>part !== '').join('&');
         return {
             kind: 'page',
             pathname,
-            query: combined
+            query: combineQuery(ownQuery, query)
         };
     }
     // A colon-less value like `example.com` is a schemeless hostname, not a path -
@@ -59,19 +61,30 @@ function classifyUrl({ lowdefy, url, query }) {
             return {
                 kind: 'page',
                 pathname,
-                query: parsed.search.replace(/^\?/, '')
+                query: combineQuery(parsed.search.replace(/^\?/, ''), query)
             };
         }
         // Same origin but outside basePath (a marketing page at the origin root while
         // the app lives at `/app`) is a whole URL - routing it would 404 in `/app`.
-        return {
-            kind: 'external',
-            href: parsed.href
-        };
+        return externalTarget({
+            parsed,
+            query
+        });
     }
+    return externalTarget({
+        parsed,
+        query
+    });
+}
+// An external target is handed on as one finished href, so the target's own
+// urlQuery has to be folded in here - the consumer has no separate query to
+// append once the value is a whole URL.
+function externalTarget({ parsed, query }) {
+    const search = combineQuery(parsed.search.replace(/^\?/, ''), query);
+    const href = `${parsed.origin}${parsed.pathname}${search === '' ? '' : `?${search}`}${parsed.hash}`;
     return {
         kind: 'external',
-        href: parsed.href
+        href
     };
 }
 // The single resolver of the navigation grammar { home, pageId, url, urlQuery }

package/dist/stopChain.js

@@ -0,0 +1,41 @@
+/*
+  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';
+// A marker an action returns to end its event chain, reported as a success
+// rather than an error. The only callers are engine actions that have
+// navigated the browser away, where every remaining step in the chain would
+// act on a page that is being replaced - and one of those steps competing
+// with the navigation is the defect this exists to close.
+//
+// Not an app-facing control: ':return' is how app config ends a chain, and it
+// is unchanged. There is deliberately no CONTROL_KEYS entry here.
+//
+// A symbol, not a string key: the wrapper is only ever inspected by callAction
+// one frame later, and a symbol cannot collide with a field of an action's own
+// response the way a string marker could. It also cannot survive JSON
+// serialization, which is correct - this is an in-process control signal,
+// never something to persist or send over the wire.
+const STOP_CHAIN = Symbol('lowdefyStopChain');
+function stopChain(response) {
+    return {
+        [STOP_CHAIN]: true,
+        response
+    };
+}
+function isStopChain(value) {
+    return type.isObject(value) && value[STOP_CHAIN] === true;
+}
+export { STOP_CHAIN, isStopChain };
+export default stopChain;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lowdefy/engine",
-  "version": "5.6.0",
+  "version": "6.1.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,18 +30,18 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "5.6.0",
-    "@lowdefy/helpers": "5.6.0",
-    "@lowdefy/operators": "5.6.0"
+    "@lowdefy/errors": "6.1.0",
+    "@lowdefy/helpers": "6.1.0",
+    "@lowdefy/operators": "6.1.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "5.6.0",
-    "@lowdefy/build": "5.6.0",
-    "@lowdefy/operators-js": "5.6.0",
-    "@lowdefy/operators-mql": "5.6.0",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@lowdefy/actions-core": "6.1.0",
+    "@lowdefy/build": "6.1.0",
+    "@lowdefy/operators-js": "6.1.0",
+    "@lowdefy/operators-mql": "6.1.0",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "jest": "28.1.3"
   },