@lowdefy/build 0.0.0-experimental-20260114142524 → 0.0.0-experimental-20260122074446

package/dist/build/buildPages/buildPage.js

@@ -13,26 +13,26 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import buildBlock from './buildBlock/buildBlock.js';
 import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
 import createCounter from '../../utils/createCounter.js';
-import formatConfigError from '../../utils/formatConfigError.js';
 import validateRequestReferences from './validateRequestReferences.js';
 function buildPage({ page, index, context, checkDuplicatePageId }) {
     const configKey = page['~k'];
     if (type.isUndefined(page.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Page id missing at page ${index}.`,
             configKey,
             context
-        }));
+        });
     }
     if (!type.isString(page.id)) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Page id is not a string at page ${index}. Received ${JSON.stringify(page.id)}.`,
             configKey,
             context
-        }));
+        });
     }
     checkDuplicatePageId({
         id: page.id,

package/dist/build/buildPages/validateLinkReferences.js

@@ -12,21 +12,20 @@
   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 formatConfigError from '../../utils/formatConfigError.js';
-function validateLinkReferences({ linkActionRefs, pageIds, context }) {
+*/ function validateLinkReferences({ linkActionRefs, pageIds, context }) {
     const pageIdSet = new Set(pageIds);
     linkActionRefs.forEach(({ pageId, action, sourcePageId })=>{
+        // Only skip validation if skip is explicitly true
+        // Pages must exist in app even if Link is conditional
+        if (action.skip === true) {
+            return;
+        }
         if (!pageIdSet.has(pageId)) {
-            const errorMessage = formatConfigError({
+            context.logger.configWarning({
                 message: `Page "${pageId}" not found. Link on page "${sourcePageId}" references non-existent page.`,
                 configKey: action['~k'],
-                context
+                prodError: true
             });
-            if (context.stage === 'dev' || context.stage === 'test') {
-                context.logger.warn(errorMessage);
-            } else {
-                throw new Error(errorMessage);
-            }
         }
     });
 }

package/dist/build/buildPages/validatePayloadReferences.js

@@ -13,7 +13,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import extractOperatorKey from '../../utils/extractOperatorKey.js';
-import formatConfigWarning from '../../utils/formatConfigWarning.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 function validatePayloadReferences({ page, context }) {
     const requests = page.requests || [];
@@ -41,11 +40,11 @@ function validatePayloadReferences({ page, context }) {
         payloadRefs.forEach((configKey, topLevelKey)=>{
             if (payloadKeys.has(topLevelKey)) return;
             const message = `_payload references "${topLevelKey}" in request "${request.requestId}" on page "${page.pageId}", ` + `but no key "${topLevelKey}" exists in the request payload definition. ` + `Payload keys are defined in the request's "payload" property. ` + `Check for typos or add the key to the payload definition.`;
-            context.logger.warn(formatConfigWarning({
+            context.logger.configWarning({
                 message,
                 configKey,
-                context
-            }));
+                prodError: true
+            });
         });
     });
 }

package/dist/build/buildPages/validateRequestReferences.js

@@ -12,21 +12,20 @@
   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 formatConfigError from '../../utils/formatConfigError.js';
+*/ import { type } from '@lowdefy/helpers';
 function validateRequestReferences({ requestActionRefs, requests, pageId, context }) {
     const requestIds = new Set(requests.map((req)=>req.requestId));
     requestActionRefs.forEach(({ requestId, action })=>{
+        // Skip validation if action has skip condition (true or operator object)
+        if (action.skip === true || type.isObject(action.skip)) {
+            return;
+        }
         if (!requestIds.has(requestId)) {
-            const errorMessage = formatConfigError({
+            context.logger.configWarning({
                 message: `Request "${requestId}" not defined on page "${pageId}".`,
                 configKey: action['~k'],
-                context
+                prodError: true
             });
-            if (context.stage === 'dev' || context.stage === 'test') {
-                context.logger.warn(errorMessage);
-            } else {
-                throw new Error(errorMessage);
-            }
         }
     });
 }

package/dist/build/buildPages/validateStateReferences.js

@@ -13,7 +13,6 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import extractOperatorKey from '../../utils/extractOperatorKey.js';
-import formatConfigWarning from '../../utils/formatConfigWarning.js';
 import traverseConfig from '../../utils/traverseConfig.js';
 function validateStateReferences({ page, context }) {
     // Single traversal collects blockIds, _state references, and SetState keys
@@ -51,11 +50,11 @@ function validateStateReferences({ page, context }) {
         // Skip if state key is from an input block or SetState action
         if (blockIds.has(topLevelKey) || setStateKeys.has(topLevelKey)) return;
         const message = `_state references "${topLevelKey}" on page "${page.pageId}", ` + `but no input block with id "${topLevelKey}" exists on this page. ` + `State keys are created from input block ids. ` + `Check for typos, add an input block with this id, or initialize the state with SetState.`;
-        context.logger.warn(formatConfigWarning({
+        context.logger.configWarning({
             message,
             configKey,
-            context
-        }));
+            prodError: true
+        });
     });
 }
 export default validateStateReferences;

package/dist/build/buildRefs/buildRefs.js

@@ -15,6 +15,7 @@
 */ import recursiveBuild from './recursiveBuild.js';
 import makeRefDefinition from './makeRefDefinition.js';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
+import evaluateStaticOperators from './evaluateStaticOperators.js';
 async function buildRefs({ context }) {
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
     let components = await recursiveBuild({
@@ -22,11 +23,18 @@ async function buildRefs({ context }) {
         refDef,
         count: 0
     });
+    // First: evaluate _build.* operators (e.g., _build.env)
     components = await evaluateBuildOperators({
         context,
         input: components,
         refDef
     });
+    // Second: evaluate static operators (_sum, _if, etc.) that don't depend on runtime data
+    components = evaluateStaticOperators({
+        context,
+        input: components,
+        refDef
+    });
     return components ?? {};
 }
 export default buildRefs;

package/dist/build/buildRefs/evaluateBuildOperators.js

@@ -14,10 +14,20 @@
   limitations under the License.
 */ import { BuildParser } from '@lowdefy/operators';
 import operators from '@lowdefy/operators-js/operators/build';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+// Validate and collect dynamic identifiers once at module load
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
 async function evaluateBuildOperators({ context, input, refDef }) {
     const operatorsParser = new BuildParser({
         env: process.env,
-        operators
+        operators,
+        dynamicIdentifiers
     });
     const { output, errors } = operatorsParser.parse({
         input,

package/dist/build/buildRefs/evaluateStaticOperators.js

@@ -0,0 +1,54 @@
+/*
+  Copyright 2020-2024 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 { BuildParser } from '@lowdefy/operators';
+import operators from '@lowdefy/operators-js/operators/build';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import collectTypeNames from '../collectTypeNames.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+// Validate and collect dynamic identifiers once at module load
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
+function evaluateStaticOperators({ context, input, refDef }) {
+    // Collect type names from context.typesMap for type boundary detection
+    const typeNames = collectTypeNames({
+        typesMap: context.typesMap
+    });
+    const operatorsParser = new BuildParser({
+        env: process.env,
+        operators,
+        dynamicIdentifiers,
+        typeNames
+    });
+    const location = refDef.path ?? refDef.resolver;
+    const { output, errors } = operatorsParser.parse({
+        input,
+        location,
+        operatorPrefix: '_'
+    });
+    if (errors.length > 0) {
+        errors.forEach((error)=>{
+            context.logger.configWarning({
+                message: error.message,
+                operatorLocation: error.operatorLocation
+            });
+        });
+    }
+    return output;
+}
+export default evaluateStaticOperators;

package/dist/build/buildRefs/getConfigFile.js

@@ -14,31 +14,36 @@
   limitations under the License.
 */ import path from 'path';
 import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 async function getConfigFile({ context, refDef, referencedFrom }) {
     if (!type.isString(refDef.path)) {
-        throw new Error(`Invalid _ref definition ${JSON.stringify({
-            _ref: refDef.original
-        })} in file ${referencedFrom}`);
+        throw new ConfigError({
+            message: `Invalid _ref definition: ${JSON.stringify({
+                _ref: refDef.original
+            })}`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     const content = await context.readConfigFile(refDef.path);
     if (content === null) {
-        // Build helpful error message with resolved path information
-        const lineInfo = refDef.lineNumber ? `:${refDef.lineNumber}` : '';
         const absolutePath = path.resolve(context.directories.config, refDef.path);
-        let message = `[Config Error] Referenced file does not exist: "${refDef.path}"\n`;
-        message += `  Referenced from: ${referencedFrom}${lineInfo}\n`;
-        message += `  Resolved to: ${absolutePath}\n`;
+        let message = `Referenced file does not exist: "${refDef.path}". Resolved to: ${absolutePath}`;
         // Help with common mistakes
         if (refDef.path.startsWith('../')) {
             const suggestedPath = refDef.path.replace(/^(\.\.\/)+/, '');
-            message += `\n  Tip: Paths in _ref are resolved from your config directory root.`;
-            message += `\n  Did you mean: "${suggestedPath}"?`;
+            message += ` Tip: Paths in _ref are resolved from config root. Did you mean "${suggestedPath}"?`;
         } else if (refDef.path.startsWith('./')) {
             const suggestedPath = refDef.path.substring(2);
-            message += `\n  Tip: Remove the "./" prefix - paths are resolved from config root.`;
-            message += `\n  Did you mean: "${suggestedPath}"?`;
+            message += ` Tip: Remove "./" prefix - paths are resolved from config root. Did you mean "${suggestedPath}"?`;
         }
-        throw new Error(message);
+        throw new ConfigError({
+            message,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     return content;
 }

package/dist/build/buildRefs/getRefContent.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 getConfigFile from './getConfigFile.js';
+*/ import { ConfigError } from '@lowdefy/node-utils';
+import getConfigFile from './getConfigFile.js';
 import parseRefContent from './parseRefContent.js';
 import runRefResolver from './runRefResolver.js';
 async function getRefContent({ context, refDef, referencedFrom }) {
@@ -36,9 +37,18 @@ async function getRefContent({ context, refDef, referencedFrom }) {
             referencedFrom
         });
     }
-    return parseRefContent({
-        content,
-        refDef
-    });
+    try {
+        return parseRefContent({
+            content,
+            refDef
+        });
+    } catch (error) {
+        // Re-throw parse errors as ConfigError with location info
+        throw new ConfigError({
+            message: `Error parsing "${refDef.path}": ${error.message}`,
+            filePath: refDef.path,
+            configDirectory: context.directories.config
+        });
+    }
 }
 export default getRefContent;

package/dist/build/buildRefs/makeRefDefinition.js

@@ -16,7 +16,7 @@
 import getRefPath from './getRefPath.js';
 import makeId from '../../utils/makeId.js';
 function makeRefDefinition(refDefinition, parent, refMap, lineNumber) {
-    const id = makeId();
+    const id = makeId.next();
     const refDef = {
         parent,
         lineNumber

package/dist/build/buildRefs/parseRefContent.js

@@ -36,10 +36,32 @@ function addLineNumbers(node, content, result) {
             if (isPair(pair) && isScalar(pair.key)) {
                 const key = pair.key.value;
                 const value = pair.value;
+                // Use key's line number for the value's ~l (more useful for error messages)
+                const keyLineNumber = pair.key.range ? getLineNumber(content, pair.key.range[0]) : null;
                 if (isMap(value)) {
-                    obj[key] = addLineNumbers(value, content, {});
+                    const mapResult = addLineNumbers(value, content, {});
+                    // Override ~l with key's line number if available
+                    if (keyLineNumber) {
+                        Object.defineProperty(mapResult, '~l', {
+                            value: keyLineNumber,
+                            enumerable: false,
+                            writable: true,
+                            configurable: true
+                        });
+                    }
+                    obj[key] = mapResult;
                 } else if (isSeq(value)) {
-                    obj[key] = addLineNumbers(value, content, []);
+                    const arrResult = addLineNumbers(value, content, []);
+                    // Override ~l with key's line number if available
+                    if (keyLineNumber) {
+                        Object.defineProperty(arrResult, '~l', {
+                            value: keyLineNumber,
+                            enumerable: false,
+                            writable: true,
+                            configurable: true
+                        });
+                    }
+                    obj[key] = arrResult;
                 } else if (isScalar(value)) {
                     obj[key] = value.value;
                 } else {
@@ -51,6 +73,14 @@ function addLineNumbers(node, content, result) {
     }
     if (isSeq(node)) {
         const arr = result || [];
+        if (node.range) {
+            Object.defineProperty(arr, '~l', {
+                value: getLineNumber(content, node.range[0]),
+                enumerable: false,
+                writable: true,
+                configurable: true
+            });
+        }
         for (const item of node.items){
             if (isMap(item)) {
                 arr.push(addLineNumbers(item, content, {}));

package/dist/build/buildRefs/recursiveBuild.js

@@ -13,8 +13,8 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { serializer, type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
-import formatConfigError from '../../utils/formatConfigError.js';
 import getKey from './getKey.js';
 import getRefContent from './getRefContent.js';
 import getRefsFromFile from './getRefsFromFile.js';
@@ -30,20 +30,22 @@ async function recursiveBuild({ context, refDef, count, referencedFrom, refChain
                 ...refChainList,
                 currentPath
             ].join('\n  -> ');
-            throw new Error(formatConfigError({
-                message: `Circular reference detected.\nFile "${currentPath}" references itself through:\n  -> ${chainDisplay}`,
-                context
-            }));
+            throw new ConfigError({
+                message: `Circular reference detected. File "${currentPath}" references itself through:\n  -> ${chainDisplay}`,
+                filePath: referencedFrom,
+                lineNumber: refDef.lineNumber,
+                configDirectory: context.directories.config
+            });
         }
         refChainSet.add(currentPath);
         refChainList.push(currentPath);
     }
     // Keep count as a fallback safety limit
     if (count > 10000) {
-        throw new Error(formatConfigError({
+        throw new ConfigError({
             message: `Maximum recursion depth of references exceeded (10000 levels). This likely indicates a circular reference.`,
             context
-        }));
+        });
     }
     let fileContent = await getRefContent({
         context,

package/dist/build/buildRefs/runRefResolver.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/node-utils';
 import getUserJavascriptFunction from './getUserJavascriptFunction.js';
 async function runRefResolver({ context, refDef, referencedFrom }) {
     const resolverFn = await getUserJavascriptFunction({
@@ -23,10 +24,20 @@ async function runRefResolver({ context, refDef, referencedFrom }) {
     try {
         content = await resolverFn(refDef.path, refDef.vars, context);
     } catch (error) {
-        throw new Error(`Error calling resolver "${refDef.resolver}" from "${referencedFrom}": ${error.message}`);
+        throw new ConfigError({
+            message: `Error calling resolver "${refDef.resolver}": ${error.message}`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     if (type.isNone(content)) {
-        throw new Error(`Tried to reference with resolver "${refDef.resolver}" from "${referencedFrom}", but received "${content}".`);
+        throw new ConfigError({
+            message: `Resolver "${refDef.resolver}" returned "${content}".`,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber,
+            configDirectory: context.directories.config
+        });
     }
     return content;
 }

package/dist/build/buildTypes.js

@@ -16,11 +16,20 @@
 import loaderTypes from '@lowdefy/blocks-loaders/types';
 import findSimilarString from '../utils/findSimilarString.js';
 import formatBuildError from './formatBuildError.js';
+// Check if a configKey has ~ignoreBuildCheck set
+function hasIgnoreBuildCheck(keyMap, configKey) {
+    return keyMap[configKey]?.['~ignoreBuildCheck'] === true;
+}
 function buildTypeClass(context, { counter, definitions, store, typeClass, warnIfMissing = false }) {
     const counts = counter.getCounts();
     const definedTypes = Object.keys(definitions);
     Object.keys(counts).forEach((typeName)=>{
         if (!definitions[typeName]) {
+            // Check if this type usage has ~ignoreBuildCheck flag
+            const configKey = counter.getLocation(typeName);
+            if (configKey && hasIgnoreBuildCheck(context.keyMap, configKey)) {
+                return; // Skip warning/error for this type
+            }
             let message = `${typeClass} type "${typeName}" was used but is not defined.`;
             const suggestion = findSimilarString({
                 input: typeName,

package/dist/build/collectDynamicIdentifiers.js

@@ -0,0 +1,35 @@
+/*
+  Copyright 2020-2024 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';
+function collectDynamicIdentifiers({ operators }) {
+    const dynamicIdentifiers = new Set();
+    Object.entries(operators).forEach(([operatorName, operatorFn])=>{
+        if (!type.isFunction(operatorFn)) return;
+        if (operatorFn.dynamic === true) {
+            dynamicIdentifiers.add(operatorName);
+            return;
+        }
+        // Check for method-level dynamic in meta
+        if (type.isObject(operatorFn.meta)) {
+            Object.entries(operatorFn.meta).forEach(([methodName, methodMeta])=>{
+                if (type.isObject(methodMeta) && methodMeta.dynamic === true) {
+                    dynamicIdentifiers.add(`${operatorName}.${methodName}`);
+                }
+            });
+        }
+    });
+    return dynamicIdentifiers;
+}
+export default collectDynamicIdentifiers;

package/dist/{utils/formatConfigError.js → build/collectTypeNames.js}

@@ -12,13 +12,25 @@
   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 formatConfigMessage from './formatConfigMessage.js';
-function formatConfigError({ message, configKey, context }) {
-    return formatConfigMessage({
-        prefix: '[Config Error]',
-        message,
-        configKey,
-        context
+*/ import { type } from '@lowdefy/helpers';
+function collectTypeNames({ typesMap }) {
+    const typeNames = new Set();
+    if (!type.isObject(typesMap)) {
+        return typeNames;
+    }
+    [
+        'blocks',
+        'requests',
+        'connections',
+        'actions',
+        'controls'
+    ].forEach((category)=>{
+        if (type.isObject(typesMap[category])) {
+            Object.keys(typesMap[category]).forEach((typeName)=>{
+                typeNames.add(typeName);
+            });
+        }
     });
+    return typeNames;
 }
-export default formatConfigError;
+export default collectTypeNames;

package/dist/build/formatBuildError.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 { resolveConfigLocation } from '@lowdefy/helpers';
+*/ import { resolveConfigLocation } from '@lowdefy/node-utils';
 function formatBuildError({ context, counter, typeName, message }) {
     const configKey = counter.getLocation(typeName);
     if (!configKey) {

package/dist/build/testSchema.js

@@ -13,8 +13,9 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { validate } from '@lowdefy/ajv';
+import { ConfigError } from '@lowdefy/node-utils';
+import findConfigKey from '../utils/findConfigKey.js';
 import lowdefySchema from '../lowdefySchema.js';
-import formatErrorMessage from '../utils/formatErrorMessage.js';
 function testSchema({ components, context }) {
     const { valid, errors } = validate({
         schema: lowdefySchema,
@@ -22,11 +23,49 @@ function testSchema({ components, context }) {
         returnErrors: true
     });
     if (!valid) {
-        context.logger.warn('Schema not valid.');
-        errors.map((error)=>context.logger.warn(formatErrorMessage({
-                error,
-                components
-            })));
+        // Filter out anyOf/oneOf cascade errors - these are always accompanied by
+        // more specific validation errors and just add noise
+        let filteredErrors = errors.filter((error)=>error.keyword !== 'anyOf' && error.keyword !== 'oneOf');
+        // Hierarchical deduplication: if an error exists at a child path,
+        // filter out errors at parent paths (prefer more specific errors)
+        filteredErrors = filteredErrors.filter((error)=>{
+            const hasChildError = filteredErrors.some((other)=>other !== error && other.instancePath.startsWith(error.instancePath + '/'));
+            return !hasChildError;
+        });
+        // Same-path deduplication: only show first error per unique path
+        // (multiple errors at same path are usually cascade errors from schema branches)
+        const seenPaths = new Set();
+        filteredErrors = filteredErrors.filter((error)=>{
+            if (seenPaths.has(error.instancePath)) {
+                return false;
+            }
+            seenPaths.add(error.instancePath);
+            return true;
+        });
+        filteredErrors.forEach((error)=>{
+            const instancePath = error.instancePath.split('/').slice(1).filter(Boolean);
+            const configKey = findConfigKey({
+                components,
+                instancePath
+            });
+            let message = error.message;
+            if (error.params?.additionalProperty) {
+                message = `${message} - "${error.params.additionalProperty}"`;
+            }
+            const configError = new ConfigError({
+                message,
+                configKey,
+                context
+            });
+            if (!configError.suppressed) {
+                if (!context.errors) {
+                    // If no error collection array, throw immediately (fallback for tests)
+                    throw new Error(configError.message);
+                }
+                // Collect error - logging happens at checkpoints in index.js
+                context.errors.push(configError.message);
+            }
+        });
     }
 }
 export default testSchema;