@lowdefy/build 4.5.2 → 4.6.0

package/dist/build/buildRefs/populateRefs.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -12,32 +12,94 @@
   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 { get, type } from '@lowdefy/helpers';
+*/ import { get, serializer, type } from '@lowdefy/helpers';
+/**
+ * Copies a _var value while preserving source location markers.
+ *
+ * When _var copies a value from vars into a template, we need to preserve
+ * the ~r (ref ID) and ~l (line number) from WHERE THE VALUE IS DEFINED
+ * (the source file), not where _var is used (the template).
+ *
+ * The issue is that serializer.copy loses non-enumerable properties, and
+ * recursiveBuild.js then sets ~r to the template file for objects without ~r.
+ *
+ * This function preserves the source location by making ~r enumerable on
+ * the copied value, so it survives through subsequent serializer.copy calls.
+ *
+ * @param {*} value - The value to copy from vars
+ * @param {string} sourceRefId - The ref ID of the source file where the var is defined
+ * @returns {*} The copied value with preserved source location markers
+ */ function copyVarValue(value, sourceRefId) {
+    if (!type.isObject(value) && !type.isArray(value)) {
+        return value;
+    }
+    // Copy the value, preserving ~l and setting ~r to the source file
+    return serializer.copy(value, {
+        reviver: (_, v)=>{
+            if (type.isObject(v) || type.isArray(v)) {
+                // Preserve the source file's ref ID by setting it explicitly
+                // This prevents recursiveBuild from overwriting it with the template's ref ID
+                if (sourceRefId && v['~r'] === undefined) {
+                    v['~r'] = sourceRefId;
+                }
+            }
+            return v;
+        }
+    });
+}
 function refReviver(key, value) {
     if (type.isObject(value)) {
         if (!type.isUndefined(value._ref)) {
-            return this.parsedFiles[value._ref.id];
+            const result = this.parsedFiles[value._ref.id];
+            if (value._ref.ignoreBuildChecks !== undefined) {
+                if (type.isObject(result)) {
+                    result['~ignoreBuildChecks'] = value._ref.ignoreBuildChecks;
+                } else if (type.isArray(result)) {
+                    result.forEach((item)=>{
+                        if (type.isObject(item)) {
+                            item['~ignoreBuildChecks'] = value._ref.ignoreBuildChecks;
+                        }
+                    });
+                }
+            }
+            return result;
         }
         if (value._var) {
             if (type.isString(value._var)) {
-                return JSON.parse(JSON.stringify(get(this.vars, value._var, {
+                const varValue = get(this.vars, value._var, {
                     default: null
-                })));
+                });
+                return copyVarValue(varValue, this.sourceRefId);
             }
             if (type.isObject(value._var) && type.isString(value._var.key)) {
-                return JSON.parse(JSON.stringify(get(this.vars, value._var.key, {
-                    default: type.isNone(value._var.default) ? null : value._var.default
-                })));
+                const varKey = value._var.key;
+                const varFromParent = get(this.vars, varKey);
+                // Check if var was explicitly provided (even if null) vs not provided at all (undefined)
+                // - Var provided (including null): use parent's sourceRefId for location
+                // - Var not provided (undefined): use default, preserve template's location
+                if (!type.isUndefined(varFromParent)) {
+                    // Var was explicitly provided from parent file - use parent's location
+                    return copyVarValue(varFromParent, this.sourceRefId);
+                }
+                // Using default value defined in template - preserve template's location markers
+                // Pass null for sourceRefId so we don't override the template file's ~r
+                const defaultValue = type.isNone(value._var.default) ? null : value._var.default;
+                return copyVarValue(defaultValue, null);
             }
-            throw new Error(`"_var" operator takes a string or object with "key" field as arguments. Received "${JSON.stringify(value)}"`);
+            throw new Error('_var operator takes a string or object with "key" field as arguments.');
         }
     }
     return value;
 }
 function populateRefs({ parsedFiles, refDef, toPopulate }) {
-    return JSON.parse(JSON.stringify(toPopulate), refReviver.bind({
-        parsedFiles,
-        vars: refDef.vars
-    }));
+    // Use serializer.copy to preserve non-enumerable properties like ~r, ~k, ~l
+    // sourceRefId is the PARENT file's ref ID where vars are defined (not the template's ID)
+    return serializer.copy(toPopulate, {
+        reviver: refReviver.bind({
+            parsedFiles,
+            vars: refDef.vars,
+            sourceRefId: refDef.parent
+        })
+    });
 }
 export default populateRefs;

package/dist/build/buildRefs/recursiveBuild.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -12,30 +12,65 @@
   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 { serializer, type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+import createRefReviver from './createRefReviver.js';
 import evaluateBuildOperators from './evaluateBuildOperators.js';
 import getKey from './getKey.js';
 import getRefContent from './getRefContent.js';
+import getRefPositions from '../jit/getRefPositions.js';
 import getRefsFromFile from './getRefsFromFile.js';
 import populateRefs from './populateRefs.js';
 import runTransformer from './runTransformer.js';
-async function recursiveBuild({ context, refDef, count, referencedFrom }) {
-    // TODO: Maybe it would be better to detect a cycle, since this is the real issue here?
+import isPageContentPath from '../jit/isPageContentPath.js';
+async function recursiveBuild({ context, refDef, count, content, referencedFrom, refChainSet = new Set(), refChainList = [], shallowOptions, jsonPath = '' }) {
+    // Detect circular references by tracking the chain of files being resolved
+    // Skip circular reference checking for refs without paths (e.g., resolver refs)
+    const currentPath = refDef.path;
+    if (currentPath) {
+        if (refChainSet.has(currentPath)) {
+            const chainDisplay = [
+                ...refChainList,
+                currentPath
+            ].join('\n  -> ');
+            throw new ConfigError(`Circular reference detected. File "${currentPath}" references itself through:\n  -> ${chainDisplay}`, {
+                filePath: referencedFrom ?? null,
+                lineNumber: referencedFrom ? refDef.lineNumber : null
+            });
+        }
+        refChainSet.add(currentPath);
+        refChainList.push(currentPath);
+    }
+    // Keep count as a fallback safety limit
     if (count > 10000) {
-        throw new Error(`Maximum recursion depth of references exceeded.`);
+        throw new ConfigError('Maximum recursion depth of references exceeded (10000 levels). This likely indicates a circular reference.');
     }
-    let fileContent = await getRefContent({
+    let fileContent = content ?? await getRefContent({
         context,
         refDef,
         referencedFrom
     });
     const { foundRefs, fileContentBuiltRefs } = getRefsFromFile(fileContent, refDef.id, context.refMap);
     const parsedFiles = {};
+    // Compute the JSON path position of each ref within the current file's content.
+    // This lets us check if a ref should be skipped during shallow builds.
+    const refPositions = shallowOptions ? getRefPositions(fileContentBuiltRefs, jsonPath) : null;
     // Since we can have references in the variables of a reference, we need to first parse
     // the deeper nodes, so we can use those parsed files in references higher in the tree.
     // To do this, since foundRefs is an array of ref definitions that are in order of the
     // deepest nodes first we for loop over over foundRefs one by one, awaiting each result.
     for (const newRefDef of foundRefs.values()){
+        // Check if this ref should be skipped (shallow build)
+        const refJsonPath = refPositions?.get(newRefDef.id) ?? '';
+        if (shallowOptions && isPageContentPath(refJsonPath)) {
+            // Store shallow marker instead of resolving
+            parsedFiles[newRefDef.id] = {
+                '~shallow': true,
+                _ref: newRefDef.original,
+                _refId: newRefDef.id
+            };
+            continue;
+        }
         // Parse vars and path before passing down to parse new file
         const parsedRefDef = populateRefs({
             toPopulate: newRefDef,
@@ -43,11 +78,22 @@ async function recursiveBuild({ context, refDef, count, referencedFrom }) {
             refDef
         });
         context.refMap[parsedRefDef.id].path = parsedRefDef.path;
+        // Store original definition for resolver refs so JIT can re-run them
+        if (!parsedRefDef.path) {
+            context.refMap[parsedRefDef.id].original = newRefDef.original;
+        }
+        if (Object.keys(newRefDef.vars).length > 0) {
+            context.unresolvedRefVars[newRefDef.id] = newRefDef.vars;
+        }
         const parsedFile = await recursiveBuild({
             context,
             refDef: parsedRefDef,
             count: count + 1,
-            referencedFrom: refDef.path
+            referencedFrom: refDef.path ?? referencedFrom,
+            refChainSet,
+            refChainList,
+            shallowOptions,
+            jsonPath: refJsonPath
         });
         const transformedFile = await runTransformer({
             context,
@@ -64,17 +110,19 @@ async function recursiveBuild({ context, refDef, count, referencedFrom }) {
             input: evaluatedOperators,
             refDef: parsedRefDef
         });
-        const reviver = (_, value)=>{
-            if (!type.isObject(value)) return value;
-            Object.defineProperty(value, '~r', {
-                value: refDef.id,
-                enumerable: false,
-                writable: true,
-                configurable: true
-            });
-            return value;
-        };
-        parsedFiles[newRefDef.id] = JSON.parse(JSON.stringify(withRefKey), reviver);
+        // Use serializer.copy to preserve non-enumerable properties like ~l.
+        // Only set ~r if not already present to preserve original file references from nested imports.
+        // Use child file's ref ID (parsedRefDef.id) not parent's (refDef.id) for correct error tracing.
+        const reviver = createRefReviver(parsedRefDef.id);
+        parsedFiles[newRefDef.id] = serializer.copy(withRefKey, {
+            reviver
+        });
+    }
+    // Backtrack: remove current file from chain so sibling refs can use it
+    // Only remove if it was added (i.e., if currentPath exists)
+    if (currentPath) {
+        refChainSet.delete(currentPath);
+        refChainList.pop();
     }
     return populateRefs({
         toPopulate: fileContentBuiltRefs,

package/dist/build/buildRefs/runRefResolver.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -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/errors';
 import getUserJavascriptFunction from './getUserJavascriptFunction.js';
 async function runRefResolver({ context, refDef, referencedFrom }) {
     const resolverFn = await getUserJavascriptFunction({
@@ -23,10 +24,17 @@ 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(`Error calling resolver "${refDef.resolver}".`, {
+            cause: error,
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber
+        });
     }
     if (type.isNone(content)) {
-        throw new Error(`Tried to reference with resolver "${refDef.resolver}" from "${referencedFrom}", but received "${content}".`);
+        throw new ConfigError(`Resolver "${refDef.resolver}" returned "${content}".`, {
+            filePath: referencedFrom,
+            lineNumber: refDef.lineNumber
+        });
     }
     return content;
 }

package/dist/build/buildRefs/runTransformer.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -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 getUserJavascriptFunction from './getUserJavascriptFunction.js';
+*/ import { ConfigError } from '@lowdefy/errors';
+import getUserJavascriptFunction from './getUserJavascriptFunction.js';
 async function runTransformer({ context, input, refDef }) {
     if (refDef.transformer) {
         const transformerFn = await getUserJavascriptFunction({
@@ -22,7 +23,10 @@ async function runTransformer({ context, input, refDef }) {
         try {
             return transformerFn(input, refDef.vars);
         } catch (error) {
-            throw Error(`Error calling transformer "${refDef.transformer}" from "${refDef.path}": ${error.message}`);
+            throw new ConfigError(`Error calling transformer "${refDef.transformer}" from "${refDef.path}".`, {
+                cause: error,
+                filePath: refDef.transformer
+            });
         }
     }
     return input;

package/dist/build/buildTypes.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -14,21 +14,36 @@
   limitations under the License.
 */ import basicTypes from '@lowdefy/blocks-basic/types';
 import loaderTypes from '@lowdefy/blocks-loaders/types';
+import { ConfigError, ConfigWarning } from '@lowdefy/errors';
+import findSimilarString from '../utils/findSimilarString.js';
 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]) {
+            const configKey = counter.getLocation(typeName);
+            let message = `${typeClass} type "${typeName}" was used but is not defined.`;
+            const suggestion = findSimilarString({
+                input: typeName,
+                candidates: definedTypes
+            });
+            if (suggestion) {
+                message += ` Did you mean "${suggestion}"?`;
+            }
             if (warnIfMissing) {
-                if (typeName === '_id') {
-                    return;
-                }
-                context.logger.warn(`${typeClass} type "${typeName}" was used but is not defined.`);
+                context.handleWarning(new ConfigWarning(message, {
+                    configKey,
+                    checkSlug: 'types'
+                }));
                 return;
             }
-            throw new Error(`${typeClass} type "${typeName}" was used but is not defined.`);
+            throw new ConfigError(message, {
+                configKey,
+                checkSlug: 'types'
+            });
         }
         store[typeName] = {
-            originalTypeName: definitions[typeName].originalTypeName,
+            originalTypeName: definitions[typeName].originalTypeName ?? typeName,
             package: definitions[typeName].package,
             version: definitions[typeName].version,
             count: counts[typeName]

package/dist/build/cleanBuildDirectory.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.

package/dist/build/collectDynamicIdentifiers.js

@@ -0,0 +1,35 @@
+/*
+  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';
+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/build/collectTypeNames.js

@@ -0,0 +1,36 @@
+/*
+  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';
+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 collectTypeNames;

package/dist/build/copyPublicFolder.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.

package/dist/build/{buildJs → full}/buildJs.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -12,11 +12,11 @@
   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 jsMapParser from './jsMapParser.js';
+*/ import jsMapParser from '../buildJs/jsMapParser.js';
 function buildJs({ components, context }) {
     components.pages = components.pages.map((page)=>{
         const pageRequests = [
-            ...page.requests
+            ...page.requests ?? []
         ];
         delete page.requests;
         const cleanPage = jsMapParser({

package/dist/build/full/buildPages.js

@@ -0,0 +1,87 @@
+/* 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, shouldSuppressBuildCheck } from '@lowdefy/errors';
+import buildPage from '../buildPages/buildPage.js';
+import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
+import validateLinkReferences from '../buildPages/validateLinkReferences.js';
+import validatePayloadReferences from '../buildPages/validatePayloadReferences.js';
+import validateServerStateReferences from '../buildPages/validateServerStateReferences.js';
+import validateStateReferences from '../buildPages/validateStateReferences.js';
+function buildPages({ components, context }) {
+    const pages = type.isArray(components.pages) ? components.pages : [];
+    const checkDuplicatePageId = createCheckDuplicateId({
+        message: 'Duplicate pageId "{{ id }}".'
+    });
+    // Initialize linkActionRefs to collect Link action references across all pages
+    context.linkActionRefs = [];
+    // Track which pages failed to build so we skip them in validation
+    const failedPageIndices = new Set();
+    // Wrap each page build to collect errors instead of stopping on first error
+    pages.forEach((page, index)=>{
+        try {
+            const result = buildPage({
+                page,
+                index,
+                context,
+                checkDuplicatePageId
+            });
+            // buildPage returns { failed: true } when validation fails
+            if (result?.failed) {
+                failedPageIndices.add(index);
+            }
+        } catch (error) {
+            // Skip suppressed ConfigErrors (via ~ignoreBuildChecks)
+            if (error instanceof ConfigError && shouldSuppressBuildCheck(error, context.keyMap)) {
+                return;
+            }
+            // Collect error object if context.errors exists, otherwise throw (for backward compat with tests)
+            if (context?.errors) {
+                context.errors.push(error);
+                failedPageIndices.add(index);
+            } else {
+                throw error;
+            }
+        }
+    });
+    // Validate that all Link actions reference existing pages
+    // Include all pages — a link to a broken page is valid; the page error is already reported
+    const pageIds = pages.map((page)=>page.pageId);
+    validateLinkReferences({
+        linkActionRefs: context.linkActionRefs,
+        pageIds,
+        context
+    });
+    // Validate that _state references use defined block IDs
+    // and _payload references use defined payload keys
+    // Skip pages that failed to build
+    pages.forEach((page, index)=>{
+        if (failedPageIndices.has(index)) return;
+        validateStateReferences({
+            page,
+            context
+        });
+        validatePayloadReferences({
+            page,
+            context
+        });
+        validateServerStateReferences({
+            page,
+            context
+        });
+    });
+    return components;
+}
+export default buildPages;

package/dist/build/{buildPages → full}/buildTestPage.js

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -16,7 +16,7 @@
 import buildAuth from '../buildAuth/buildAuth.js';
 import buildPages from './buildPages.js';
 import createContext from '../../createContext.js';
-function buildTestPage({ pageConfig }) {
+function buildTestPage({ pageConfig, connectionIds = [] }) {
     const context = createContext({
         customTypesMap: {},
         directories: {},
@@ -24,10 +24,22 @@ function buildTestPage({ pageConfig }) {
             debug: ()=>{},
             log: ()=>{},
             warn: ()=>{},
-            error: ()=>{}
+            error: ()=>{},
+            ui: {
+                warn: ()=>{},
+                error: ()=>{}
+            }
         },
         stage: 'test'
     });
+    // Add any connectionIds from test config to allow validation to pass
+    connectionIds.forEach((id)=>context.connectionIds.add(id));
+    // Also extract connectionIds from requests in the pageConfig
+    (pageConfig.requests || []).forEach((request)=>{
+        if (request.connectionId) {
+            context.connectionIds.add(request.connectionId);
+        }
+    });
     const components = {
         pages: [
             pageConfig

package/dist/build/{updateServerPackageJson.js → full/updateServerPackageJson.js}

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.

package/dist/build/{writePages.js → full/writePages.js}

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.

package/dist/build/{writeRequests.js → full/writeRequests.js}

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.
@@ -12,9 +12,17 @@
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-*/ import { serializer } from '@lowdefy/helpers';
+*/ import { serializer, type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
 async function writeRequestsOnPage({ page, context }) {
-    return Promise.all(page.requests.map(async (request)=>{
+    const requests = page.requests ?? [];
+    if (!type.isArray(requests)) {
+        throw new ConfigError('Page requests must be an array.', {
+            received: requests,
+            configKey: page['~k']
+        });
+    }
+    return Promise.all(requests.map(async (request)=>{
         await context.writeBuildArtifact(`pages/${page.pageId}/requests/${request.requestId}.json`, serializer.serializeToString(request ?? {}));
         delete request.properties;
         delete request.type;

package/dist/build/{writeTypes.js → full/writeTypes.js}

@@ -1,5 +1,5 @@
 /*
-  Copyright 2020-2024 Lowdefy, Inc
+  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.