@lowdefy/build 5.0.0 → 5.2.0

package/dist/build/buildApi/buildRoutine/countStepTypes.js

@@ -13,6 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function countStepTypes(step, { typeCounters }) {
+    if (step.type === 'CallApi') {
+        return;
+    }
     typeCounters.requests.increment(step.type, step['~k']);
 }
 export default countStepTypes;

package/dist/build/buildApi/buildRoutine/setStepId.js

@@ -13,8 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ function setStepId(step, { endpointId }) {
-    step.requestId = step.id;
+    step.stepId = step.id;
     step.endpointId = endpointId;
-    step.id = `request:${endpointId}:${step.requestId}`;
+    const prefix = step.type === 'CallApi' ? 'endpoint' : 'request';
+    step.id = `${prefix}:${endpointId}:${step.stepId}`;
 }
 export default setStepId;

package/dist/build/buildApi/buildRoutine/validateStep.js

@@ -50,6 +50,25 @@ function validateStep(step, { endpointId }) {
             configKey
         });
     }
+    if (step.type === 'CallApi') {
+        if (type.isNone(step.properties?.endpointId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" requires properties.endpointId.`, {
+                configKey
+            });
+        }
+        if (!type.isString(step.properties.endpointId) && !type.isObject(step.properties.endpointId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" properties.endpointId is not a string.`, {
+                received: step.properties.endpointId,
+                configKey
+            });
+        }
+        if (!type.isNone(step.connectionId)) {
+            throw new ConfigError(`Endpoint step "${step.id}" at endpoint "${endpointId}" should not have a connectionId.`, {
+                configKey
+            });
+        }
+        return;
+    }
     if (type.isUndefined(step.connectionId)) {
         throw new ConfigError(`Step connectionId missing at endpoint "${endpointId}".`, {
             configKey

package/dist/build/buildApi/validateEndpoint.js

@@ -44,6 +44,16 @@ function validateEndpoint({ endpoint, index, checkDuplicateEndpointId }) {
             configKey
         });
     }
+    const validEndpointTypes = [
+        'Api',
+        'InternalApi'
+    ];
+    if (!validEndpointTypes.includes(endpoint.type)) {
+        throw new ConfigError(`Endpoint type "${endpoint.type}" is not valid at "${endpoint.id}". Must be one of: ${validEndpointTypes.join(', ')}.`, {
+            received: endpoint.type,
+            configKey
+        });
+    }
     checkDuplicateEndpointId({
         id: endpoint.id,
         configKey

package/dist/build/buildApi/validateStepReferences.js

@@ -17,16 +17,16 @@ import { type } from '@lowdefy/helpers';
 import extractOperatorKey from '../../utils/extractOperatorKey.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 // Collect all step IDs from a routine (including nested control structures)
-// Note: After buildRoutine, steps have requestId (original id) and id is modified
+// Note: After buildRoutine, steps have stepId (original id) and id is modified
 function collectStepIds(routine, stepIds) {
     if (type.isArray(routine)) {
         routine.forEach((item)=>collectStepIds(item, stepIds));
         return;
     }
     if (type.isObject(routine)) {
-        // Check if this is a step (has requestId after build, or id before build)
-        if (routine.requestId) {
-            stepIds.add(routine.requestId);
+        // Check if this is a step (has stepId after build, or id before build)
+        if (routine.stepId) {
+            stepIds.add(routine.stepId);
         }
         // Recurse into all values (handles control structures like :then, :else, :try, :catch)
         Object.values(routine).forEach((value)=>collectStepIds(value, stepIds));

package/dist/build/buildAuth/buildApiAuth.js

@@ -16,6 +16,7 @@
 import { ConfigError } from '@lowdefy/errors';
 import getApiRoles from './getApiRoles.js';
 import getProtectedApi from './getProtectedApi.js';
+import { isInPatternList } from './matchPattern.js';
 function buildApiAuth({ components, context }) {
     const protectedApiEndpoints = getProtectedApi({
         components
@@ -29,7 +30,7 @@ function buildApiAuth({ components, context }) {
     }
     (components.api || []).forEach((endpoint)=>{
         if (apiRoles[endpoint.id]) {
-            if (configPublicApi.includes(endpoint.id)) {
+            if (isInPatternList(endpoint.id, configPublicApi)) {
                 throw new ConfigError(`Endpoint "${endpoint.id}" is both protected by roles and public.`, {
                     received: apiRoles[endpoint.id],
                     configKey: endpoint['~k']

package/dist/build/buildAuth/buildPageAuth.js

@@ -16,6 +16,7 @@
 import { ConfigError } from '@lowdefy/errors';
 import getPageRoles from './getPageRoles.js';
 import getProtectedPages from './getProtectedPages.js';
+import { isInPatternList } from './matchPattern.js';
 function buildPageAuth({ components, context }) {
     const protectedPages = getProtectedPages({
         components
@@ -36,7 +37,7 @@ function buildPageAuth({ components, context }) {
             return;
         }
         if (pageRoles[page.id]) {
-            if (configPublicPages.includes(page.id)) {
+            if (isInPatternList(page.id, configPublicPages)) {
                 throw new ConfigError(`Page "${page.id}" is both protected by roles and public.`, {
                     received: pageRoles[page.id],
                     configKey: page['~k']

package/dist/build/buildAuth/getApiRoles.js

@@ -12,15 +12,21 @@
   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 getApiRoles({ components }) {
+*/ import { matchesPattern } from './matchPattern.js';
+function getApiRoles({ components }) {
     const roles = components.auth.api.roles;
+    const endpointIds = (components.api ?? []).map((e)=>e.id);
     const apiRoles = {};
     Object.keys(roles).forEach((roleName)=>{
-        roles[roleName].forEach((endpointId)=>{
-            if (!apiRoles[endpointId]) {
-                apiRoles[endpointId] = new Set();
-            }
-            apiRoles[endpointId].add(roleName);
+        roles[roleName].forEach((pattern)=>{
+            endpointIds.forEach((endpointId)=>{
+                if (matchesPattern(endpointId, pattern)) {
+                    if (!apiRoles[endpointId]) {
+                        apiRoles[endpointId] = new Set();
+                    }
+                    apiRoles[endpointId].add(roleName);
+                }
+            });
         });
     });
     Object.keys(apiRoles).forEach((endpointId)=>{

package/dist/build/buildAuth/getPageRoles.js

@@ -12,15 +12,21 @@
   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 getPageRoles({ components }) {
+*/ import { matchesPattern } from './matchPattern.js';
+function getPageRoles({ components }) {
     const roles = components.auth.pages.roles;
+    const pageIds = (components.pages ?? []).map((p)=>p.id);
     const pageRoles = {};
     Object.keys(roles).forEach((roleName)=>{
-        roles[roleName].forEach((pageId)=>{
-            if (!pageRoles[pageId]) {
-                pageRoles[pageId] = new Set();
-            }
-            pageRoles[pageId].add(roleName);
+        roles[roleName].forEach((pattern)=>{
+            pageIds.forEach((pageId)=>{
+                if (matchesPattern(pageId, pattern)) {
+                    if (!pageRoles[pageId]) {
+                        pageRoles[pageId] = new Set();
+                    }
+                    pageRoles[pageId].add(roleName);
+                }
+            });
         });
     });
     Object.keys(pageRoles).forEach((pageId)=>{

package/dist/build/buildAuth/getProtectedApi.js

@@ -13,15 +13,16 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { isInPatternList } from './matchPattern.js';
 function getProtectedApi({ components }) {
     const endpointIds = (components.api || []).map((endpoint)=>endpoint.id);
     let protectedApi = [];
     if (type.isArray(components.auth.api.public)) {
-        protectedApi = endpointIds.filter((endpointId)=>!components.auth.api.public.includes(endpointId));
+        protectedApi = endpointIds.filter((endpointId)=>!isInPatternList(endpointId, components.auth.api.public));
     } else if (components.auth.api.protected === true) {
         protectedApi = endpointIds;
     } else if (type.isArray(components.auth.api.protected)) {
-        protectedApi = components.auth.api.protected;
+        protectedApi = endpointIds.filter((endpointId)=>isInPatternList(endpointId, components.auth.api.protected));
     }
     return protectedApi;
 }

package/dist/build/buildAuth/getProtectedPages.js

@@ -13,15 +13,16 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { isInPatternList } from './matchPattern.js';
 function getProtectedPages({ components }) {
     const pageIds = (components.pages || []).map((page)=>page.id);
     let protectedPages = [];
     if (type.isArray(components.auth.pages.public)) {
-        protectedPages = pageIds.filter((pageId)=>!components.auth.pages.public.includes(pageId));
+        protectedPages = pageIds.filter((pageId)=>!isInPatternList(pageId, components.auth.pages.public));
     } else if (components.auth.pages.protected === true) {
         protectedPages = pageIds;
     } else if (type.isArray(components.auth.pages.protected)) {
-        protectedPages = components.auth.pages.protected;
+        protectedPages = pageIds.filter((pageId)=>isInPatternList(pageId, components.auth.pages.protected));
     }
     return protectedPages;
 }

package/dist/build/buildAuth/matchPattern.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.
+*/ import picomatch from 'picomatch';
+function matchesPattern(id, pattern) {
+    return picomatch.isMatch(id, pattern);
+}
+function isInPatternList(id, patternList) {
+    return patternList.some((pattern)=>matchesPattern(id, pattern));
+}
+export { matchesPattern, isInPatternList };

package/dist/build/buildConnections.js

@@ -12,20 +12,58 @@
   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 countOperators from '../utils/countOperators.js';
+*/ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+import collectExceptions from '../utils/collectExceptions.js';
+import countOperators from '../utils/countOperators.js';
 import createCheckDuplicateId from '../utils/createCheckDuplicateId.js';
 import validateId from '../utils/validateId.js';
+function validateConnection(connection, context) {
+    const configKey = connection?.['~k'];
+    if (!type.isObject(connection)) {
+        collectExceptions(context, new ConfigError('Connection should be an object.', {
+            received: connection,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isUndefined(connection.id)) {
+        collectExceptions(context, new ConfigError('Connection id missing.', {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(connection.id)) {
+        collectExceptions(context, new ConfigError('Connection id is not a string.', {
+            received: connection.id,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isNone(connection.type)) {
+        collectExceptions(context, new ConfigError(`Connection type is not defined at connection "${connection.id}".`, {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(connection.type)) {
+        collectExceptions(context, new ConfigError(`Connection type is not a string at connection "${connection.id}".`, {
+            received: connection.type,
+            configKey
+        }));
+        return false;
+    }
+    return true;
+}
 function buildConnections({ components, context }) {
     // Store connection IDs for validation in buildRequests
     context.connectionIds = new Set();
-    // Schema validates: id required, id is string, type is string
-    // Only check for duplicates here (schema can't do that)
     const checkDuplicateConnectionId = createCheckDuplicateId({
         message: 'Duplicate connectionId "{{ id }}".'
     });
     (components.connections ?? []).forEach((connection)=>{
+        if (!validateConnection(connection, context)) return;
         const configKey = connection['~k'];
-        // Check duplicates (schema can't validate this)
         checkDuplicateConnectionId({
             id: connection.id,
             configKey

package/dist/build/buildJs/jsMapParser.js

@@ -15,12 +15,10 @@
 */ import { ConfigError } from '@lowdefy/errors';
 import { serializer, type } from '@lowdefy/helpers';
 import crypto from 'crypto';
-function makeHash({ jsMap, env, value }) {
+function hashFn({ jsMap, env, value }) {
     const hash = crypto.createHash('sha1').update(value).digest('base64');
     jsMap[env][hash] = value;
-    return {
-        _js: hash
-    };
+    return hash;
 }
 function JsMapParser({ input, jsMap, env }) {
     if (!jsMap[env]) {
@@ -31,15 +29,30 @@ function JsMapParser({ input, jsMap, env }) {
         if (Object.keys(value).length !== 1) return value;
         const key = Object.keys(value)[0];
         if (key !== '_js') return value;
-        if (!type.isString(value[key])) {
-            throw new ConfigError(`_js operator expects the JavaScript definition as a string. Received ${JSON.stringify(value[key])}.`, {
-                configKey: value['~k']
-            });
+        const inner = value[key];
+        if (type.isString(inner)) {
+            return {
+                _js: hashFn({
+                    jsMap,
+                    env,
+                    value: inner
+                })
+            };
+        }
+        if (type.isObject(inner) && type.isString(inner.fn)) {
+            return {
+                _js: {
+                    fn: hashFn({
+                        jsMap,
+                        env,
+                        value: inner.fn
+                    }),
+                    args: inner.args
+                }
+            };
         }
-        return makeHash({
-            jsMap,
-            env,
-            value: value[key]
+        throw new ConfigError(`_js operator expects a JavaScript string or { fn: string, args?: object }. Received ${JSON.stringify(inner)}.`, {
+            configKey: value['~k']
         });
     };
     return serializer.copy(input, {

package/dist/build/buildJs/writeJs.js

@@ -16,11 +16,11 @@
 async function writeJs({ context }) {
     await context.writeBuildArtifact('plugins/operators/clientJsMap.js', generateJsFile({
         map: context.jsMap.client,
-        functionPrototype: `{ actions, event, input, location, lowdefyGlobal, request, state, urlQuery, user }`
+        functionPrototype: `{ actions, args, event, input, location, lowdefyGlobal, request, state, urlQuery, user }`
     }));
     await context.writeBuildArtifact('plugins/operators/serverJsMap.js', generateJsFile({
         map: context.jsMap.server,
-        functionPrototype: `{ item, payload, secrets, state, step, user }`
+        functionPrototype: `{ args, item, payload, secrets, state, step, user }`
     }));
 }
 export default writeJs;

package/dist/build/buildMenu.js

@@ -32,9 +32,50 @@ function buildDefaultMenu({ components, context }) {
     ];
     return menus;
 }
+function validateMenuItem(menuItem, menuId, context) {
+    const configKey = menuItem?.['~k'];
+    if (!type.isObject(menuItem)) {
+        collectExceptions(context, new ConfigError(`Menu item should be an object on menu "${menuId}".`, {
+            received: menuItem,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isUndefined(menuItem.id)) {
+        collectExceptions(context, new ConfigError(`Menu item id missing on menu "${menuId}".`, {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(menuItem.id)) {
+        collectExceptions(context, new ConfigError(`Menu item id is not a string on menu "${menuId}".`, {
+            received: menuItem.id,
+            configKey
+        }));
+        return false;
+    }
+    if (type.isNone(menuItem.type)) {
+        collectExceptions(context, new ConfigError(`Menu item type is not defined at "${menuItem.id}" on menu "${menuId}".`, {
+            configKey
+        }));
+        return false;
+    }
+    if (!type.isString(menuItem.type)) {
+        collectExceptions(context, new ConfigError(`Menu item type is not a string at "${menuItem.id}" on menu "${menuId}".`, {
+            received: menuItem.type,
+            configKey
+        }));
+        return false;
+    }
+    return true;
+}
 function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateMenuItemId, context }) {
     if (type.isArray(parent.links)) {
         parent.links.forEach((menuItem)=>{
+            if (!validateMenuItem(menuItem, menuId, context)) {
+                menuItem.remove = true;
+                return;
+            }
             const configKey = menuItem['~k'];
             if (menuItem.type === 'MenuLink') {
                 if (type.isString(menuItem.pageId)) {

package/dist/build/buildModuleDefs.js

@@ -0,0 +1,97 @@
+/*
+  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 operators from '@lowdefy/operators-js/operators/build';
+import { resolve, WalkContext } from './buildRefs/walker.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 } from './registerModules.js';
+import resolveModuleDependencies from './resolveModuleDependencies.js';
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+async function parseLowdefyYaml({ context }) {
+    const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
+    const content = await getRefContent({
+        context,
+        refDef,
+        referencedFrom: null
+    });
+    const ctx = new WalkContext({
+        buildContext: context,
+        refId: refDef.id,
+        sourceRefId: null,
+        vars: {},
+        path: '',
+        currentFile: refDef.path,
+        refChain: new Set(refDef.path ? [
+            refDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        dynamicIdentifiers,
+        shouldStop: (path)=>{
+            if (path.startsWith('modules')) return false;
+            return 'preserve';
+        }
+    });
+    let config = await resolve(content, ctx);
+    config = evaluateStaticOperators({
+        context,
+        input: config,
+        refDef
+    });
+    return config ?? {};
+}
+async function buildModuleDefs({ context }) {
+    const lowdefyConfig = await parseLowdefyYaml({
+        context
+    });
+    context.plugins = lowdefyConfig.plugins ?? [];
+    const moduleEntries = lowdefyConfig.modules ?? [];
+    if (moduleEntries.length === 0) {
+        return;
+    }
+    const resolvedPaths = await fetchModules({
+        moduleEntries,
+        context
+    });
+    // Step 1: Local resolve — concrete arrays, preserved content, exports/deps extracted
+    for (const entry of moduleEntries){
+        await resolveLocalManifest({
+            entry,
+            resolvedPaths: resolvedPaths[entry.id],
+            context
+        });
+    }
+    // Step 2: Auto-wire and validate dependency wiring
+    resolveModuleDependencies({
+        context
+    });
+    // Step 3: Full resolve — cross-module refs, preserved content
+    for (const entryId of Object.keys(context.modules)){
+        await resolveFullManifest({
+            entryId,
+            context
+        });
+    }
+}
+export default buildModuleDefs;

package/dist/build/buildModules.js

@@ -0,0 +1,96 @@
+/* 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 { ConfigError } from '@lowdefy/errors';
+import { serializer, type } from '@lowdefy/helpers';
+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;
+        }
+    });
+}
+function buildModules({ components, context }) {
+    const moduleEntries = components.modules ?? [];
+    delete components.modules;
+    for (const entry of moduleEntries){
+        const moduleEntry = context.modules[entry.id];
+        if (!moduleEntry) {
+            throw new ConfigError(`Module entry "${entry.id}" not registered. ` + `Check that buildModuleDefs ran successfully.`);
+        }
+        const manifest = moduleEntry.manifest;
+        // Validate connection remapping keys
+        const remapping = moduleEntry.connections ?? {};
+        const moduleConnIds = new Set((manifest.connections ?? []).map((c)=>c.id));
+        for (const remapKey of Object.keys(remapping)){
+            if (!moduleConnIds.has(remapKey)) {
+                throw new ConfigError(`Module "${entry.id}" connection remapping references "${remapKey}", ` + `but the module does not export a connection with that id.`);
+            }
+        }
+        // Validate secret whitelist on non-remapped content
+        for (const page of manifest.pages ?? []){
+            validateModuleSecrets({
+                content: page,
+                manifest,
+                entryId: entry.id
+            });
+        }
+        for (const conn of manifest.connections ?? []){
+            if (remapping[conn.id]) continue;
+            validateModuleSecrets({
+                content: conn,
+                manifest,
+                entryId: entry.id
+            });
+        }
+        for (const endpoint of manifest.api ?? []){
+            validateModuleSecrets({
+                content: endpoint,
+                manifest,
+                entryId: entry.id
+            });
+        }
+        // Process pages
+        for (const page of manifest.pages ?? []){
+            page.id = `${entry.id}/${page.id}`;
+            components.pages = components.pages ?? [];
+            components.pages.push(page);
+        }
+        // Process connections (skip remapped -- app provides those)
+        for (const conn of manifest.connections ?? []){
+            if (remapping[conn.id]) continue;
+            conn.id = `${entry.id}/${conn.id}`;
+            components.connections = components.connections ?? [];
+            components.connections.push(conn);
+        }
+        // Process API endpoints
+        for (const endpoint of manifest.api ?? []){
+            endpoint.id = `${entry.id}/${endpoint.id}`;
+            components.api = components.api ?? [];
+            components.api.push(endpoint);
+        }
+    }
+    return components;
+}
+export default buildModules;

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

@@ -25,8 +25,8 @@ import normalizeLayout from './normalizeLayout.js';
 import setBlockId from './setBlockId.js';
 import validateBlock from './validateBlock.js';
 import validateSlots from './validateSlots.js';
-function buildBlock(block, pageContext) {
-    validateBlock(block, pageContext);
+function buildBlock(block, pageContext, parentConfigKey) {
+    validateBlock(block, pageContext, parentConfigKey);
     setBlockId(block, pageContext);
     normalizeLayout(block, pageContext);
     moveAreasToSlots(block, pageContext);