@lowdefy/build 5.6.0 → 6.0.0

package/dist/build/buildModules.js

@@ -13,22 +13,43 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
-import { serializer, type } from '@lowdefy/helpers';
+import { type } from '@lowdefy/helpers';
+function checkSecretNodes({ value, declaredSecrets, entryId }) {
+    if (type.isArray(value)) {
+        for (const item of value){
+            checkSecretNodes({
+                value: item,
+                declaredSecrets,
+                entryId
+            });
+        }
+        return;
+    }
+    if (!type.isObject(value)) return;
+    // Only a single-non-tilde-key object is operator shape (matches
+    // getRuntimeOperatorKey) — { _secret: 'X', extra: 1 } is deliberately not
+    // treated as a secret reference.
+    const keys = Object.keys(value).filter((k)=>!k.startsWith('~'));
+    if (keys.length === 1 && !type.isUndefined(value['_secret'])) {
+        const secretName = value['_secret'];
+        if (type.isString(secretName) && !declaredSecrets.has(secretName)) {
+            throw new ConfigError(`Module "${entryId}" references secret "${secretName}" ` + `but does not declare it in module.lowdefy.yaml secrets. ` + `Add it to the module's secrets list or remove the reference.`);
+        }
+    }
+    for (const key of Object.keys(value)){
+        checkSecretNodes({
+            value: value[key],
+            declaredSecrets,
+            entryId
+        });
+    }
+}
 function validateModuleSecrets({ content, manifest, entryId }) {
     const declaredSecrets = new Set((manifest.secrets ?? []).map((s)=>s.name));
-    serializer.copy(content, {
-        reviver: (_, value)=>{
-            if (!type.isObject(value)) return value;
-            const keys = Object.keys(value).filter((k)=>!k.startsWith('~'));
-            if (keys.length !== 1) return value;
-            if (!type.isUndefined(value['_secret'])) {
-                const secretName = value['_secret'];
-                if (type.isString(secretName) && !declaredSecrets.has(secretName)) {
-                    throw new ConfigError(`Module "${entryId}" references secret "${secretName}" ` + `but does not declare it in module.lowdefy.yaml secrets. ` + `Add it to the module's secrets list or remove the reference.`);
-                }
-            }
-            return value;
-        }
+    checkSecretNodes({
+        value: content,
+        declaredSecrets,
+        entryId
     });
 }
 function buildModules({ components, context }) {
@@ -71,6 +92,20 @@ function buildModules({ components, context }) {
                 entryId: entry.id
             });
         }
+        for (const agent of manifest.agents ?? []){
+            validateModuleSecrets({
+                content: agent,
+                manifest,
+                entryId: entry.id
+            });
+        }
+        for (const notification of manifest.notifications ?? []){
+            validateModuleSecrets({
+                content: notification,
+                manifest,
+                entryId: entry.id
+            });
+        }
         // Process pages
         for (const page of manifest.pages ?? []){
             page.id = `${entry.id}/${page.id}`;
@@ -90,6 +125,18 @@ function buildModules({ components, context }) {
             components.api = components.api ?? [];
             components.api.push(endpoint);
         }
+        // Process agents
+        for (const agent of manifest.agents ?? []){
+            agent.id = `${entry.id}/${agent.id}`;
+            components.agents = components.agents ?? [];
+            components.agents.push(agent);
+        }
+        // Process notifications
+        for (const notification of manifest.notifications ?? []){
+            notification.id = `${entry.id}/${notification.id}`;
+            components.notifications = components.notifications ?? [];
+            components.notifications.push(notification);
+        }
     }
     return components;
 }

package/dist/build/buildNotifications.js

@@ -0,0 +1,98 @@
+/* eslint-disable no-param-reassign */ /*
+  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';
+import { ConfigError } from '@lowdefy/errors';
+import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
+import validateId from '../utils/validateId.js';
+function buildNotifications({ components, context }) {
+    if (components.notifications && !type.isArray(components.notifications)) {
+        throw new ConfigError('Notifications is not an array.', {
+            received: components.notifications
+        });
+    }
+    const notifications = type.isArray(components.notifications) ? components.notifications : [];
+    context.notificationIds = new Set();
+    const checkDuplicateNotificationId = createCheckDuplicateId({
+        message: 'Duplicate notificationId "{{ id }}".'
+    });
+    notifications.forEach((notification, index)=>{
+        const configKey = notification['~k'];
+        if (type.isUndefined(notification.id)) {
+            throw new ConfigError(`Notification id missing at notification ${index}.`, {
+                configKey
+            });
+        }
+        if (!type.isString(notification.id)) {
+            throw new ConfigError(`Notification id is not a string at notification ${index}.`, {
+                received: notification.id,
+                configKey
+            });
+        }
+        validateId({
+            id: notification.id,
+            field: 'Notification id',
+            configKey
+        });
+        checkDuplicateNotificationId({
+            id: notification.id,
+            configKey
+        });
+        if (!type.isString(notification.type)) {
+            throw new ConfigError(`Notification type is not a string at notification "${notification.id}".`, {
+                received: notification.type,
+                configKey
+            });
+        }
+        // Track type usage for buildTypes validation
+        context.typeCounters.notifications.increment(notification.type, configKey);
+        if (type.isNone(notification.properties)) {
+            notification.properties = {};
+        }
+        if (!type.isObject(notification.properties)) {
+            throw new ConfigError(`Notification properties is not an object at notification "${notification.id}".`, {
+                received: notification.properties,
+                configKey
+            });
+        }
+        // subject is a framework contract, independent of the template type's own schema —
+        // the render step reads it for the mail header and the returned result.
+        if (!type.isString(notification.properties.subject) || notification.properties.subject === '') {
+            throw new ConfigError(`Notification "${notification.id}" requires "properties.subject" to be a non-empty string.`, {
+                received: notification.properties.subject,
+                configKey
+            });
+        }
+        if (!type.isNone(notification.theme) && !type.isObject(notification.theme)) {
+            throw new ConfigError(`Notification theme is not an object at notification "${notification.id}".`, {
+                received: notification.theme,
+                configKey
+            });
+        }
+        if (!type.isNone(notification.testData) && !type.isObject(notification.testData)) {
+            throw new ConfigError(`Notification testData is not an object at notification "${notification.id}".`, {
+                received: notification.testData,
+                configKey
+            });
+        }
+        // Rename id to internal format
+        notification.notificationId = notification.id;
+        context.notificationIds.add(notification.notificationId);
+        notification.id = `notification:${notification.notificationId}`;
+    // No countOperators here — notification properties are nunjucks data templates,
+    // not operator config; there is no runtime operator evaluation inside them.
+    });
+    return components;
+}
+export default buildNotifications;

package/dist/build/buildPages/buildBlock/buildBlock.js

@@ -12,7 +12,8 @@
   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 buildEvents from './buildEvents.js';
+*/ import buildDynamicBlock from './buildDynamicBlock.js';
+import buildEvents from './buildEvents.js';
 import buildRequests from './buildRequests.js';
 import buildSubBlocks from './buildSubBlocks.js';
 import countBlockOperators from './countBlockOperators.js';
@@ -28,6 +29,7 @@ import validateSlots from './validateSlots.js';
 function buildBlock(block, pageContext, parentConfigKey) {
     validateBlock(block, pageContext, parentConfigKey);
     setBlockId(block, pageContext);
+    buildDynamicBlock(block, pageContext);
     normalizeLayout(block, pageContext);
     moveAreasToSlots(block, pageContext);
     countBlockOperators(block, pageContext);

package/dist/build/buildPages/buildBlock/buildDynamicBlock.js

@@ -0,0 +1,131 @@
+/*
+  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';
+import { ConfigError } from '@lowdefy/errors';
+import countOperators from '../../../utils/countOperators.js';
+const TYPES_CATEGORIES = new Set([
+    'blocks',
+    'actions',
+    'operators'
+]);
+function countDeclaredTypes(block, { pageId, typeCounters }) {
+    const configKey = block['~k'];
+    const types = block.properties.types;
+    if (!type.isObject(types)) {
+        throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.types should be an object.`, {
+            received: types,
+            configKey
+        });
+    }
+    Object.keys(types).forEach((category)=>{
+        if (category.startsWith('~')) return;
+        if (!TYPES_CATEGORIES.has(category)) {
+            throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.types has unknown category "${category}". Valid categories: blocks, actions, operators.`, {
+                configKey
+            });
+        }
+        if (!type.isArray(types[category])) {
+            throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.types.${category} should be an array.`, {
+                received: types[category],
+                configKey
+            });
+        }
+        types[category].forEach((typeName)=>{
+            if (!type.isString(typeName)) {
+                throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.types.${category} should only contain strings.`, {
+                    received: typeName,
+                    configKey
+                });
+            }
+            if (category === 'blocks') {
+                typeCounters.blocks.increment(typeName, configKey);
+            }
+            if (category === 'actions') {
+                typeCounters.actions.increment(typeName, configKey);
+            }
+            if (category === 'operators') {
+                // Normalize method form (_number.round) to the base operator (_number),
+                // matching how countOperators counts operator usage.
+                const operator = typeName.split('.')[0];
+                if (operator.length < 2 || operator[0] !== '_') {
+                    throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.types.operators contains "${typeName}" which is not an operator name. Operator names start with "_".`, {
+                        configKey
+                    });
+                }
+                typeCounters.operators.client.increment(operator, configKey);
+            }
+        });
+    });
+}
+function buildDynamicBlock(block, pageContext) {
+    if (block.type !== 'Dynamic') {
+        return;
+    }
+    const { pageId } = pageContext;
+    const configKey = block['~k'];
+    if (!type.isObject(block.properties)) {
+        throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties should be an object.`, {
+            received: block.properties,
+            configKey
+        });
+    }
+    if (type.isUndefined(block.properties.endpointId)) {
+        throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" requires properties.endpointId.`, {
+            configKey
+        });
+    }
+    if (!type.isString(block.properties.endpointId)) {
+        throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.endpointId is not a string.`, {
+            received: block.properties.endpointId,
+            configKey
+        });
+    }
+    if (!type.isNone(block.properties.params)) {
+        if (!type.isObject(block.properties.params)) {
+            throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.params should be an object.`, {
+                received: block.properties.params,
+                configKey
+            });
+        }
+        // The page artifact is static — params are passed to the endpoint verbatim,
+        // so operators here would never evaluate. Runtime values belong in the
+        // endpoint routine (_payload, _user, _secret).
+        countOperators(block.properties.params, {
+            counter: {
+                increment: (operator)=>{
+                    throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.params must not contain operators. Found "${operator}". Params are static — read runtime values in the endpoint routine with _payload, _user or _secret.`, {
+                        configKey
+                    });
+                }
+            }
+        });
+    }
+    if (!type.isNone(block.properties.required) && !type.isBoolean(block.properties.required)) {
+        throw new ConfigError(`Dynamic block "${block.blockId}" on page "${pageId}" properties.required is not a boolean.`, {
+            received: block.properties.required,
+            configKey
+        });
+    }
+    if (!type.isNone(block.properties.types)) {
+        countDeclaredTypes(block, pageContext);
+    }
+    pageContext.hasDynamicBlocks = true;
+    pageContext.dynamicBlockRefs.push({
+        endpointId: block.properties.endpointId,
+        block,
+        sourcePageId: pageId
+    });
+}
+export default buildDynamicBlock;

package/dist/build/buildPages/buildBlock/buildEvents.js

@@ -23,7 +23,43 @@ const BROWSER_DEFAULT_SHORTCUTS = new Set([
     'mod+q',
     'mod+l'
 ]);
-function checkAction(action, { blockId, callApiActionRefs, checkDuplicateActionId, eventId, linkActionRefs, pageId, requestActionRefs, typeCounters }) {
+const CONTROL_KEYS = [
+    ':if',
+    ':switch',
+    ':return'
+];
+const ACTION_KEYS_NOT_ALLOWED_ON_CONTROLS = [
+    'id',
+    'skip',
+    'messages'
+];
+const CONTROL_ALLOWED_KEYS = {
+    ':if': [
+        ':if',
+        ':then',
+        ':else'
+    ],
+    ':return': [
+        ':return'
+    ],
+    ':switch': [
+        ':switch',
+        ':default'
+    ]
+};
+const CASE_ALLOWED_KEYS = [
+    ':case',
+    ':then'
+];
+// '~'-prefixed keys are build meta markers (~k, ~r, ~l, ~ignoreBuildChecks) and
+// never user config - tolerate them by prefix, as the rest of the build does.
+function isMetaKey(key) {
+    return key.startsWith('~');
+}
+function isControl(item) {
+    return type.isObject(item) && CONTROL_KEYS.some((key)=>key in item);
+}
+function checkAction(action, { blockId, callApiActionRefs, checkDuplicateActionId, eventId, linkActionRefs, pageId, requestActionRefs, typeCounters, websocketActionRefs }) {
     const configKey = action['~k'];
     if (type.isUndefined(action.id)) {
         throw new ConfigError(`Action id missing on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
@@ -108,6 +144,142 @@ function checkAction(action, { blockId, callApiActionRefs, checkDuplicateActionI
             });
         }
     }
+    // Collect static Subscribe/Unsubscribe/Publish action references for validation
+    if ([
+        'Subscribe',
+        'Unsubscribe'
+    ].includes(action.type) && type.isString(action.params)) {
+        (websocketActionRefs ?? []).push({
+            websocketId: action.params,
+            action,
+            actionType: action.type,
+            blockId,
+            eventId,
+            sourcePageId: pageId
+        });
+    }
+    if (action.type === 'Publish' && type.isObject(action.params) && type.isString(action.params.websocketId)) {
+        (websocketActionRefs ?? []).push({
+            websocketId: action.params.websocketId,
+            action,
+            actionType: action.type,
+            blockId,
+            eventId,
+            sourcePageId: pageId
+        });
+    }
+}
+function checkBranchList({ list, listName, configKey }, ctx) {
+    const { blockId, eventId, pageId } = ctx;
+    if (!type.isArray(list)) {
+        throw new ConfigError(`Control "${listName}" must be an array on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+            received: list,
+            configKey
+        });
+    }
+    checkActionList(list, ctx);
+}
+function checkControl(control, ctx) {
+    const { blockId, eventId, pageId } = ctx;
+    const configKey = control['~k'];
+    const controlKeys = CONTROL_KEYS.filter((key)=>key in control);
+    if (controlKeys.length > 1) {
+        const keyList = controlKeys.map((key)=>`"${key}"`).join(', ');
+        throw new ConfigError(`Control has more than one control key (${keyList}) on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+            received: controlKeys,
+            configKey
+        });
+    }
+    const [controlKey] = controlKeys;
+    const invalidKeys = Object.keys(control).filter((key)=>!CONTROL_ALLOWED_KEYS[controlKey].includes(key) && !isMetaKey(key));
+    if (invalidKeys.length > 0) {
+        // Action keys do nothing on a control - call out the likely mistake directly.
+        if (ACTION_KEYS_NOT_ALLOWED_ON_CONTROLS.includes(invalidKeys[0])) {
+            throw new ConfigError(`Control "${controlKey}" can not have action property "${invalidKeys[0]}" on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                received: invalidKeys,
+                configKey
+            });
+        }
+        throw new ConfigError(`Control "${controlKey}" has invalid key "${invalidKeys[0]}" on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+            received: invalidKeys,
+            configKey
+        });
+    }
+    if (controlKey === ':if') {
+        if (type.isNone(control[':then'])) {
+            throw new ConfigError(`Control ":if" requires a ":then" list on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                configKey
+            });
+        }
+        checkBranchList({
+            list: control[':then'],
+            listName: ':then',
+            configKey
+        }, ctx);
+        if (!type.isNone(control[':else'])) {
+            checkBranchList({
+                list: control[':else'],
+                listName: ':else',
+                configKey
+            }, ctx);
+        }
+    }
+    if (controlKey === ':switch') {
+        if (!type.isArray(control[':switch'])) {
+            throw new ConfigError(`Control ":switch" must be an array of case objects on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                received: control[':switch'],
+                configKey
+            });
+        }
+        control[':switch'].forEach((caseObject)=>{
+            if (!type.isObject(caseObject)) {
+                throw new ConfigError(`Control ":switch" case must be an object on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                    received: caseObject,
+                    configKey
+                });
+            }
+            const caseConfigKey = caseObject['~k'] ?? configKey;
+            if (!(':case' in caseObject)) {
+                throw new ConfigError(`Control ":switch" case requires a ":case" condition on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                    configKey: caseConfigKey
+                });
+            }
+            if (type.isNone(caseObject[':then'])) {
+                throw new ConfigError(`Control ":case" requires a ":then" list on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                    configKey: caseConfigKey
+                });
+            }
+            const invalidCaseKeys = Object.keys(caseObject).filter((key)=>!CASE_ALLOWED_KEYS.includes(key) && !isMetaKey(key));
+            if (invalidCaseKeys.length > 0) {
+                throw new ConfigError(`Control ":switch" case has invalid key "${invalidCaseKeys[0]}" on event "${eventId}" on block "${blockId}" on page "${pageId}".`, {
+                    received: invalidCaseKeys,
+                    configKey: caseConfigKey
+                });
+            }
+            checkBranchList({
+                list: caseObject[':then'],
+                listName: ':then',
+                configKey: caseConfigKey
+            }, ctx);
+        });
+        if (!type.isNone(control[':default'])) {
+            checkBranchList({
+                list: control[':default'],
+                listName: ':default',
+                configKey
+            }, ctx);
+        }
+    }
+// ':return' takes a value, not a list - nothing more to validate.
+}
+function checkActionList(list, ctx) {
+    list.forEach((item)=>{
+        if (isControl(item)) {
+            checkControl(item, ctx);
+        } else {
+            checkAction(item, ctx);
+        }
+    });
 }
 function buildEvents(block, pageContext) {
     if (block.events) {
@@ -143,26 +315,19 @@ function buildEvents(block, pageContext) {
             const checkDuplicateActionId = createCheckDuplicateId({
                 message: 'Duplicate actionId "{{ id }}" on event "{{ eventId }}" on block "{{ blockId }}" on page "{{ pageId }}".'
             });
-            block.events[key].try.map((action)=>checkAction(action, {
-                    eventId: key,
-                    blockId: block.blockId,
-                    callApiActionRefs: pageContext.callApiActionRefs,
-                    typeCounters: pageContext.typeCounters,
-                    pageId: pageContext.pageId,
-                    linkActionRefs: pageContext.linkActionRefs,
-                    requestActionRefs: pageContext.requestActionRefs,
-                    checkDuplicateActionId
-                }));
-            block.events[key].catch.map((action)=>checkAction(action, {
-                    eventId: key,
-                    blockId: block.blockId,
-                    callApiActionRefs: pageContext.callApiActionRefs,
-                    typeCounters: pageContext.typeCounters,
-                    pageId: pageContext.pageId,
-                    linkActionRefs: pageContext.linkActionRefs,
-                    requestActionRefs: pageContext.requestActionRefs,
-                    checkDuplicateActionId
-                }));
+            const actionContext = {
+                eventId: key,
+                blockId: block.blockId,
+                callApiActionRefs: pageContext.callApiActionRefs,
+                typeCounters: pageContext.typeCounters,
+                pageId: pageContext.pageId,
+                linkActionRefs: pageContext.linkActionRefs,
+                requestActionRefs: pageContext.requestActionRefs,
+                websocketActionRefs: pageContext.websocketActionRefs,
+                checkDuplicateActionId
+            };
+            checkActionList(block.events[key].try, actionContext);
+            checkActionList(block.events[key].catch, actionContext);
             // Validate shortcut strings and collect refs for duplicate detection
             if (type.isObject(block.events[key]) && !type.isNone(block.events[key].shortcut)) {
                 const shortcuts = type.isArray(block.events[key].shortcut) ? block.events[key].shortcut : [

package/dist/build/buildPages/buildBlock/buildRequests.js

@@ -75,6 +75,15 @@ function buildRequest(request, pageContext) {
     pageContext.requests.push(request);
 }
 function buildRequests(block, pageContext) {
+    // Runtime-resolved dynamic content cannot define requests — request
+    // artifacts are written at build time, so a runtime request would have no
+    // server-side properties to execute.
+    if (pageContext.forbidRequests === true && !type.isNone(block.requests)) {
+        throw new ConfigError(`Dynamic content must not define requests — found "requests" on block "${block.blockId}" on page "${pageContext.pageId}". Reference requests defined statically on the page instead.`, {
+            received: block.requests,
+            configKey: block['~k']
+        });
+    }
     (block.requests || []).forEach((request)=>{
         buildRequest(request, pageContext);
     });

package/dist/build/buildPages/buildBlock/normalizeClassAndStyles.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 { type } from '@lowdefy/helpers';
+*/ import { getOperatorType, type } from '@lowdefy/helpers';
 import { ConfigError } from '@lowdefy/errors';
 const breakpointKeys = new Set([
     'xs',
@@ -22,17 +22,8 @@ const breakpointKeys = new Set([
     'xl',
     '2xl'
 ]);
-// Keys that look like operators (single key starting with _) but are not.
-const KNOWN_NON_OPERATORS = new Set([
-    '_id'
-]);
 function isOperator(value) {
-    const nonTildeKeys = Object.keys(value).filter((k)=>!k.startsWith('~'));
-    if (nonTildeKeys.length !== 1) return false;
-    const key = nonTildeKeys[0];
-    const [op] = key.split('.');
-    const operator = op.replace(/^(_+)/gm, '_');
-    return operator.length > 1 && operator[0] === '_' && !KNOWN_NON_OPERATORS.has(operator);
+    return getOperatorType(value) !== null;
 }
 function stripDotPrefix(key) {
     return key.startsWith('.') ? key.slice(1) : key;

package/dist/build/buildPages/buildBlock/setBlockId.js

@@ -13,14 +13,17 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
-function setBlockId(block, { pageId, blockIdCounter }) {
+function setBlockId(block, { pageId, blockIdCounter, blockIdPrefix }) {
     block.blockId = block.id;
     if (block.blockId === pageId && blockIdCounter.getCount(block.blockId) > 0) {
         throw new ConfigError(`Block id "${block.blockId}" on page "${pageId}" collides with the page id. A block cannot have the same id as its page.`, {
             configKey: block['~k']
         });
     }
-    block.id = `block:${pageId}:${block.blockId}:${blockIdCounter.getCount(block.blockId)}`;
+    // blockIdPrefix namespaces runtime-built dynamic content ids under the
+    // resolving Dynamic block's id so they can never collide with static ids.
+    const prefix = blockIdPrefix ?? `block:${pageId}`;
+    block.id = `${prefix}:${block.blockId}:${blockIdCounter.getCount(block.blockId)}`;
     blockIdCounter.increment(block.blockId);
 }
 export default setBlockId;

package/dist/build/buildPages/buildBlock/validateBlock.js

@@ -63,5 +63,12 @@ function validateBlock(block, { pageId }, parentConfigKey) {
             });
         }
     }
+    // Page subscriptions are extracted before block building — any subscriptions
+    // key reaching here is defined on a nested block, where it has no effect.
+    if (!type.isNone(block.subscriptions)) {
+        throw new ConfigError(`Subscriptions are only allowed on the page, not on block "${block.id}" on page "${pageId}".`, {
+            configKey
+        });
+    }
 }
 export default validateBlock;