@lowdefy/build 5.3.0 → 5.4.0

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

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

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

@@ -12,10 +12,14 @@
   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 setStepId(step, { endpointId }) {
+*/ const prefixByType = {
+    CallApi: 'endpoint',
+    ValidateSchema: 'validate'
+};
+function setStepId(step, { endpointId }) {
     step.stepId = step.id;
     step.endpointId = endpointId;
-    const prefix = step.type === 'CallApi' ? 'endpoint' : 'request';
+    const prefix = prefixByType[step.type] ?? 'request';
     step.id = `${prefix}:${endpointId}:${step.stepId}`;
 }
 export default setStepId;

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

@@ -69,6 +69,24 @@ function validateStep(step, { endpointId }) {
         }
         return;
     }
+    if (step.type === 'ValidateSchema') {
+        if (type.isNone(step.properties?.schema)) {
+            throw new ConfigError(`ValidateSchema step "${step.id}" at endpoint "${endpointId}" requires properties.schema.`, {
+                configKey
+            });
+        }
+        if (type.isNone(step.properties?.data)) {
+            throw new ConfigError(`ValidateSchema step "${step.id}" at endpoint "${endpointId}" requires properties.data.`, {
+                configKey
+            });
+        }
+        if (!type.isNone(step.connectionId)) {
+            throw new ConfigError(`ValidateSchema 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/buildApp.js

@@ -14,6 +14,15 @@
   limitations under the License.
 */ import { execSync } from 'child_process';
 import { type } from '@lowdefy/helpers';
+function computeGitSha() {
+    const fromEnv = process.env.LOWDEFY_GIT_SHA?.trim();
+    if (fromEnv) return fromEnv;
+    try {
+        return execSync('git rev-parse HEAD').toString().trim();
+    } catch (_) {
+        return null;
+    }
+}
 function buildApp({ components }) {
     if (type.isNone(components.app)) {
         components.app = {};
@@ -30,11 +39,15 @@ function buildApp({ components }) {
     if (type.isNone(components.app.html.appendHead)) {
         components.app.html.appendHead = '';
     }
-    try {
-        components.app.git_sha = execSync('git rev-parse HEAD').toString().trim();
-    } catch (_) {
-    //pass
-    }
+    components.appMeta = {
+        slug: components.slug ?? null,
+        name: components.name ?? null,
+        version: components.version ?? null,
+        description: components.description ?? null,
+        license: components.license ?? null,
+        lowdefyVersion: components.lowdefy ?? null,
+        gitSha: computeGitSha()
+    };
     return components;
 }
 export default buildApp;

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, args, event, input, location, lowdefyGlobal, request, state, urlQuery, user }`
+        functionPrototype: `{ actions, args, event, input, location, lowdefyApp, lowdefyGlobal, request, state, urlQuery, user }`
     }));
     await context.writeBuildArtifact('plugins/operators/serverJsMap.js', generateJsFile({
         map: context.jsMap.server,
-        functionPrototype: `{ args, item, payload, secrets, state, step, user }`
+        functionPrototype: `{ args, item, lowdefyApp, payload, secret, state, step, user }`
     }));
 }
 export default writeJs;

package/dist/build/buildMenu.js

@@ -103,6 +103,11 @@ function loopItems({ parent, menuId, pages, missingPageWarnings, checkDuplicateM
                     public: true
                 };
             }
+            if (menuItem.type === 'MenuDivider') {
+                menuItem.auth = {
+                    public: true
+                };
+            }
             checkDuplicateMenuItemId({
                 id: menuItem.id,
                 menuId,

package/dist/build/buildModuleDefs.js

@@ -20,7 +20,7 @@ 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 { resolveLocalManifest, resolveFullManifest, validateRequiredVars } from './registerModules.js';
 import resolveModuleDependencies from './resolveModuleDependencies.js';
 validateOperatorsDynamic({
     operators
@@ -30,6 +30,9 @@ const dynamicIdentifiers = collectDynamicIdentifiers({
 });
 async function parseLowdefyYaml({ context }) {
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
+    // Stash for Phase 2.5 — consumer vars come from lowdefy.yaml, so refs
+    // within them must be parented to lowdefy.yaml's refDef.
+    context.lowdefyYamlRefDef = refDef;
     const content = await getRefContent({
         context,
         refDef,
@@ -49,6 +52,10 @@ async function parseLowdefyYaml({ context }) {
         env: process.env,
         dynamicIdentifiers,
         shouldStop: (path)=>{
+            // Defer entry vars and connections: they may contain cross-module
+            // refs that require modules to be registered first.
+            if (/^modules\.\d+\.vars$/.test(path)) return 'preserve';
+            if (/^modules\.\d+\.connections$/.test(path)) return 'preserve';
             if (path.startsWith('modules')) return false;
             return 'preserve';
         }
@@ -61,6 +68,42 @@ async function parseLowdefyYaml({ context }) {
     });
     return config ?? {};
 }
+async function resolveEntryConfig({ entry, context }) {
+    const moduleEntry = context.modules[entry.id];
+    const lowdefyYamlRefDef = context.lowdefyYamlRefDef;
+    function makeAppLevelCtx() {
+        return new WalkContext({
+            buildContext: context,
+            refId: lowdefyYamlRefDef.id,
+            sourceRefId: null,
+            vars: {},
+            path: '',
+            currentFile: lowdefyYamlRefDef.path,
+            refChain: new Set(lowdefyYamlRefDef.path ? [
+                lowdefyYamlRefDef.path
+            ] : []),
+            operators,
+            env: process.env,
+            dynamicIdentifiers
+        });
+    }
+    const refDef = lowdefyYamlRefDef;
+    let resolvedVars = await resolve(moduleEntry.consumerVars, makeAppLevelCtx());
+    resolvedVars = evaluateStaticOperators({
+        context,
+        input: resolvedVars,
+        refDef
+    });
+    moduleEntry.consumerVars = resolvedVars ?? {};
+    let resolvedConnections = await resolve(moduleEntry.connections, makeAppLevelCtx());
+    resolvedConnections = evaluateStaticOperators({
+        context,
+        input: resolvedConnections,
+        refDef
+    });
+    moduleEntry.connections = resolvedConnections ?? {};
+    validateRequiredVars(moduleEntry.varDefs, moduleEntry.consumerVars, entry.id, entry.source);
+}
 async function buildModuleDefs({ context }) {
     const lowdefyConfig = await parseLowdefyYaml({
         context
@@ -86,6 +129,14 @@ async function buildModuleDefs({ context }) {
     resolveModuleDependencies({
         context
     });
+    // Step 2.5: Resolve deferred entry vars and connections at app level,
+    // then validate required vars against the resolved values.
+    for (const entry of moduleEntries){
+        await resolveEntryConfig({
+            entry,
+            context
+        });
+    }
     // Step 3: Full resolve — cross-module refs, preserved content
     for (const entryId of Object.keys(context.modules)){
         await resolveFullManifest({

package/dist/build/buildModules.js

@@ -45,7 +45,7 @@ function buildModules({ components, context }) {
         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.`);
+                throw new ConfigError(`Module "${entry.id}" connection remapping references "${remapKey}", ` + `but the module has no connection with that id.`);
             }
         }
         // Validate secret whitelist on non-remapped content

package/dist/build/buildPages/validateCallApiRefs.js

@@ -14,11 +14,20 @@
   limitations under the License.
 */ import { ConfigWarning } from '@lowdefy/errors';
 function validateCallApiRefs({ callApiActionRefs, endpointConfigs, context }) {
+    const existingEndpointIds = new Set(endpointConfigs.map((config)=>config.endpointId));
     const internalEndpoints = new Set(endpointConfigs.filter((config)=>config.type === 'InternalApi').map((config)=>config.endpointId));
     callApiActionRefs.forEach(({ endpointId, action, sourcePageId })=>{
         if (action.skip === true) {
             return;
         }
+        if (!existingEndpointIds.has(endpointId)) {
+            context.handleWarning(new ConfigWarning(`CallAPI action on page "${sourcePageId}" references non-existent endpoint "${endpointId}".`, {
+                configKey: action['~k'],
+                prodError: true,
+                checkSlug: 'callapi-refs'
+            }));
+            return;
+        }
         if (internalEndpoints.has(endpointId)) {
             context.handleWarning(new ConfigWarning(`CallAPI action on page "${sourcePageId}" targets InternalApi endpoint "${endpointId}". InternalApi endpoints are not accessible from client pages.`, {
                 configKey: action['~k'],

package/dist/build/buildRefs/getUserJavascriptFunction.js

@@ -15,20 +15,17 @@
 */ import path from 'path';
 import { pathToFileURL } from 'url';
 import { ConfigError } from '@lowdefy/errors';
-// Create a native import() that survives webpack bundling. When this module is
-// bundled by Next.js webpack for server-dev API routes, webpack transforms
-// import() into __webpack_require__() which can't handle file:// URLs for
-// loading user-provided resolver and transformer JS files from the config
-// directory. The Function constructor creates the import call at runtime,
-// bypassing webpack's static analysis.
-const nativeImport = new Function('specifier', 'return import(specifier)');
 async function getUserJavascriptFunction({ context, filePath }) {
     try {
-        const fileUrl = pathToFileURL(path.join(context.directories.config, filePath));
+        const fileUrl = pathToFileURL(path.resolve(context.directories.config, filePath));
         // Bust Node.js module cache so edits to resolver/transformer JS files are
         // picked up during dev rebuilds. Each import gets a unique URL.
         fileUrl.searchParams.set('t', Date.now());
-        return (await nativeImport(fileUrl.href)).default;
+        // webpackIgnore tells Next.js webpack to leave this dynamic import alone
+        // when bundling server-dev API routes — otherwise webpack rewrites import()
+        // into __webpack_require__() which can't handle file:// URLs for loading
+        // user-provided resolver/transformer JS files from the config directory.
+        return (await import(/* webpackIgnore: true */ fileUrl.href)).default;
     } catch (error) {
         throw new ConfigError(`Error importing ${filePath}.`, {
             cause: error,

package/dist/build/buildRefs/runTransformer.js

@@ -14,7 +14,7 @@
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
 import getUserJavascriptFunction from './getUserJavascriptFunction.js';
-async function runTransformer({ context, input, refDef }) {
+async function runTransformer({ context, input, refDef, referencedFrom }) {
     if (refDef.transformer) {
         const transformerFn = await getUserJavascriptFunction({
             context,
@@ -25,7 +25,8 @@ async function runTransformer({ context, input, refDef }) {
         } catch (error) {
             throw new ConfigError(`Error calling transformer "${refDef.transformer}" from "${refDef.path}".`, {
                 cause: error,
-                filePath: refDef.transformer
+                filePath: referencedFrom,
+                lineNumber: refDef.lineNumber
             });
         }
     }

package/dist/build/buildRefs/walker.js

@@ -330,11 +330,6 @@ function resolveModulePageId(arg, moduleEntry, context, configKey) {
                 configKey
             });
         }
-        if (!(moduleEntry.exports?.pages ?? []).some((p)=>p.id === arg)) {
-            throw new ConfigError(`Module "${moduleEntry.id}" does not export page "${arg}".`, {
-                configKey
-            });
-        }
         return `${moduleEntry.id}/${arg}`;
     }
     if (type.isObject(arg) && type.isString(arg.id) && type.isString(arg.module)) {
@@ -345,12 +340,6 @@ function resolveModulePageId(arg, moduleEntry, context, configKey) {
             configKey,
             usage: `_module.pageId { id: "${arg.id}", module: "${arg.module}" }`
         });
-        if (!(targetEntry.exports?.pages ?? []).some((p)=>p.id === arg.id)) {
-            const caller = moduleEntry ? `Module "${moduleEntry.id}"` : 'App config';
-            throw new ConfigError(`${caller} references page "${arg.id}" ` + `from "${arg.module}" (entry "${targetEntry.id}"), ` + `but that module does not export page "${arg.id}".`, {
-                configKey
-            });
-        }
         return `${targetEntry.id}/${arg.id}`;
     }
     throw new ConfigError('_module.pageId requires a string or object { id, module }.', {
@@ -365,11 +354,6 @@ function resolveModuleConnectionId(arg, moduleEntry, context, configKey) {
                 configKey
             });
         }
-        if (!(moduleEntry.exports?.connections ?? []).some((c)=>c.id === arg)) {
-            throw new ConfigError(`Module "${moduleEntry.id}" does not export connection "${arg}".`, {
-                configKey
-            });
-        }
         const remapping = moduleEntry.connections ?? {};
         if (remapping[arg]) {
             return remapping[arg];
@@ -384,12 +368,6 @@ function resolveModuleConnectionId(arg, moduleEntry, context, configKey) {
             configKey,
             usage: `_module.connectionId { id: "${arg.id}", module: "${arg.module}" }`
         });
-        if (!(targetEntry.exports?.connections ?? []).some((c)=>c.id === arg.id)) {
-            const caller = moduleEntry ? `Module "${moduleEntry.id}"` : 'App config';
-            throw new ConfigError(`${caller} references connection "${arg.id}" ` + `from "${arg.module}" (entry "${targetEntry.id}"), ` + `but that module does not export connection "${arg.id}".`, {
-                configKey
-            });
-        }
         const targetRemapping = targetEntry.connections ?? {};
         if (targetRemapping[arg.id]) {
             return targetRemapping[arg.id];
@@ -408,11 +386,6 @@ function resolveModuleEndpointId(arg, moduleEntry, context, configKey) {
                 configKey
             });
         }
-        if (!(moduleEntry.exports?.api ?? []).some((e)=>e.id === arg)) {
-            throw new ConfigError(`Module "${moduleEntry.id}" does not export endpoint "${arg}".`, {
-                configKey
-            });
-        }
         return `${moduleEntry.id}/${arg}`;
     }
     if (type.isObject(arg) && type.isString(arg.id) && type.isString(arg.module)) {
@@ -423,12 +396,6 @@ function resolveModuleEndpointId(arg, moduleEntry, context, configKey) {
             configKey,
             usage: `_module.endpointId { id: "${arg.id}", module: "${arg.module}" }`
         });
-        if (!(targetEntry.exports?.api ?? []).some((e)=>e.id === arg.id)) {
-            const caller = moduleEntry ? `Module "${moduleEntry.id}"` : 'App config';
-            throw new ConfigError(`${caller} references endpoint "${arg.id}" ` + `from "${arg.module}" (entry "${targetEntry.id}"), ` + `but that module does not export endpoint "${arg.id}".`, {
-                configKey
-            });
-        }
         return `${targetEntry.id}/${arg.id}`;
     }
     throw new ConfigError('_module.endpointId requires a string or object { id, module }.', {
@@ -503,8 +470,16 @@ async function resolveRef(node, ctx) {
         refDef.key = await resolve(cloneForResolve(refDef.key), ctx);
     }
     // 4. Module path resolution: resolve relative paths from the module root
-    if (ctx.moduleRoot && type.isString(refDef.path) && !path.isAbsolute(refDef.path)) {
-        refDef.path = path.resolve(ctx.moduleRoot, refDef.path);
+    if (ctx.moduleRoot) {
+        if (type.isString(refDef.path) && !path.isAbsolute(refDef.path)) {
+            refDef.path = path.resolve(ctx.moduleRoot, refDef.path);
+        }
+        if (type.isString(refDef.resolver) && !path.isAbsolute(refDef.resolver)) {
+            refDef.resolver = path.resolve(ctx.moduleRoot, refDef.resolver);
+        }
+        if (type.isString(refDef.transformer) && !path.isAbsolute(refDef.transformer)) {
+            refDef.transformer = path.resolve(ctx.moduleRoot, refDef.transformer);
+        }
     }
     // 5. Update refMap with resolved path; store original for resolver refs
     ctx.refMap[refDef.id].path = refDef.path;
@@ -512,9 +487,16 @@ async function resolveRef(node, ctx) {
         ctx.refMap[refDef.id].original = refDef.original;
     }
     // 6. Path escape constraint: module refs cannot escape the package root
-    if (ctx.packageRoot && refDef.path) {
-        if (!refDef.path.startsWith(ctx.packageRoot + '/') && refDef.path !== ctx.packageRoot) {
-            throw new ConfigError(`Module ref path "${refDef.path}" escapes the package root.`);
+    if (ctx.packageRoot) {
+        for (const field of [
+            'path',
+            'resolver',
+            'transformer'
+        ]){
+            const value = refDef[field];
+            if (type.isString(value) && !value.startsWith(ctx.packageRoot + '/') && value !== ctx.packageRoot) {
+                throw new ConfigError(`Module ref ${field} "${value}" escapes the package root.`);
+            }
         }
     }
     // 7. Circular detection
@@ -628,7 +610,8 @@ async function resolveRef(node, ctx) {
         content = await runTransformer({
             context: ctx.buildContext,
             input: content,
-            refDef
+            refDef,
+            referencedFrom: ctx.currentFile
         });
         // 14. Extract key
         content = getKey({

package/dist/build/codegenI18nLocales.js

@@ -0,0 +1,53 @@
+/*
+  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';
+const HEADER = `// Generated by @lowdefy/build. Do not edit.\n`;
+const SAFE_IDENTIFIER_REGEX = /^[A-Za-z0-9_-]+$/;
+function isSafeIdentifier(value) {
+    return type.isString(value) && SAFE_IDENTIFIER_REGEX.test(value);
+}
+function buildAntdLoaders(locales) {
+    const entries = locales.filter((locale)=>isSafeIdentifier(locale.code) && isSafeIdentifier(locale.antd)).map((locale)=>`  '${locale.code}': () => import('antd/locale/${locale.antd}.js').then((m) => m.default ?? m),`);
+    return `${HEADER}const loaders = {\n${entries.join('\n')}\n};\nexport default loaders;\n`;
+}
+function buildDayjsImports(locales) {
+    const validDayjsLocales = locales.filter((locale)=>isSafeIdentifier(locale.code) && isSafeIdentifier(locale.dayjs));
+    const ids = Array.from(new Set(validDayjsLocales.map((locale)=>locale.dayjs)));
+    const imports = ids.map((id)=>`import 'dayjs/locale/${id}.js';`).join('\n');
+    const localeMap = validDayjsLocales.map((locale)=>`  '${locale.code}': '${locale.dayjs}',`).join('\n');
+    return `${HEADER}${imports}\nconst localeMap = {\n${localeMap}\n};\nexport default localeMap;\n`;
+}
+// antd X (@ant-design/x@2.7.x) only ships two locale packs: en_US and zh_CN.
+// Other locales fall back to en_US for X-native strings (New chat, OK/Cancel,
+// Stop loading, Like/Dislike, etc.). App authors override per-locale via
+// config.i18n.messages.{locale}.agent.antdx.* keys handled outside this codegen.
+const ANTD_X_SUPPORTED = new Set([
+    'en_US',
+    'zh_CN'
+]);
+function buildAntdXLoaders(locales) {
+    const entries = locales.filter((locale)=>isSafeIdentifier(locale.code) && isSafeIdentifier(locale.antd)).map((locale)=>{
+        const pack = ANTD_X_SUPPORTED.has(locale.antd) ? locale.antd : 'en_US';
+        return `  '${locale.code}': () => import('@ant-design/x/locale/${pack}.js').then((m) => m.default ?? m),`;
+    });
+    return `${HEADER}const loaders = {\n${entries.join('\n')}\n};\nexport default loaders;\n`;
+}
+async function codegenI18nLocales({ components, context }) {
+    const locales = components.config?.i18n?.locales ?? [];
+    await context.writeBuildArtifact('i18n/antdLocales.js', buildAntdLoaders(locales));
+    await context.writeBuildArtifact('i18n/antdXLocales.js', buildAntdXLoaders(locales));
+    await context.writeBuildArtifact('i18n/dayjsLocales.js', buildDayjsImports(locales));
+}
+export default codegenI18nLocales;

package/dist/build/jit/shallowBuild.js

@@ -38,6 +38,7 @@ import copyPublicFolder from '../copyPublicFolder.js';
 import testSchema from '../testSchema.js';
 import validateConfig from '../validateConfig.js';
 import writeApp from '../writeApp.js';
+import writeAppMeta from '../writeAppMeta.js';
 import writeAuth from '../writeAuth.js';
 import writeConfig from '../writeConfig.js';
 import writeConnections from '../writeConnections.js';
@@ -46,6 +47,8 @@ import writeApi from '../writeApi.js';
 import writeGlobal from '../writeGlobal.js';
 import writeJs from '../buildJs/writeJs.js';
 import writeLogger from '../writeLogger.js';
+import codegenI18nLocales from '../codegenI18nLocales.js';
+import writeI18n from '../writeI18n.js';
 import writeTheme from '../writeTheme.js';
 import writeMaps from '../writeMaps.js';
 import updateServerPackageJson from '../full/updateServerPackageJson.js';
@@ -202,6 +205,10 @@ async function shallowBuild(options) {
             components,
             context
         });
+        await writeAppMeta({
+            components,
+            context
+        });
         await writeAuth({
             components,
             context
@@ -230,6 +237,14 @@ async function shallowBuild(options) {
             components,
             context
         });
+        await writeI18n({
+            components,
+            context
+        });
+        await codegenI18nLocales({
+            components,
+            context
+        });
         await writeLogger({
             components,
             context
@@ -253,6 +268,7 @@ async function shallowBuild(options) {
         await context.writeBuildArtifact('jsMap.json', JSON.stringify(context.jsMap));
         await context.writeBuildArtifact('idCounter.json', JSON.stringify(makeId.counter));
         await context.writeBuildArtifact('customTypesMap.json', JSON.stringify(options.customTypesMap ?? {}));
+        await context.writeBuildArtifact('customMessagesMap.json', JSON.stringify(options.customMessagesMap ?? {}));
         // Persist snapshot of installed packages for JIT missing-package detection.
         // Written as a build artifact so JIT builds compare against the skeleton
         // build state, not a potentially-updated package.json (race condition).

package/dist/build/registerModules.js

@@ -122,38 +122,12 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
             throw new ConfigError(`Module "${entry.id}": each item in "dependencies" must have a string "id".`);
         }
     }
-    // Parse exports object from manifest
-    const rawExports = manifest.exports ?? {};
-    const exportSections = [
-        'pages',
-        'components',
-        'menus',
-        'connections',
-        'api'
-    ];
-    const exports = {};
-    for (const section of exportSections){
-        const items = rawExports[section] ?? [];
-        if (!type.isArray(items)) {
-            throw new ConfigError(`Module "${entry.id}": exports.${section} must be an array.`);
-        }
-        for (const item of items){
-            if (!type.isString(item.id)) {
-                throw new ConfigError(`Module "${entry.id}": each item in exports.${section} must have a string "id".`);
-            }
-        }
-        exports[section] = items;
-    }
-    // Reject unknown keys in exports
-    for (const key of Object.keys(rawExports)){
-        if (!exportSections.includes(key)) {
-            throw new ConfigError(`Module "${entry.id}": unknown exports section "${key}". ` + `Valid sections: ${exportSections.join(', ')}.`);
-        }
-    }
-    // Validate required vars without defaults (needs raw defs + consumer values only).
-    // Type validation moves to after Phase 2 because defaults are resolved lazily.
+    // Capture var definitions for the registered module entry.
+    // Required-var validation is deferred to Phase 2.5 (buildModuleDefs.js)
+    // because entry.vars may contain unresolved _refs at this point.
+    // Type validation runs at the end of Phase 3 against the lazily-populated
+    // resolvedVarCache.
     const varDefs = manifest.vars ?? {};
-    validateRequiredVars(varDefs, entry.vars ?? {}, entry.id, entry.source);
     // Validate plugin dependencies against app's declared plugins
     const requiredPlugins = manifest.plugins ?? [];
     for (const plugin of requiredPlugins){
@@ -189,7 +163,6 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
         connections: entry.connections ?? {},
         manifest,
         dependencies,
-        exports,
         moduleDependencies: entry.dependencies ?? {},
         refDef
     };
@@ -244,4 +217,4 @@ async function resolveFullManifest({ entryId, context }) {
         validateVarTypes(varDefs, moduleEntry.resolvedVarCache, entryId, moduleEntry.source);
     }
 }
-export { resolveLocalManifest, resolveFullManifest };
+export { resolveLocalManifest, resolveFullManifest, validateRequiredVars };

package/dist/build/writeAppMeta.js

@@ -0,0 +1,19 @@
+/*
+  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 { serializer } from '@lowdefy/helpers';
+async function writeAppMeta({ components, context }) {
+    await context.writeBuildArtifact('appMeta.json', serializer.serializeToString(components.appMeta));
+}
+export default writeAppMeta;