@lowdefy/engine 5.5.1 → 6.0.0

package/dist/Actions.js

@@ -15,6 +15,15 @@
 */ import { ActionError, ConfigError, UserError } from '@lowdefy/errors';
 import { type } from '@lowdefy/helpers';
 import getActionMethods from './actions/getActionMethods.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;
@@ -52,10 +61,38 @@ 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, progress, responses }) {
+        for (const [position, action] of actions.entries()){
+            if (isControl(action)) {
+                const returned = await this.callControl({
+                    arrayIndices,
+                    block,
+                    control: action,
+                    controls,
+                    counters,
+                    event,
+                    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,
@@ -76,6 +113,18 @@ let Actions = class Actions {
                         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,26 +132,242 @@ let Actions = class Actions {
                 throw err;
             }
         }
+        return false;
+    }
+    async callControl({ arrayIndices, block, control, controls, counters, event, 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,
+                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,
+                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,
+                    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,
+                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,
+                    responses
+                });
+                if (condition) {
+                    matched = true;
+                    controls.push({
+                        index,
+                        type: ':switch',
+                        taken: casePosition
+                    });
+                    returned = await this.callActionLoop({
+                        actions: caseObject[':then'],
+                        arrayIndices,
+                        block,
+                        controls,
+                        counters,
+                        event,
+                        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,
+            progress,
+            responses
+        });
+    }
+    evaluateControlValue({ arrayIndices, block, event, input, node, responses }) {
+        const { output, errors: parserErrors } = this.context._internal.parser.parse({
+            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,
                 responses,
                 progress
             });
         } catch (error) {
             this.logActionError(error);
+            // 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,
                     responses,
                     progress
@@ -112,6 +377,9 @@ let Actions = class Actions {
                 return {
                     blockId: block.blockId,
                     bounced: false,
+                    ...controls && {
+                        controls
+                    },
                     endTimestamp: new Date(),
                     error,
                     errorCatch,
@@ -125,6 +393,9 @@ let Actions = class Actions {
             return {
                 blockId: block.blockId,
                 bounced: false,
+                ...controls && {
+                    controls
+                },
                 endTimestamp: new Date(),
                 error,
                 event,
@@ -137,6 +408,9 @@ let Actions = class Actions {
         return {
             blockId: block.blockId,
             bounced: false,
+            ...controls && {
+                controls
+            },
             endTimestamp: new Date(),
             event,
             eventName,
@@ -251,6 +525,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 +558,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

@@ -247,6 +247,9 @@ let Block = class Block {
             if (beforeVisible !== this.visibleEval.output) {
                 repeat.value = true;
             }
+            if (this.isList() && !this.isVisible()) {
+                this.captureHiddenValue();
+            }
             if (this.visibleEval.output !== false) {
                 this.propertiesEval = this.parse(this.properties);
                 this.requiredEval = this.parse(this.required);
@@ -347,8 +350,23 @@ let Block = class Block {
                 visibleEval: this.visibleEval
             });
         });
+        _define_property(this, "captureHiddenValue", ()=>{
+            const stateValue = get(this.context.state, this.blockId);
+            if (type.isUndefined(stateValue)) return;
+            this.hiddenValue = serializer.copy(stateValue);
+        });
+        _define_property(this, "restoreHiddenValue", ()=>{
+            if (type.isUndefined(this.hiddenValue)) return;
+            if (type.isUndefined(get(this.context.state, this.blockId))) {
+                this.context._internal.State.set(this.blockId, this.hiddenValue);
+            }
+            this.hiddenValue = undefined;
+        });
         _define_property(this, "updateState", (toSet)=>{
             if (!this.isVisible()) return;
+            if (this.isList()) {
+                this.restoreHiddenValue();
+            }
             if (this.isContainer() || this.isList()) {
                 if (this.subSlots && this.subSlots.length > 0) {
                     this.loopSubSlots((subSlotsClass)=>subSlotsClass.updateState());
@@ -424,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/State.js

@@ -12,7 +12,7 @@
   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 { unset, get, serializer, set, swap, type } from '@lowdefy/helpers';
+*/ import { unset, get, joinPath, serializer, set, splitPath, swap, type } from '@lowdefy/helpers';
 let State = class State {
     resetState() {
         Object.keys(this.context.state).forEach((key)=>{
@@ -35,9 +35,9 @@ let State = class State {
     del(field) {
         unset(this.context.state, field);
         // remove all empty objects from state as an effect of deleted values
-        const fields = field.split('.');
+        const fields = splitPath(field);
         if (fields.length > 1) {
-            const parent = fields.slice(0, fields.length - 1).join('.');
+            const parent = joinPath(fields.slice(0, -1));
             const parentValue = get(this.context.state, parent);
             if (type.isObject(parentValue) && Object.keys(parentValue).length === 0) {
                 this.del(parent);

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/actions/getFromObject.js

@@ -12,7 +12,7 @@
   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 { applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
+*/ import { ReservedKeyError, applyArrayIndices, get, serializer, type } from '@lowdefy/helpers';
 const getFromObject = ({ arrayIndices, location, method, object, params })=>{
     if (params === true) params = {
         all: true
@@ -23,20 +23,26 @@ const getFromObject = ({ arrayIndices, location, method, object, params })=>{
     if (!type.isObject(params)) {
         throw new Error(`Method Error: ${method} params must be of type string, integer, boolean or object at ${location}.`);
     }
-    if (params.key === null) return get(params, 'default', {
+    const defaultValue = get(params, 'default', {
         default: null,
         copy: true
     });
+    if (params.key === null) return defaultValue;
     if (params.all === true) return serializer.copy(object);
     if (!type.isString(params.key) && !type.isInt(params.key)) {
         throw new Error(`Method Error: ${method} params.key must be of type string or integer at ${location}.`);
     }
-    return get(object, applyArrayIndices(arrayIndices, params.key), {
-        default: get(params, 'default', {
-            default: null,
+    try {
+        return get(object, applyArrayIndices(arrayIndices, params.key), {
+            default: defaultValue,
             copy: true
-        }),
-        copy: true
-    });
+        });
+    } catch (error) {
+        // Tier 2: a runtime read of an app-developer keypath. There is no loud failure that helps here —
+        // a thrown error in the browser is worse than the default, and the reserved rule's job (refusing
+        // the read) is already done. Author-written identifiers fail loudly at build instead.
+        if (error instanceof ReservedKeyError) return defaultValue;
+        throw error;
+    }
 };
 export default getFromObject;

package/dist/createLink.js

@@ -12,60 +12,68 @@
   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, urlQuery as urlQueryFn } from '@lowdefy/helpers';
+*/ import { type } from '@lowdefy/helpers';
+import resolveTarget from './resolveTarget.js';
 function createLink({ backLink, disabledLink, lowdefy, newOriginLink, noLink, sameOriginLink }) {
     function link(props) {
         if (props.disabled === true) {
             return disabledLink(props);
         }
-        if ([
-            !props.pageId,
-            !props.back,
-            !props.home,
-            !props.href,
-            !props.url
-        ].filter((v)=>!v).length > 1) {
-            throw new Error(`Invalid Link: To avoid ambiguity, only one of 'back', 'home', 'href', 'pageId' or 'url' can be defined.`);
-        }
+        // back has no pathname to resolve and cannot carry input or urlQuery.
         if (props.back === true) {
-            // Cannot set input or urlQuery on back
             return backLink(props);
         }
-        const query = type.isNone(props.urlQuery) ? '' : `${urlQueryFn.stringify(props.urlQuery)}`;
-        if (props.home === true) {
-            const pathname = `/${lowdefy.home.configured ? '' : lowdefy.home.pageId}`;
-            return sameOriginLink({
-                ...props,
-                pathname,
-                query,
-                setInput: ()=>{
-                    lowdefy.inputs[`page:${lowdefy.home.pageId}`] = props.input ?? {};
-                }
-            });
-        }
-        if (type.isString(props.pageId)) {
-            return sameOriginLink({
-                ...props,
-                pathname: `/${props.pageId}`,
-                query,
-                setInput: ()=>{
-                    lowdefy.inputs[`page:${props.pageId}`] = props.input ?? {};
-                }
-            });
-        }
+        // href is an HTML-attribute passthrough the <Link> component reads, not a
+        // navigation target, so it never enters the grammar resolver.
         if (type.isString(props.href)) {
             return newOriginLink(props);
         }
-        if (type.isString(props.url)) {
-            const protocol = props.url.includes(':') ? '' : 'https://';
+        const target = resolveTarget({
+            lowdefy,
+            target: {
+                home: props.home,
+                pageId: props.pageId,
+                url: props.url,
+                urlQuery: props.urlQuery
+            }
+        });
+        if (type.isNone(target)) {
+            return noLink(props);
+        }
+        if (target.kind === 'external') {
+            // The resolver's href is the whole URL with any query already folded in,
+            // so it is passed as the url prop the callback reads with an empty query.
             return newOriginLink({
                 ...props,
-                url: `${protocol}${props.url}`,
-                query
+                url: target.href,
+                query: ''
             });
         }
-        return noLink(props);
+        return sameOriginLink({
+            ...props,
+            pathname: target.pathname,
+            query: target.query,
+            setInput: getSetInput({
+                lowdefy,
+                props
+            })
+        });
     }
     return link;
 }
+// A page-kind url names no page, so it seeds no input - writing
+// inputs['page:undefined'] is the bug family a no-op setInput avoids.
+function getSetInput({ lowdefy, props }) {
+    if (props.home === true) {
+        return ()=>{
+            lowdefy.inputs[`page:${lowdefy.home.pageId}`] = props.input ?? {};
+        };
+    }
+    if (type.isString(props.pageId)) {
+        return ()=>{
+            lowdefy.inputs[`page:${props.pageId}`] = props.input ?? {};
+        };
+    }
+    return ()=>{};
+}
 export default createLink;

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/getHomePathname.js

@@ -0,0 +1,34 @@
+/*
+  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';
+// The single reading of `lowdefy.home` for every 'home' target - the Link
+// grammar in createLink and the post-auth callbackUrl ladder in the client both
+// resolve through here. Returns undefined when the app names no home page:
+// getHomeAndMenus resolves pageId to null for an app with no homePageId whose
+// authorized menu yields no link, and each caller decides what no-home means
+// for it (an invalid link, no callback target) rather than interpolating the
+// missing value into a path.
+function getHomePathname({ lowdefy }) {
+    // A configured homePageId is served at the app root - the server resolves `/`
+    // to that page, so the pageId is deliberately not in the path.
+    if (lowdefy.home?.configured === true) {
+        return '/';
+    }
+    if (type.isString(lowdefy.home?.pageId)) {
+        return `/${lowdefy.home.pageId}`;
+    }
+    return undefined;
+}
+export default getHomePathname;

package/dist/index.js

@@ -17,7 +17,10 @@ import Slots from './Slots.js';
 import createLink from './createLink.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, Requests, State };
+import stopChain from './stopChain.js';
+export { Actions, Slots, createLink, Events, getHomePathname, Requests, resolveTarget, State, stopChain };
 export default getContext;

package/dist/resolveTarget.js

@@ -0,0 +1,139 @@
+/*
+  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, 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 }) {
+    // The leading-slash test runs before the colon-less test: `/2fa` is an
+    // app-relative page and colon-less, and the colon-less branch would wrongly
+    // give it an `https://` scheme and parse it as an off-app origin.
+    if (url.startsWith('/')) {
+        const questionMark = url.indexOf('?');
+        const pathname = questionMark === -1 ? url : url.slice(0, questionMark);
+        const ownQuery = questionMark === -1 ? '' : url.slice(questionMark + 1);
+        return {
+            kind: 'page',
+            pathname,
+            query: combineQuery(ownQuery, query)
+        };
+    }
+    // A colon-less value like `example.com` is a schemeless hostname, not a path -
+    // prepend `https://` so the URL parser reads it as an absolute URL rather than
+    // the app-relative path `/example.com`. Confined to here by the leading-slash
+    // test above, so a colon-bearing path like `/path:1` never reaches it.
+    const value = url.includes(':') ? url : `https://${url}`;
+    const origin = lowdefy._internal?.globals?.window?.location?.origin;
+    // No window (SSR, tests): a `url` that reaches origin classification cannot be
+    // placed, so it resolves to nothing rather than dereferencing a missing window.
+    if (type.isNone(origin)) {
+        return undefined;
+    }
+    const parsed = new URL(value, origin);
+    const basePath = lowdefy.basePath ?? '';
+    if (parsed.origin === origin) {
+        const insideBasePath = basePath === '' || parsed.pathname.startsWith(basePath);
+        if (insideBasePath) {
+            // Strip basePath so the router does not re-apply it: an absolute
+            // `https://myapp.com/app/reports` under basePath `/app` already carries the
+            // prefix, and without stripping router.push would push `/app/app/reports`.
+            const pathname = parsed.pathname.startsWith(basePath) ? parsed.pathname.slice(basePath.length) : parsed.pathname;
+            return {
+                kind: 'page',
+                pathname,
+                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 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
+    };
+}
+// The single resolver of the navigation grammar { home, pageId, url, urlQuery }
+// for every reader. Returns a discriminated, un-prefixed target - never a string,
+// never basePath-prefixed - so the page/external distinction is data the consumer
+// reads rather than a shape it guesses from a leading slash.
+function resolveTarget({ lowdefy, target, name = 'Link' }) {
+    if (!type.isObject(target)) {
+        return undefined;
+    }
+    const { home, pageId, url, urlQuery } = target;
+    const defined = [
+        home,
+        pageId,
+        url
+    ].filter((value)=>value);
+    if (defined.length > 1) {
+        throw new Error(`Invalid ${name}: To avoid ambiguity, only one of 'home', 'pageId' or 'url' can be defined.`);
+    }
+    const query = type.isNone(urlQuery) ? '' : `${urlQueryFn.stringify(urlQuery)}`;
+    if (home === true) {
+        const pathname = getHomePathname({
+            lowdefy
+        });
+        // An app whose home config names no page has no resolvable home - propagate
+        // getHomePathname's undefined rather than building the literal "/undefined".
+        if (type.isNone(pathname)) {
+            return undefined;
+        }
+        return {
+            kind: 'page',
+            pathname,
+            query
+        };
+    }
+    if (type.isString(pageId)) {
+        return {
+            kind: 'page',
+            pathname: `/${pageId}`,
+            query
+        };
+    }
+    if (type.isString(url)) {
+        return classifyUrl({
+            lowdefy,
+            url,
+            query
+        });
+    }
+    return undefined;
+}
+export default resolveTarget;

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.5.1",
+  "version": "6.0.0",
   "license": "Apache-2.0",
   "description": "",
   "homepage": "https://lowdefy.com",
@@ -30,18 +30,18 @@
     "dist/*"
   ],
   "dependencies": {
-    "@lowdefy/errors": "5.5.1",
-    "@lowdefy/helpers": "5.5.1",
-    "@lowdefy/operators": "5.5.1"
+    "@lowdefy/errors": "6.0.0",
+    "@lowdefy/helpers": "6.0.0",
+    "@lowdefy/operators": "6.0.0"
   },
   "devDependencies": {
     "@jest/globals": "28.1.3",
-    "@lowdefy/actions-core": "5.5.1",
-    "@lowdefy/build": "5.5.1",
-    "@lowdefy/operators-js": "5.5.1",
-    "@lowdefy/operators-mql": "5.5.1",
-    "@swc/cli": "0.8.0",
-    "@swc/core": "1.15.18",
+    "@lowdefy/actions-core": "6.0.0",
+    "@lowdefy/build": "6.0.0",
+    "@lowdefy/operators-js": "6.0.0",
+    "@lowdefy/operators-mql": "6.0.0",
+    "@swc/cli": "0.8.1",
+    "@swc/core": "1.15.32",
     "@swc/jest": "0.2.39",
     "jest": "28.1.3"
   },