@lowdefy/build 5.5.1 → 6.0.0

package/dist/build/jit/writePageJit.js

@@ -14,10 +14,9 @@
   limitations under the License.
 */ import path from 'path';
 import { serializer, type } from '@lowdefy/helpers';
-import { writeFile } from '@lowdefy/node-utils';
-import collectPageContent from '../collectPageContent.js';
+import { writeFileIfChanged } from '@lowdefy/node-utils';
 import writeJs from '../buildJs/writeJs.js';
-async function writePageJit({ page, context }) {
+async function writePageJit({ page, context, tailwindContent }) {
     // Write page JSON
     await context.writeBuildArtifact(`pages/${page.pageId}.json`, serializer.serializeToString(page ?? {}));
     // Write page request JSONs
@@ -43,10 +42,14 @@ async function writePageJit({ page, context }) {
     await writeJs({
         context
     });
-    // Write per-page content file for Tailwind to scan class and property strings
-    const pageContent = collectPageContent([
-        page
-    ]);
-    await writeFile(path.join(context.directories.server, 'lowdefy-build', 'tailwind', `${encodeURIComponent(page.pageId)}.html`), '<!-- Generated by Lowdefy build -->\n' + (pageContent ?? ''));
+    // Write per-page content file for Tailwind to scan class and property strings.
+    // Content is collected by the caller before _js extraction so class
+    // candidates inside _js source are included. Skipping unchanged content lets
+    // the caller avoid touching the CSS recompilation trigger
+    // (tailwind-candidates.css) for builds that introduced no new class candidates.
+    const tailwindChanged = await writeFileIfChanged(path.join(context.directories.server, 'lowdefy-build', 'tailwind', `${encodeURIComponent(page.pageId)}.html`), '<!-- Generated by Lowdefy build -->\n' + (tailwindContent ?? ''));
+    return {
+        tailwindChanged
+    };
 }
 export default writePageJit;

package/dist/build/registerModules.js

@@ -14,15 +14,15 @@
   limitations under the License.
 */ import path from 'path';
 import semver from 'semver';
-import { type } from '@lowdefy/helpers';
+import { ReservedKeyError, setKey, type } from '@lowdefy/helpers';
 import { ConfigError } from '@lowdefy/errors';
 import operators from '@lowdefy/operators-js/operators/build';
 import { resolve, WalkContext } from './buildRefs/walker.js';
 import getRefContent from './buildRefs/getRefContent.js';
 import makeRefDefinition from './buildRefs/makeRefDefinition.js';
-import evaluateStaticOperators from './buildRefs/evaluateStaticOperators.js';
 import collectDynamicIdentifiers from './collectDynamicIdentifiers.js';
 import validateOperatorsDynamic from './validateOperatorsDynamic.js';
+import { makeShouldStop } from './buildRefs/deferredRegions.js';
 validateOperatorsDynamic({
     operators
 });
@@ -48,11 +48,69 @@ function validateRequiredVars(varDefs, consumerVars, entryId, source, prefix = '
         }
     }
 }
+function getRuntimeOperatorKey(value) {
+    if (!type.isObject(value)) return null;
+    const nonTildeKeys = Object.keys(value).filter((k)=>!k.startsWith('~'));
+    if (nonTildeKeys.length === 1 && nonTildeKeys[0].startsWith('_')) return nonTildeKeys[0];
+    return null;
+}
+function suggestBuildOperator(operatorKey) {
+    // '_string.concat' -> '_build.string.concat', '_sum' -> '_build.sum'
+    return `_build.${operatorKey.slice(1)}`;
+}
+// Component bodies are preserved by config path (components.<i>.component), so
+// bodies under an operator object at `components` itself or at an array element
+// escape preservation and resolve eagerly during the manifest walk. That is
+// harmless for static bodies (operator-composed component lists are supported —
+// pinned by fixture 81-cross-module-build-op-components), but a _var in such a
+// body resolves against the manifest walk's scope instead of the consumer's
+// per-ref vars — a silently wrong value. Error on that combination explicitly.
+// A _ref at either position is fully safe: it resolves top-down, so paths
+// inside the ref'd file still match the preserve regex. An operator at
+// components.<i>.component itself is inside the preserved body and is fine.
+function findVarNode(value) {
+    if (type.isArray(value)) {
+        for (const item of value){
+            const found = findVarNode(item);
+            if (found) return found;
+        }
+        return null;
+    }
+    if (!type.isObject(value)) return null;
+    if (getRuntimeOperatorKey(value) === '_var') return value;
+    for (const key of Object.keys(value)){
+        const found = findVarNode(value[key]);
+        if (found) return found;
+    }
+    return null;
+}
+function assertStaticComponentsList({ components, entryId, filePath }) {
+    if (!type.isObject(components) && !type.isArray(components)) return;
+    const check = (value, position)=>{
+        const operatorKey = getRuntimeOperatorKey(value);
+        if (operatorKey && operatorKey !== '_ref' && findVarNode(value)) {
+            throw new ConfigError(`Module "${entryId}": _var inside an operator-generated components section ` + `cannot resolve per consumer. Found "${operatorKey}" at ${position} with a _var ` + `in its content. Define components whose bodies use _var as static ` + `{ id, component } list items so the bodies are preserved.`, {
+                filePath
+            });
+        }
+    };
+    check(components, '"components"');
+    if (type.isArray(components)) {
+        components.forEach((item, i)=>check(item, `"components.${i}"`));
+    }
+}
 function validateVarTypes(varDefs, resolvedVarCache, entryId, source, prefix = '') {
     for (const [varName, varDef] of Object.entries(varDefs)){
         const fullName = prefix ? `${prefix}.${varName}` : varName;
         const value = resolvedVarCache[fullName];
         if (varDef.type && !type.isNone(value)) {
+            // A typed var must hold a concrete value — runtime operators are not allowed
+            // regardless of whether they are static-foldable or dynamic. Suggest the
+            // build-time equivalent so the user knows how to fix it.
+            const operatorKey = getRuntimeOperatorKey(value);
+            if (operatorKey) {
+                throw new ConfigError(`Module "${entryId}" (${source}) var "${fullName}" is typed "${varDef.type}" ` + `but received a runtime operator "${operatorKey}". ` + `Use the build-time equivalent "${suggestBuildOperator(operatorKey)}" instead.` + (varDef.description ? `\n  - ${varDef.description}` : ''));
+            }
             if (type.typeOf(value) !== varDef.type) {
                 throw new ConfigError(`Module "${entryId}" (${source}) var "${fullName}" must be type ` + `"${varDef.type}" but got "${type.typeOf(value)}".` + (varDef.description ? `\n  - ${varDef.description}` : ''));
             }
@@ -69,9 +127,6 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
     if (entry.id.includes('/')) {
         throw new ConfigError(`Module entry id "${entry.id}" must not contain '/'. ` + `Use a flat identifier like "team-users".`);
     }
-    if (entry.id === '__proto__' || entry.id === 'constructor' || entry.id === 'prototype') {
-        throw new ConfigError(`Module entry id "${entry.id}" is a reserved name.`);
-    }
     if (!entry.source || !type.isString(entry.source)) {
         throw new ConfigError(`Module entry "${entry.id}": 'source' is required and must be a string.`);
     }
@@ -88,7 +143,17 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
         refDef,
         referencedFrom: null
     });
-    // Run walker with shouldStop preserving content that may contain cross-module refs
+    if (type.isObject(content)) {
+        assertStaticComponentsList({
+            components: content.components,
+            entryId: entry.id,
+            filePath: moduleYamlPath
+        });
+    }
+    // Phase A — header parse: walk only the static header keys (dependencies,
+    // plugins, secrets, vars definitions — defaults record-ified). Content
+    // sections stay raw parsed YAML; Phase C.5 record-ifies exportables and
+    // Phase D resolves the rest.
     const ctx = new WalkContext({
         buildContext: context,
         refId: refDef.id,
@@ -96,6 +161,9 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
         vars: {},
         moduleRoot,
         packageRoot,
+        // The entry object is created after this walk; deferred-record coordinates
+        // still need the owning entry id.
+        entryId: entry.id,
         path: '',
         currentFile: moduleYamlPath,
         refChain: new Set(refDef.path ? [
@@ -103,16 +171,9 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
         ] : []),
         operators,
         env: process.env,
+        lowdefyApp: context.appMeta,
         dynamicIdentifiers,
-        shouldStop: (childPath)=>{
-            if (/^vars(\.[^.]+\.properties)*\.[^.]+\.default(\..*)?$/.test(childPath)) return 'preserve';
-            if (/^components\.\d+\.component$/.test(childPath)) return 'preserve';
-            if (/^pages(\..*)?$/.test(childPath)) return 'preserve';
-            if (/^api(\..*)?$/.test(childPath)) return 'preserve';
-            if (/^connections(\..*)?$/.test(childPath)) return 'preserve';
-            if (/^menus\.\d+\.links$/.test(childPath)) return 'preserve';
-            return false;
-        }
+        shouldStop: makeShouldStop('header')
     });
     const manifest = await resolve(content, ctx);
     // Parse dependencies array from manifest
@@ -151,22 +212,74 @@ async function resolveLocalManifest({ entry, resolvedPaths, context }) {
             throw new ConfigError(`Module "${entry.id}" requires plugin "${plugin.name}" version "${plugin.version}" ` + `but the app has version "${appVersion}" installed. ` + `Update the plugin to a compatible version.`);
         }
     }
-    context.modules[entry.id] = {
-        id: entry.id,
-        source: entry.source,
-        packageRoot,
+    try {
+        setKey(context.modules, entry.id, {
+            id: entry.id,
+            source: entry.source,
+            packageRoot,
+            moduleRoot,
+            isLocal,
+            consumerVars: entry.vars ?? {},
+            varDefs,
+            resolvedVarCache: {},
+            connections: entry.connections ?? {},
+            manifest,
+            dependencies,
+            moduleDependencies: entry.dependencies ?? {},
+            refDef
+        });
+    } catch (error) {
+        if (error instanceof ReservedKeyError) {
+            throw new ConfigError(`Module entry id "${entry.id}" is a reserved name.`, {
+                cause: error
+            });
+        }
+        throw error;
+    }
+}
+// Phase C.5 — record-ify exportables: walk only the components and menus
+// sections in module-static scope (entry id known, but NO moduleEntry on the
+// context — a _module.var at a structural position errors, because export ids
+// must not vary per consumer). File refs are entered and static operators
+// resolve; component bodies and menu links become records before any phase can
+// consume them, so cross-entry consumption never races record creation.
+async function recordifyExportables({ entryId, context }) {
+    const moduleEntry = context.modules[entryId];
+    const { manifest, packageRoot, moduleRoot, refDef } = moduleEntry;
+    const moduleYamlPath = path.join(moduleRoot, 'module.lowdefy.yaml');
+    if (type.isObject(manifest)) {
+        assertStaticComponentsList({
+            components: manifest.components,
+            entryId,
+            filePath: moduleYamlPath
+        });
+    }
+    const ctx = new WalkContext({
+        buildContext: context,
+        refId: refDef.id,
+        sourceRefId: null,
+        vars: {},
         moduleRoot,
-        isLocal,
-        consumerVars: entry.vars ?? {},
-        varDefs,
-        resolvedVarCache: {},
-        connections: entry.connections ?? {},
-        manifest,
-        dependencies,
-        moduleDependencies: entry.dependencies ?? {},
-        refDef
-    };
+        packageRoot,
+        entryId,
+        path: '',
+        currentFile: moduleYamlPath,
+        refChain: new Set(refDef.path ? [
+            refDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        lowdefyApp: context.appMeta,
+        dynamicIdentifiers,
+        shouldStop: makeShouldStop('exportables')
+    });
+    moduleEntry.manifest = await resolve(manifest, ctx);
 }
+// Phase D — manifest resolve: ONE full walk with the module entry in context.
+// Pages, api, and connections resolve completely; component/menuLinks
+// placeholders pass through the kind-aware dispatch untouched; varDefault
+// placeholders keep their rule so the dispatch cannot force demand-only
+// records.
 async function resolveFullManifest({ entryId, context }) {
     const moduleEntry = context.modules[entryId];
     const { manifest, packageRoot, moduleRoot, moduleDependencies, refDef } = moduleEntry;
@@ -187,24 +300,18 @@ async function resolveFullManifest({ entryId, context }) {
         ] : []),
         operators,
         env: process.env,
+        lowdefyApp: context.appMeta,
         dynamicIdentifiers,
-        shouldStop: (childPath)=>{
-            if (/^vars(\.[^.]+\.properties)*\.[^.]+\.default(\..*)?$/.test(childPath)) return 'preserve';
-            if (/^components\.\d+\.component$/.test(childPath)) return 'preserve';
-            return false;
-        }
-    });
-    let resolved = await resolve(manifest, ctx);
-    resolved = evaluateStaticOperators({
-        context,
-        input: resolved,
-        refDef
+        shouldStop: makeShouldStop('manifest')
     });
+    const resolved = await resolve(manifest, ctx);
     // Filter null entries produced by _ref resolution failures
     for (const key of [
         'pages',
         'connections',
-        'api'
+        'api',
+        'agents',
+        'notifications'
     ]){
         if (type.isArray(resolved[key])) {
             resolved[key] = resolved[key].filter((item)=>!type.isNone(item));
@@ -217,4 +324,4 @@ async function resolveFullManifest({ entryId, context }) {
         validateVarTypes(varDefs, moduleEntry.resolvedVarCache, entryId, moduleEntry.source);
     }
 }
-export { resolveLocalManifest, resolveFullManifest, validateRequiredVars };
+export { resolveLocalManifest, recordifyExportables, resolveFullManifest, validateRequiredVars };

package/dist/build/validateCallAgentSteps.js

@@ -0,0 +1,58 @@
+/*
+  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, ConfigWarning } from '@lowdefy/errors';
+function collectCallAgentSteps(routine, steps) {
+    if (type.isArray(routine)) {
+        routine.forEach((item)=>collectCallAgentSteps(item, steps));
+        return;
+    }
+    if (type.isObject(routine)) {
+        if (routine.type === 'CallAgent') {
+            steps.push(routine);
+        }
+        // Recurse into all values (handles control structures like :then, :else, :try, :catch)
+        Object.values(routine).forEach((value)=>collectCallAgentSteps(value, steps));
+    }
+}
+// Runs after buildAgents (needs context.agentIds and normalized agent.tools).
+// Validates that CallAgent steps with a static agentId reference an existing
+// agent, and warns when that agent has confirm tools — headless runs have no
+// client to resolve an approval, so those tools auto-execute. Operator
+// (dynamic) agentIds are skipped; they resolve at runtime.
+function validateCallAgentSteps({ components, context }) {
+    (components.api ?? []).forEach((endpoint)=>{
+        const steps = [];
+        collectCallAgentSteps(endpoint.routine, steps);
+        steps.forEach((step)=>{
+            const agentId = step.properties?.agentId;
+            if (!type.isString(agentId)) return;
+            if (!context.agentIds?.has(agentId)) {
+                throw new ConfigError(`CallAgent step "${step.stepId}" at endpoint "${endpoint.endpointId}" references agent "${agentId}" which does not exist.`, {
+                    configKey: step['~k']
+                });
+            }
+            const agent = (components.agents ?? []).find((a)=>a.agentId === agentId);
+            const hasConfirmTools = (agent?.tools ?? []).some((t)=>t.confirm);
+            if (hasConfirmTools) {
+                context.handleWarning(new ConfigWarning(`Agent "${agentId}" has tools with confirm: true, but tool approval is not supported when run from a CallAgent step. Tools will auto-execute.`, {
+                    configKey: step['~k']
+                }));
+            }
+        });
+    });
+    return components;
+}
+export default validateCallAgentSteps;

package/dist/build/validateConfig.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 validateCronConfig from './validateCronConfig.js';
 function validateConfig({ components }) {
     if (type.isNone(components.config)) {
         components.config = {};
@@ -25,6 +26,9 @@ function validateConfig({ components }) {
             throw new Error('Base path must start with "/".');
         }
     }
+    validateCronConfig({
+        components
+    });
     return components;
 }
 export default validateConfig;

package/dist/build/validateCronConfig.js

@@ -0,0 +1,110 @@
+/*
+  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 } from '@lowdefy/errors';
+import getCronEnvironmentNames from '../utils/getCronEnvironmentNames.js';
+// Environment names become a path segment (/api/cron-forward/<environment>/<endpointId>).
+const environmentNamePattern = /^[A-Za-z0-9\-_]+$/;
+function isAbsoluteHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    } catch  {
+        return false;
+    }
+}
+// Returns true when the environment is forwarded to (has a url), false for the host environment.
+function validateCronEnvironment({ name, environment, configKey }) {
+    if (name === 'default') {
+        throw new ConfigError('Cron environment name "default" is reserved: it names the schedules every environment inherits.', {
+            configKey
+        });
+    }
+    if (!environmentNamePattern.test(name)) {
+        throw new ConfigError(`Cron environment name "${name}" is invalid. Environment names must only contain A-Z, a-z, 0-9, "-" and "_".`, {
+            configKey
+        });
+    }
+    if (!type.isObject(environment)) {
+        throw new ConfigError(`Cron environment "${name}" is not an object.`, {
+            received: environment,
+            configKey
+        });
+    }
+    if (!type.isUndefined(environment.enabled) && !type.isBoolean(environment.enabled)) {
+        throw new ConfigError(`Cron environment "${name}" enabled is not a boolean.`, {
+            received: environment.enabled,
+            configKey: environment['~k'] ?? configKey
+        });
+    }
+    if (type.isUndefined(environment.url)) {
+        if (!type.isUndefined(environment.secret)) {
+            throw new ConfigError(`Cron environment "${name}" has a secret but no url. The environment without a url is the deployment that runs the crons and needs no secret.`, {
+                configKey: environment['~k'] ?? configKey
+            });
+        }
+        return false;
+    }
+    if (!type.isString(environment.url) || !isAbsoluteHttpUrl(environment.url)) {
+        throw new ConfigError(`Cron environment "${name}" url is not an absolute http(s) URL, e.g. "https://staging.example.com".`, {
+            received: environment.url,
+            configKey: environment['~k'] ?? configKey
+        });
+    }
+    if (!type.isString(environment.secret) || environment.secret === '') {
+        throw new ConfigError(`Cron environment "${name}" has a url but no secret. Set secret to the Lowdefy secret name that holds the environment's CRON_SECRET.`, {
+            received: environment.secret,
+            configKey: environment['~k'] ?? configKey
+        });
+    }
+    return true;
+}
+// Validates config.cron: the deployment environments scheduled endpoints run in. Exactly one
+// environment has no url — the deployment whose crons Vercel fires — and every other environment
+// is forwarded to from there, so it needs a url and the secret that authorizes the forwarded call.
+function validateCronConfig({ components }) {
+    const cron = components.config.cron;
+    if (type.isUndefined(cron)) return;
+    const configKey = cron['~k'] ?? components.config['~k'];
+    if (!type.isObject(cron)) {
+        throw new ConfigError('lowdefy.config.cron is not an object.', {
+            received: cron,
+            configKey
+        });
+    }
+    if (!type.isObject(cron.environments)) {
+        throw new ConfigError('lowdefy.config.cron.environments is not an object.', {
+            received: cron.environments,
+            configKey
+        });
+    }
+    const names = getCronEnvironmentNames(cron.environments);
+    if (names.length === 0) {
+        throw new ConfigError('lowdefy.config.cron.environments declares no environments.', {
+            configKey
+        });
+    }
+    const hosts = names.filter((name)=>!validateCronEnvironment({
+            name,
+            environment: cron.environments[name],
+            configKey
+        }));
+    if (hosts.length !== 1) {
+        throw new ConfigError(`Exactly one environment in lowdefy.config.cron.environments must have no url (the deployment that runs the crons). Received ${JSON.stringify(hosts)}.`, {
+            configKey
+        });
+    }
+}
+export default validateCronConfig;

package/dist/build/validateRenderNotificationSteps.js

@@ -0,0 +1,50 @@
+/*
+  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 } from '@lowdefy/errors';
+function collectRenderNotificationSteps(routine, steps) {
+    if (type.isArray(routine)) {
+        routine.forEach((item)=>collectRenderNotificationSteps(item, steps));
+        return;
+    }
+    if (type.isObject(routine)) {
+        if (routine.type === 'RenderNotification') {
+            steps.push(routine);
+        }
+        // Recurse into all values (handles control structures like :then, :else, :try, :catch)
+        Object.values(routine).forEach((value)=>collectRenderNotificationSteps(value, steps));
+    }
+}
+// Runs after buildNotifications (needs context.notificationIds). Validates that
+// RenderNotification steps with a static notificationId reference an existing
+// notification. Operator (dynamic) notificationIds are skipped; they resolve at
+// runtime.
+function validateRenderNotificationSteps({ components, context }) {
+    (components.api ?? []).forEach((endpoint)=>{
+        const steps = [];
+        collectRenderNotificationSteps(endpoint.routine, steps);
+        steps.forEach((step)=>{
+            const notificationId = step.properties?.notificationId;
+            if (!type.isString(notificationId)) return;
+            if (!context.notificationIds?.has(notificationId)) {
+                throw new ConfigError(`RenderNotification step "${step.stepId}" at endpoint "${endpoint.endpointId}" references notification "${notificationId}" which does not exist.`, {
+                    configKey: step['~k']
+                });
+            }
+        });
+    });
+    return components;
+}
+export default validateRenderNotificationSteps;

package/dist/build/writeApi.js

@@ -13,9 +13,62 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { type, serializer } from '@lowdefy/helpers';
+import getCronEnvironmentNames from '../utils/getCronEnvironmentNames.js';
 async function writeEndpoint({ endpoint, context }) {
     await context.writeBuildArtifact(`api/${endpoint.endpointId}.json`, serializer.serializeToString(endpoint ?? {}));
 }
+// Flat manifest of every scheduled endpoint, consumed by the Vercel Build Output assembly to
+// generate the `crons` array in config.json. The runtime reads schedules off the endpoint artifact
+// directly, so it does not depend on this file.
+//
+// With config.cron.environments declared there is one entry per enabled environment and schedule:
+// `environment` names it and `forward` is true for environments the production deployment forwards
+// to (those with a url) — Vercel fires crons only on production, so every environment's schedules
+// must be registered there.
+function getSchedules({ endpoint, environment }) {
+    if (type.isArray(endpoint.schedules)) return endpoint.schedules;
+    return endpoint.schedules?.[environment] ?? [];
+}
+function pushSchedules({ endpoint, environment, forward }) {
+    return getSchedules({
+        endpoint,
+        environment
+    }).map((schedule)=>({
+            endpointId: endpoint.endpointId,
+            cron: schedule.cron,
+            payload: schedule.payload ?? {},
+            ...type.isUndefined(environment) ? {} : {
+                environment,
+                forward
+            }
+        }));
+}
+async function writeSchedulesManifest({ components, context }) {
+    const cronEnvironments = components.config?.cron?.environments;
+    const environmentNames = getCronEnvironmentNames(cronEnvironments);
+    const schedules = [];
+    (components.api ?? []).forEach((endpoint)=>{
+        if (environmentNames.length === 0) {
+            schedules.push(...pushSchedules({
+                endpoint
+            }));
+            return;
+        }
+        environmentNames.forEach((environment)=>{
+            const config = cronEnvironments[environment];
+            if (config.enabled === false) return;
+            schedules.push(...pushSchedules({
+                endpoint,
+                environment,
+                forward: !type.isUndefined(config.url)
+            }));
+        });
+    });
+    // Only emit the manifest when something is scheduled; the Vercel assembly treats a missing
+    // schedules.json as "no crons".
+    if (schedules.length === 0) return;
+    await context.writeBuildArtifact('schedules.json', serializer.serializeToString(schedules));
+}
 async function writeApi({ components, context }) {
     if (type.isNone(components.api)) return;
     if (!type.isArray(components.api)) {
@@ -25,6 +78,10 @@ async function writeApi({ components, context }) {
             endpoint,
             context
         }));
-    return Promise.all(writePromises);
+    await Promise.all(writePromises);
+    await writeSchedulesManifest({
+        components,
+        context
+    });
 }
 export default writeApi;

package/dist/build/writeI18n.js

@@ -13,7 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError, ConfigWarning } from '@lowdefy/errors';
-import { mergeObjects, serializer, type } from '@lowdefy/helpers';
+import { isReserved, mergeObjects, serializer, type } from '@lowdefy/helpers';
 function collectPluginMessages({ messagesMap, declaredCodes }) {
     const collected = {};
     Object.values(messagesMap ?? {}).forEach((pluginCatalog)=>{
@@ -57,6 +57,13 @@ async function writeI18n({ components, context }) {
                 configKey: locale?.['~k'] ?? i18n['~k']
             });
         }
+        // The code keys the collected plugin catalog and the merged messages
+        // artifact, both plain objects.
+        if (isReserved(locale.code)) {
+            throw new ConfigError(`Locale code "${locale.code}" in "config.i18n.locales" is a reserved name and cannot be used as a locale code.`, {
+                configKey: locale['~k']
+            });
+        }
         if (codes.has(locale.code)) {
             throw new ConfigError(`Duplicate locale code "${locale.code}" in "config.i18n.locales".`, {
                 configKey: locale['~k']

package/dist/build/writeMcp.js

@@ -0,0 +1,21 @@
+/*
+  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';
+// Always written, even unconfigured - the runtime reads mcp.configured and
+// never needs an existence check on the artifact.
+async function writeMcp({ components, context }) {
+    await context.writeBuildArtifact('mcp.json', serializer.serializeToString(components.mcp));
+}
+export default writeMcp;