@lowdefy/build 4.5.2 → 4.7.0

package/dist/build/buildRefs/walker.js

@@ -0,0 +1,340 @@
+/*
+  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 { get, type } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+import { evaluateOperators } from '@lowdefy/operators';
+import makeRefDefinition from './makeRefDefinition.js';
+import getRefContent from './getRefContent.js';
+import runTransformer from './runTransformer.js';
+import getKey from './getKey.js';
+import setNonEnumerableProperty from '../../utils/setNonEnumerableProperty.js';
+import collectExceptions from '../../utils/collectExceptions.js';
+let WalkContext = class WalkContext {
+    child(segment) {
+        return new WalkContext({
+            buildContext: this.buildContext,
+            refId: this.refId,
+            sourceRefId: this.sourceRefId,
+            vars: this.vars,
+            path: this.path ? `${this.path}.${segment}` : segment,
+            currentFile: this.currentFile,
+            refChain: this.refChain,
+            operators: this.operators,
+            env: this.env,
+            dynamicIdentifiers: this.dynamicIdentifiers,
+            shouldStop: this.shouldStop
+        });
+    }
+    forRef({ refId, vars, filePath }) {
+        const newChain = new Set(this.refChain);
+        if (filePath) {
+            newChain.add(filePath);
+        }
+        return new WalkContext({
+            buildContext: this.buildContext,
+            refId,
+            sourceRefId: this.refId,
+            vars: vars ?? {},
+            path: this.path,
+            currentFile: filePath ?? this.currentFile,
+            refChain: newChain,
+            operators: this.operators,
+            env: this.env,
+            dynamicIdentifiers: this.dynamicIdentifiers,
+            shouldStop: this.shouldStop
+        });
+    }
+    collectError(error) {
+        collectExceptions(this.buildContext, error);
+    }
+    get refMap() {
+        return this.buildContext.refMap;
+    }
+    get unresolvedRefVars() {
+        return this.buildContext.unresolvedRefVars;
+    }
+    constructor({ buildContext, refId, sourceRefId, vars, path, currentFile, refChain, operators, env, dynamicIdentifiers, shouldStop }){
+        this.buildContext = buildContext;
+        this.refId = refId;
+        this.sourceRefId = sourceRefId;
+        this.vars = vars;
+        this.path = path;
+        this.currentFile = currentFile;
+        this.refChain = refChain;
+        this.operators = operators;
+        this.env = env;
+        this.dynamicIdentifiers = dynamicIdentifiers;
+        this.shouldStop = shouldStop;
+    }
+};
+// Detect _build.* operator objects: single non-tilde key starting with '_build.'
+function isBuildOperator(node) {
+    const keys = Object.keys(node);
+    const nonTildeKeys = keys.filter((k)=>!k.startsWith('~'));
+    return nonTildeKeys.length === 1 && nonTildeKeys[0].startsWith('_build.');
+}
+// Set ~r as non-enumerable if not already present
+function tagRef(node, refId) {
+    if (type.isObject(node) || type.isArray(node)) {
+        if (node['~r'] === undefined) {
+            setNonEnumerableProperty(node, '~r', refId);
+        }
+    }
+}
+// Recursively set ~r on all objects/arrays that don't already have it
+function tagRefDeep(node, refId) {
+    if (!type.isObject(node) && !type.isArray(node)) return;
+    if (node['~r'] !== undefined) return;
+    setNonEnumerableProperty(node, '~r', refId);
+    if (type.isArray(node)) {
+        for(let i = 0; i < node.length; i++){
+            tagRefDeep(node[i], refId);
+        }
+    } else {
+        for (const key of Object.keys(node)){
+            tagRefDeep(node[key], refId);
+        }
+    }
+}
+// Deep clone preserving ~r, ~l, ~k non-enumerable markers.
+// Used before resolving ref def path/vars to prevent mutation of stored originals.
+function cloneForResolve(value) {
+    if (!type.isObject(value) && !type.isArray(value)) return value;
+    if (type.isArray(value)) {
+        const clone = value.map((item)=>cloneForResolve(item));
+        if (value['~r'] !== undefined) setNonEnumerableProperty(clone, '~r', value['~r']);
+        if (value['~l'] !== undefined) setNonEnumerableProperty(clone, '~l', value['~l']);
+        if (value['~k'] !== undefined) setNonEnumerableProperty(clone, '~k', value['~k']);
+        if (value['~arr'] !== undefined) setNonEnumerableProperty(clone, '~arr', value['~arr']);
+        return clone;
+    }
+    const clone = {};
+    for (const key of Object.keys(value)){
+        clone[key] = cloneForResolve(value[key]);
+    }
+    if (value['~r'] !== undefined) setNonEnumerableProperty(clone, '~r', value['~r']);
+    if (value['~l'] !== undefined) setNonEnumerableProperty(clone, '~l', value['~l']);
+    if (value['~k'] !== undefined) setNonEnumerableProperty(clone, '~k', value['~k']);
+    return clone;
+}
+// Deep clone a var value, preserving markers and setting ~r provenance.
+// When sourceRefId is null, preserves the template's existing ~r markers.
+function cloneVarValue(value, sourceRefId) {
+    if (!type.isObject(value) && !type.isArray(value)) return value;
+    return cloneDeepWithProvenance(value, sourceRefId);
+}
+function cloneDeepWithProvenance(node, sourceRefId) {
+    if (!type.isObject(node) && !type.isArray(node)) return node;
+    if (type.isArray(node)) {
+        const clone = node.map((item)=>cloneDeepWithProvenance(item, sourceRefId));
+        if (node['~r'] !== undefined) {
+            setNonEnumerableProperty(clone, '~r', node['~r']);
+        } else if (sourceRefId) {
+            setNonEnumerableProperty(clone, '~r', sourceRefId);
+        }
+        if (node['~l'] !== undefined) setNonEnumerableProperty(clone, '~l', node['~l']);
+        if (node['~k'] !== undefined) setNonEnumerableProperty(clone, '~k', node['~k']);
+        if (node['~arr'] !== undefined) setNonEnumerableProperty(clone, '~arr', node['~arr']);
+        return clone;
+    }
+    const clone = {};
+    for (const key of Object.keys(node)){
+        clone[key] = cloneDeepWithProvenance(node[key], sourceRefId);
+    }
+    if (node['~r'] !== undefined) {
+        setNonEnumerableProperty(clone, '~r', node['~r']);
+    } else if (sourceRefId) {
+        setNonEnumerableProperty(clone, '~r', sourceRefId);
+    }
+    if (node['~l'] !== undefined) setNonEnumerableProperty(clone, '~l', node['~l']);
+    if (node['~k'] !== undefined) setNonEnumerableProperty(clone, '~k', node['~k']);
+    return clone;
+}
+// Evaluate a _build.* operator using evaluateOperators
+function evaluateBuildOperator(node, ctx) {
+    const { output, errors } = evaluateOperators({
+        input: node,
+        operators: ctx.operators,
+        operatorPrefix: '_build.',
+        env: ctx.env,
+        dynamicIdentifiers: ctx.dynamicIdentifiers
+    });
+    if (errors.length > 0) {
+        errors.forEach((error)=>{
+            error.filePath = error.refId ? ctx.refMap[error.refId]?.path : ctx.currentFile;
+            ctx.collectError(error);
+        });
+    }
+    return output;
+}
+// Resolve a _var node
+function resolveVar(node, ctx) {
+    const varDef = node._var;
+    // String form: { _var: "key" }
+    if (type.isString(varDef)) {
+        const value = get(ctx.vars, varDef, {
+            default: null
+        });
+        return cloneVarValue(value, ctx.sourceRefId);
+    }
+    // Object form: { _var: { key, default } }
+    if (type.isObject(varDef) && type.isString(varDef.key)) {
+        const varFromParent = get(ctx.vars, varDef.key);
+        // Var provided (even if null) → use parent's sourceRefId for location
+        if (!type.isUndefined(varFromParent)) {
+            return cloneVarValue(varFromParent, ctx.sourceRefId);
+        }
+        // Not provided → use default, preserve template's ~r
+        const defaultValue = type.isNone(varDef.default) ? null : varDef.default;
+        return cloneVarValue(defaultValue, null);
+    }
+    throw new ConfigError('_var operator takes a string or object with "key" field as arguments.', {
+        filePath: ctx.currentFile
+    });
+}
+// Resolve a _ref node (12-step ref handling)
+async function resolveRef(node, ctx) {
+    // 1. Create ref definition
+    const lineNumber = node['~l'];
+    const refDef = makeRefDefinition(node._ref, ctx.refId, ctx.refMap, lineNumber);
+    // 2. Store unresolved vars before resolution mutates them, and clone so
+    //    resolution operates on a copy (preserving original.vars for resolver refs).
+    const varKeys = Object.keys(refDef.vars);
+    if (varKeys.length > 0) {
+        ctx.unresolvedRefVars[refDef.id] = refDef.vars;
+        refDef.vars = cloneForResolve(refDef.vars);
+    }
+    // 3. Resolve dynamic path/vars/key
+    if (type.isObject(refDef.path)) {
+        refDef.path = await resolve(cloneForResolve(refDef.path), ctx);
+    }
+    for (const varKey of varKeys){
+        if (type.isObject(refDef.vars[varKey]) || type.isArray(refDef.vars[varKey])) {
+            refDef.vars[varKey] = await resolve(refDef.vars[varKey], ctx);
+        }
+    }
+    if (type.isObject(refDef.key)) {
+        refDef.key = await resolve(cloneForResolve(refDef.key), ctx);
+    }
+    // 4. Update refMap with resolved path; store original for resolver refs
+    ctx.refMap[refDef.id].path = refDef.path;
+    if (!refDef.path) {
+        ctx.refMap[refDef.id].original = refDef.original;
+    }
+    // 5. Circular detection
+    if (refDef.path && ctx.refChain.has(refDef.path)) {
+        const chainDisplay = [
+            ...ctx.refChain,
+            refDef.path
+        ].join('\n  -> ');
+        throw new ConfigError(`Circular reference detected. File "${refDef.path}" references itself through:\n  -> ${chainDisplay}`, {
+            filePath: ctx.currentFile,
+            lineNumber: ctx.currentFile ? lineNumber : null
+        });
+    }
+    // Steps 6-12: File operations that can fail independently per ref.
+    // Errors are collected so the walker can continue processing sibling refs,
+    // allowing multiple errors to be reported at once.
+    try {
+        // 6. Load content
+        let content = await getRefContent({
+            context: ctx.buildContext,
+            refDef,
+            referencedFrom: ctx.currentFile
+        });
+        // 7. Create child context for the ref file
+        const childCtx = ctx.forRef({
+            refId: refDef.id,
+            vars: refDef.vars,
+            filePath: refDef.path
+        });
+        // 8. Walk the content
+        content = await resolve(content, childCtx);
+        // 9. Run transformer
+        content = await runTransformer({
+            context: ctx.buildContext,
+            input: content,
+            refDef
+        });
+        // 10. Extract key
+        content = getKey({
+            input: content,
+            refDef
+        });
+        // 11. Tag all nodes with ~r for provenance
+        tagRefDeep(content, refDef.id);
+        // 12. Propagate ~ignoreBuildChecks
+        if (refDef.ignoreBuildChecks !== undefined) {
+            if (type.isObject(content)) {
+                content['~ignoreBuildChecks'] = refDef.ignoreBuildChecks;
+            } else if (type.isArray(content)) {
+                content.forEach((item)=>{
+                    if (type.isObject(item)) {
+                        item['~ignoreBuildChecks'] = refDef.ignoreBuildChecks;
+                    }
+                });
+            }
+        }
+        return content;
+    } catch (error) {
+        if (error instanceof ConfigError) {
+            ctx.collectError(error);
+            return null;
+        }
+        throw error;
+    }
+}
+// Core walk function — single-pass async tree walker
+async function resolve(node, ctx) {
+    // 1. Primitives pass through
+    if (!type.isObject(node) && !type.isArray(node)) return node;
+    // 2. Object with _ref
+    if (type.isObject(node) && !type.isUndefined(node._ref)) {
+        return resolveRef(node, ctx);
+    }
+    // 4. Object with _var — resolve, then re-walk the result so any
+    //    _ref or _build.* operators inside the default value get processed.
+    if (type.isObject(node) && !type.isUndefined(node._var)) {
+        const varResult = resolveVar(node, ctx);
+        return resolve(varResult, ctx);
+    }
+    // 5. Array — walk children in-place
+    if (type.isArray(node)) {
+        for(let i = 0; i < node.length; i++){
+            node[i] = await resolve(node[i], ctx.child(String(i)));
+        }
+        return node;
+    }
+    // 6. Object — walk children in-place
+    const keys = Object.keys(node);
+    for (const key of keys){
+        if (ctx.shouldStop) {
+            const childPath = ctx.path ? `${ctx.path}.${key}` : key;
+            if (ctx.shouldStop(childPath, ctx.refId)) {
+                delete node[key];
+                continue;
+            }
+        }
+        node[key] = await resolve(node[key], ctx.child(key));
+    }
+    // Check if this is a _build.* operator
+    if (isBuildOperator(node)) {
+        const result = evaluateBuildOperator(node, ctx);
+        tagRefDeep(result, ctx.refId);
+        return result;
+    }
+    return node;
+}
+export { resolve, WalkContext, cloneForResolve, tagRefDeep };

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.