@lowdefy/build 5.6.0 → 6.1.0

package/dist/build/buildLogger.js

@@ -25,17 +25,33 @@ const sentryDefaults = {
         '_id'
     ]
 };
+// Runs after validateConfig, so config.environment and config.environments are resolved.
 function buildLogger({ components }) {
     if (type.isNone(components.logger)) {
         components.logger = {};
     }
-    // Only apply defaults if sentry is explicitly configured
-    if (!type.isNone(components.logger.sentry)) {
-        components.logger.sentry = {
-            ...sentryDefaults,
-            ...components.logger.sentry
-        };
+    const current = components.config.environment;
+    // Sentry is enabled by SENTRY_DSN, not by the config being present, so a current environment
+    // creates the Sentry config to carry its name. Without either, the runtime defaults apply.
+    if (type.isNone(components.logger.sentry) && type.isNone(current)) {
+        return components;
     }
+    const sentry = {
+        ...sentryDefaults,
+        ...components.logger.sentry ?? {}
+    };
+    if (!type.isNone(current)) {
+        // Sentry reports under the environment name unless the app names one itself, and is off on
+        // both sides when the environment switches it off.
+        if (type.isNone(sentry.environment)) {
+            sentry.environment = current;
+        }
+        if (components.config.environments?.[current]?.sentry?.enabled === false) {
+            sentry.client = false;
+            sentry.server = false;
+        }
+    }
+    components.logger.sentry = sentry;
     return components;
 }
 export default buildLogger;

package/dist/build/buildMcp.js

@@ -0,0 +1,73 @@
+/*
+  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.
+*/ /* eslint-disable no-param-reassign */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+// Validates the mcp block and writes its defaults. Endpoints are matched via
+// the same dual id/endpointId match buildApi uses. Referenced endpoints must
+// carry the metadata an MCP client needs: a description and a payloadSchema
+// (the tool inputSchema).
+function buildMcp({ components }) {
+    if (type.isNone(components.mcp)) {
+        components.mcp = {};
+    }
+    const mcp = components.mcp;
+    const configKey = mcp['~k'] ?? components['~k'];
+    // Agent tools were removed from mcp; schema validation only warns on
+    // unknown properties, so a leftover "agents" key would otherwise build
+    // silently instead of surfacing the removal.
+    if (!type.isNone(mcp.agents)) {
+        throw new ConfigError('MCP agent tools are not supported. Remove "mcp.agents" from your config.', {
+            configKey
+        });
+    }
+    mcp.name = mcp.name ?? 'lowdefy';
+    mcp.version = mcp.version ?? '1.0.0';
+    mcp.endpoints = mcp.endpoints ?? [];
+    mcp.configured = mcp.endpoints.length > 0;
+    const seen = new Set();
+    mcp.endpoints.forEach((endpointId)=>{
+        if (seen.has(endpointId)) {
+            throw new ConfigError(`Duplicate MCP tool "${endpointId}".`, {
+                configKey
+            });
+        }
+        seen.add(endpointId);
+        const endpoint = (components.api ?? []).find((e)=>e.id === endpointId || e.endpointId === endpointId);
+        if (type.isNone(endpoint)) {
+            throw new ConfigError(`MCP endpoint "${endpointId}" does not reference a defined api endpoint.`, {
+                configKey
+            });
+        }
+        // MCP is an external transport - InternalApi endpoints are not addressable
+        // from outside the server, matching the HTTP endpoint route.
+        if (endpoint.type === 'InternalApi') {
+            throw new ConfigError(`MCP endpoint "${endpointId}" is an InternalApi endpoint. Only "Api" endpoints can be exposed as MCP tools.`, {
+                configKey
+            });
+        }
+        if (type.isNone(endpoint.description)) {
+            throw new ConfigError(`Endpoint "${endpointId}" is exposed as an MCP tool but does not have a "description".`, {
+                configKey: endpoint['~k'] ?? configKey
+            });
+        }
+        if (type.isNone(endpoint.payloadSchema)) {
+            throw new ConfigError(`Endpoint "${endpointId}" is exposed as an MCP tool but does not have a "payloadSchema".`, {
+                configKey: endpoint['~k'] ?? configKey
+            });
+        }
+    });
+    return components;
+}
+export default buildMcp;

package/dist/build/buildModuleDefs.js

@@ -14,13 +14,13 @@
   limitations under the License.
 */ import operators from '@lowdefy/operators-js/operators/build';
 import { resolve, WalkContext } from './buildRefs/walker.js';
+import { assertNoPlaceholderLeaks } from './buildRefs/deferredRegistry.js';
 import getRefContent from './buildRefs/getRefContent.js';
 import makeRefDefinition from './buildRefs/makeRefDefinition.js';
-import evaluateStaticOperators from './buildRefs/evaluateStaticOperators.js';
 import collectDynamicIdentifiers from './collectDynamicIdentifiers.js';
 import validateOperatorsDynamic from './validateOperatorsDynamic.js';
 import fetchModules from './fetchModules.js';
-import { resolveLocalManifest, resolveFullManifest, validateRequiredVars } from './registerModules.js';
+import { resolveLocalManifest, recordifyExportables, resolveFullManifest, validateRequiredVars } from './registerModules.js';
 import resolveModuleDependencies from './resolveModuleDependencies.js';
 validateOperatorsDynamic({
     operators
@@ -50,64 +50,86 @@ async function parseLowdefyYaml({ context }) {
         ] : []),
         operators,
         env: process.env,
+        lowdefyApp: context.appMeta,
         dynamicIdentifiers,
         shouldStop: (path)=>{
             // Defer entry vars and connections: they may contain cross-module
-            // refs that require modules to be registered first.
-            if (/^modules\.\d+\.vars$/.test(path)) return 'preserve';
-            if (/^modules\.\d+\.connections$/.test(path)) return 'preserve';
+            // refs that require modules to be registered first. Non-modules keys
+            // stay raw for the app buildRefs pass.
+            if (/^modules\.\d+\.vars$/.test(path)) return 'skip';
+            if (/^modules\.\d+\.connections$/.test(path)) return 'skip';
             if (path.startsWith('modules')) return false;
-            return 'preserve';
+            return 'skip';
         }
     });
-    let config = await resolve(content, ctx);
-    config = evaluateStaticOperators({
-        context,
-        input: config,
-        refDef
-    });
+    const config = await resolve(content, ctx);
     return config ?? {};
 }
-async function resolveEntryConfig({ entry, context }) {
-    const moduleEntry = context.modules[entry.id];
+function makeAppLevelCtx({ context, deferModuleRefs = false, entryId, entrySection }) {
     const lowdefyYamlRefDef = context.lowdefyYamlRefDef;
-    function makeAppLevelCtx() {
-        return new WalkContext({
-            buildContext: context,
-            refId: lowdefyYamlRefDef.id,
-            sourceRefId: null,
-            vars: {},
-            path: '',
-            currentFile: lowdefyYamlRefDef.path,
-            refChain: new Set(lowdefyYamlRefDef.path ? [
-                lowdefyYamlRefDef.path
-            ] : []),
-            operators,
-            env: process.env,
-            dynamicIdentifiers
-        });
-    }
-    const refDef = lowdefyYamlRefDef;
-    let resolvedVars = await resolve(moduleEntry.consumerVars, makeAppLevelCtx());
-    resolvedVars = evaluateStaticOperators({
-        context,
-        input: resolvedVars,
-        refDef
+    return new WalkContext({
+        buildContext: context,
+        refId: lowdefyYamlRefDef.id,
+        sourceRefId: null,
+        vars: {},
+        path: '',
+        currentFile: lowdefyYamlRefDef.path,
+        refChain: new Set(lowdefyYamlRefDef.path ? [
+            lowdefyYamlRefDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        lowdefyApp: context.appMeta,
+        dynamicIdentifiers,
+        deferModuleRefs,
+        entryId,
+        entrySection
     });
-    moduleEntry.consumerVars = resolvedVars ?? {};
-    let resolvedConnections = await resolve(moduleEntry.connections, makeAppLevelCtx());
-    resolvedConnections = evaluateStaticOperators({
+}
+// Stage 1 — prepare: resolve entry vars/connections in the enclosing (app)
+// scope; cross-module refs become entryRef records with the prepared refDef as
+// body (their dynamic parts already resolved), leaving placeholders in the
+// blobs. Order-free: nothing is consumed here.
+async function prepareEntryConfig({ moduleEntry, context }) {
+    const varsResult = await resolve(moduleEntry.consumerVars, makeAppLevelCtx({
         context,
-        input: resolvedConnections,
-        refDef
-    });
-    moduleEntry.connections = resolvedConnections ?? {};
-    validateRequiredVars(moduleEntry.varDefs, moduleEntry.consumerVars, entry.id, entry.source);
+        deferModuleRefs: true,
+        entryId: moduleEntry.id,
+        entrySection: 'consumerVars'
+    }));
+    moduleEntry.consumerVars = varsResult ?? {};
+    const connectionsResult = await resolve(moduleEntry.connections, makeAppLevelCtx({
+        context,
+        deferModuleRefs: true,
+        entryId: moduleEntry.id,
+        entrySection: 'connections'
+    }));
+    moduleEntry.connections = connectionsResult ?? {};
+}
+// Final sweep: re-walk each entry's blobs with deferral off. Placeholders
+// dispatch into resolveDeferred (value-granular demand, wait-graph cycle
+// detection — order immaterial, memo skips already-demanded records), and the
+// _module.connectionId object form (deferred during prepare) resolves against
+// now-prepared targets. In-place walk mutation is the write-back, so resolved
+// values land in consumerVars/connections with consumption provenance.
+async function sweepEntryConfig({ moduleEntry, context }) {
+    const varsResult = await resolve(moduleEntry.consumerVars, makeAppLevelCtx({
+        context
+    }));
+    moduleEntry.consumerVars = varsResult ?? {};
+    const connectionsResult = await resolve(moduleEntry.connections, makeAppLevelCtx({
+        context
+    }));
+    moduleEntry.connections = connectionsResult ?? {};
+    validateRequiredVars(moduleEntry.varDefs, moduleEntry.consumerVars, moduleEntry.id, moduleEntry.source);
 }
 async function buildModuleDefs({ context }) {
     const lowdefyConfig = await parseLowdefyYaml({
         context
     });
+    // Stash for index.js to compute appMeta before buildRefs, so the _build.app
+    // operator can resolve app metadata during ref resolution.
+    context.lowdefyConfig = lowdefyConfig;
     context.plugins = lowdefyConfig.plugins ?? [];
     const moduleEntries = lowdefyConfig.modules ?? [];
     if (moduleEntries.length === 0) {
@@ -129,11 +151,28 @@ async function buildModuleDefs({ context }) {
     resolveModuleDependencies({
         context
     });
-    // Step 2.5: Resolve deferred entry vars and connections at app level,
-    // then validate required vars against the resolved values.
+    // Step 2.5a — prepare all entries. No cross-entry work; order-free.
     for (const entry of moduleEntries){
-        await resolveEntryConfig({
-            entry,
+        await prepareEntryConfig({
+            moduleEntry: context.modules[entry.id],
+            context
+        });
+    }
+    // Phase C.5 — record-ify exportables (components, menu links) for every
+    // entry BEFORE anything can consume them: record creation must precede all
+    // consumption, or cross-entry refs would race manifest resolve order.
+    for (const entry of moduleEntries){
+        await recordifyExportables({
+            entryId: entry.id,
+            context
+        });
+    }
+    // Step 2.5b — final sweep. Per-record demand through the wait-graph makes
+    // the order immaterial; required-var validation runs per entry after its
+    // blobs are concrete.
+    for (const entry of moduleEntries){
+        await sweepEntryConfig({
+            moduleEntry: context.modules[entry.id],
             context
         });
     }
@@ -144,5 +183,8 @@ async function buildModuleDefs({ context }) {
             context
         });
     }
+    // Post-sweep invariant: no deferred placeholder survives outside the
+    // per-consumer slots (manifest component/menu bodies, varDefs defaults).
+    assertNoPlaceholderLeaks(context);
 }
 export default buildModuleDefs;

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;