@lowdefy/build 5.5.1 → 6.0.0

package/dist/build/buildRefs/buildRefs.js

@@ -16,7 +16,6 @@
 import { resolve, WalkContext } from './walker.js';
 import getRefContent from './getRefContent.js';
 import makeRefDefinition from './makeRefDefinition.js';
-import evaluateStaticOperators from './evaluateStaticOperators.js';
 import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
 import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
 import isPageContentPath from '../jit/isPageContentPath.js';
@@ -30,6 +29,9 @@ const dynamicIdentifiers = collectDynamicIdentifiers({
 async function buildRefs({ context, shallowOptions }) {
     context.unresolvedRefVars = context.unresolvedRefVars ?? {};
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
+    // Stash for Phase 3.5 (precomputeRuntimeOperators) so it can resolve error
+    // source file paths without creating a new makeId entry.
+    context.rootRefDef = refDef;
     const ctx = new WalkContext({
         buildContext: context,
         refId: refDef.id,
@@ -42,24 +44,31 @@ async function buildRefs({ context, shallowOptions }) {
         ] : []),
         operators,
         env: process.env,
+        lowdefyApp: context.appMeta,
         dynamicIdentifiers,
-        shouldStop: shallowOptions ? // JIT can re-resolve them from source files. Inline pages (defined
-        // directly in lowdefy.yaml) live in the root ref and have no separate
-        // source file — their content must be preserved for buildShallowPages.
-        (path, refId)=>isPageContentPath(path) && refId !== refDef.id : null
+        shouldStop: (path, refId)=>{
+            // Module entry vars/connections were already resolved by parseLowdefyYaml
+            // (same predicate) and live on context.modules — preserve the raw blobs so
+            // the app pass doesn't pull and walk their refs a second time. buildModules
+            // reads entry ids only and deletes components.modules before testSchema.
+            if (/^modules\.\d+\.vars$/.test(path)) return 'preserve';
+            if (/^modules\.\d+\.connections$/.test(path)) return 'preserve';
+            if (shallowOptions) {
+                // Strip page content (blocks, events, etc.) from ref-backed pages so
+                // JIT can re-resolve them from source files. Inline pages (defined
+                // directly in lowdefy.yaml) live in the root ref and have no separate
+                // source file — their content must be preserved for buildShallowPages.
+                return isPageContentPath(path) && refId !== refDef.id;
+            }
+            return null;
+        }
     });
     const content = await getRefContent({
         context,
         refDef,
         referencedFrom: null
     });
-    let components = await resolve(content, ctx);
-    // Evaluate static operators (_sum, _if, etc.) that don't depend on runtime data
-    components = evaluateStaticOperators({
-        context,
-        input: components,
-        refDef
-    });
+    const components = await resolve(content, ctx);
     return components ?? {};
 }
 export default buildRefs;

package/dist/build/buildRefs/cloneWithMarkers.js

@@ -0,0 +1,57 @@
+/*
+  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 setNonEnumerableProperty from '../../utils/setNonEnumerableProperty.js';
+// THE deep clone for config subtrees inside buildRefs — preserves the
+// non-enumerable provenance markers (~r ~l ~k ~arr), and with assignRefId set
+// stamps ~r on nodes that have none (pass nothing to preserve the template's
+// existing markers only). Non-plain values (Date) pass by reference; nothing
+// in the build mutates them.
+//
+// Do not use serializer.copy on config subtrees in buildRefs: it round-trips
+// the same markers but pays a JSON round-trip and re-instantiates Dates — the
+// serializer is the artifact boundary, this is the in-memory clone.
+function cloneWithMarkers(value, { assignRefId = null } = {}) {
+    if (!type.isObject(value) && !type.isArray(value)) return value;
+    let clone;
+    if (type.isArray(value)) {
+        clone = value.map((item)=>cloneWithMarkers(item, {
+                assignRefId
+            }));
+    } else {
+        clone = {};
+        for (const key of Object.keys(value)){
+            clone[key] = cloneWithMarkers(value[key], {
+                assignRefId
+            });
+        }
+    }
+    if (value['~r'] !== undefined) {
+        setNonEnumerableProperty(clone, '~r', value['~r']);
+    } else if (assignRefId) {
+        setNonEnumerableProperty(clone, '~r', assignRefId);
+    }
+    for (const marker of [
+        '~l',
+        '~k',
+        '~arr'
+    ]){
+        if (value[marker] !== undefined) {
+            setNonEnumerableProperty(clone, marker, value[marker]);
+        }
+    }
+    return clone;
+}
+export default cloneWithMarkers;

package/dist/build/buildRefs/deferredRegions.js

@@ -0,0 +1,80 @@
+/*
+  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.
+*/ // The single source of truth for which module-manifest regions each build
+// phase defers, records, or skips — one table instead of hand-maintained
+// shouldStop regex sets that must agree.
+//
+// Phases:
+// - 'header'      Phase A: parse static header keys (dependencies, plugins,
+//                 secrets, vars definitions — defaults record-ified); content
+//                 sections stay raw parsed YAML ('skip' = leave raw, do not
+//                 descend).
+// - 'exportables' Phase C.5: record-ify per-consumer bodies (components,
+//                 menu links) in module-static scope; everything else stays
+//                 raw for Phase D.
+// - 'manifest'    Phase D: one full walk; only varDefault placeholders need a
+//                 rule (single-value kinds would otherwise be forced by the
+//                 placeholder dispatch — they are demand-only). Per-consumer
+//                 placeholders pass through the dispatch untouched.
+//
+// entryRef/connRemap creation is value-shape-driven (deferModuleRefs in the
+// walker), not path-driven, so it has no row here. The JIT page-content
+// predicate lives in buildRefs.js (it composes with the app-pass modules
+// preserve and is not a manifest phase).
+const VAR_DEFAULT = /^vars(\.[^.]+\.properties)*\.[^.]+\.default(\..*)?$/;
+const CONTENT_SECTIONS = /^(pages|api|connections|agents|notifications|menus|components)(\..*)?$/;
+const NON_EXPORTABLE_SECTIONS = /^(pages|api|connections|agents|notifications|vars|dependencies|plugins|secrets)(\..*)?$/;
+const DEFERRED_REGIONS = [
+    {
+        phase: 'header',
+        match: VAR_DEFAULT,
+        action: 'record:varDefault'
+    },
+    {
+        phase: 'header',
+        match: CONTENT_SECTIONS,
+        action: 'skip'
+    },
+    {
+        phase: 'exportables',
+        match: /^components\.\d+\.component$/,
+        action: 'record:component'
+    },
+    {
+        phase: 'exportables',
+        match: /^menus\.\d+\.links$/,
+        action: 'record:menuLinks'
+    },
+    {
+        phase: 'exportables',
+        match: NON_EXPORTABLE_SECTIONS,
+        action: 'skip'
+    },
+    {
+        phase: 'manifest',
+        match: VAR_DEFAULT,
+        action: 'record:varDefault'
+    }
+];
+function makeShouldStop(phase) {
+    const rows = DEFERRED_REGIONS.filter((row)=>row.phase === phase);
+    return (childPath)=>{
+        for (const row of rows){
+            if (row.match.test(childPath)) return row.action;
+        }
+        return false;
+    };
+}
+export { DEFERRED_REGIONS, makeShouldStop };

package/dist/build/buildRefs/deferredRegistry.js

@@ -0,0 +1,292 @@
+/*
+  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 { ConfigError, LowdefyInternalError } from '@lowdefy/errors';
+import { serializer, type } from '@lowdefy/helpers';
+// Circular import by design: the walker dispatches placeholders into
+// resolveDeferred, and resolveDeferred walks record bodies. Both modules only
+// reference each other's bindings at call time, after evaluation completes.
+import { loadAndWalkRef, resolve, WalkContext } from './walker.js';
+import cloneWithMarkers from './cloneWithMarkers.js';
+// The deferred-content record registry. Every deferred region of module config
+// becomes a record { kind, body, env, slot } in context.deferred; the config
+// tree holds only an enumerable placeholder { '~deferred': '<id>' }. Records
+// carry the resolution environment explicitly instead of reconstructing it
+// from in-tree markers — the placeholder is plain data that survives every
+// clone, serializer.copy, and JSON round-trip to JIT.
+//
+// Record kinds:
+// - 'component' / 'menuLinks': resolved per consumer (per-ref vars differ) —
+//   no promise memo, no write-back; placeholders persist in manifests.
+// - 'varDefault' / 'entryRef': single-value, resolved on demand and
+//   promise-memoized per record (resolveDeferred; lands with the wait-graph).
+//
+// Resolution state (promise, waitingOn, done, value) is runtime-only and never
+// serialized; JIT re-derives it empty.
+const DEFERRED_KEY = '~deferred';
+// Record ids derive from the creation site's stable coordinates, never a
+// counter — the walker resolves siblings with Promise.all, so creation order
+// is nondeterministic, and ids leak into build artifacts.
+function makeRecordId({ entryId, configPath }) {
+    return `${entryId ?? 'app'}:${configPath}`;
+}
+function createRecord(context, { id, kind, body, env, slot = null }) {
+    var _context;
+    (_context = context).deferred ?? (_context.deferred = {});
+    if (Object.hasOwn(context.deferred, id)) {
+        throw new LowdefyInternalError(`Deferred record "${id}" already exists — one record per config position per build.`);
+    }
+    const record = {
+        kind,
+        body,
+        env,
+        slot,
+        promise: null,
+        waitingOn: new Set(),
+        done: false,
+        value: undefined
+    };
+    context.deferred[id] = record;
+    return record;
+}
+function getRecord(context, id) {
+    const record = context.deferred?.[id];
+    if (!record) {
+        throw new LowdefyInternalError(`Deferred record "${id}" not found in the registry.`);
+    }
+    return record;
+}
+function makePlaceholder(id) {
+    return {
+        [DEFERRED_KEY]: id
+    };
+}
+// A placeholder is exactly a one-enumerable-key object { '~deferred': '<id>' }.
+// The key is reserved (parseRefContent rejects it in source content), so any
+// such object in the tree was created by the build.
+function getPlaceholderId(node) {
+    if (!type.isObject(node)) return undefined;
+    const keys = Object.keys(node);
+    if (keys.length !== 1 || keys[0] !== DEFERRED_KEY) return undefined;
+    const id = node[DEFERRED_KEY];
+    return type.isString(id) ? id : undefined;
+}
+// Wait-graph reachability: is `targetId` reachable from `fromId` through
+// waitingOn edges? A synchronous set walk — edges only change between awaits,
+// so check-then-insert is atomic.
+function findPathTo(context, fromId, targetId, path = []) {
+    if (fromId === targetId) return [
+        ...path,
+        fromId
+    ];
+    if (path.includes(fromId)) return null;
+    const record = context.deferred[fromId];
+    if (!record) return null;
+    for (const nextId of record.waitingOn){
+        const found = findPathTo(context, nextId, targetId, [
+            ...path,
+            fromId
+        ]);
+        if (found) return found;
+    }
+    return null;
+}
+// Demand-driven resolution for single-value record kinds (entryRef,
+// varDefault), promise-memoized per record. Cycle detection is a wait-graph —
+// standard deadlock detection: when resolution of record R demands record S,
+// add edge R → S; if S is in flight and R is reachable from S, the demand
+// closes a cycle in "who is awaiting whom" and awaiting would deadlock — throw
+// the named chain instead. Demands from outside any record
+// (ctx.activeRecord = null) add no edges: they can wait on anything.
+//
+// The returned value is the memoized instance — callers that splice it into
+// mutable config must clone (the walker's placeholder dispatch does).
+// A rejected promise stays memoized: a record whose resolution throws is
+// genuinely broken, and every demander should see the same error once.
+async function resolveDeferred(ctx, id) {
+    const context = ctx.buildContext;
+    const record = getRecord(context, id);
+    if (record.kind === 'component' || record.kind === 'menuLinks') {
+        throw new LowdefyInternalError(`Deferred record "${id}" of kind "${record.kind}" resolves per consumer — ` + `it cannot be demanded through resolveDeferred.`);
+    }
+    if (record.done) return record.value;
+    const demanderId = ctx.activeRecord;
+    const demander = demanderId ? context.deferred[demanderId] : null;
+    if (record.promise && demander) {
+        // In flight: if the demander is reachable from this record, awaiting would
+        // deadlock — the actual dependency cycle, named record by record.
+        const path = findPathTo(context, id, demanderId);
+        if (path) {
+            throw new ConfigError(`Circular deferred value dependency: ${[
+                demanderId,
+                ...path
+            ].join(' → ')}.`, {
+                filePath: record.env?.file ?? null
+            });
+        }
+    }
+    if (demander) {
+        demander.waitingOn.add(id);
+    }
+    try {
+        if (!record.promise) {
+            // Defer the body walk by a microtask so the memo is assigned before any
+            // synchronous prefix of the walk can re-enter this record — otherwise a
+            // self-cycle recurses on a still-null promise instead of hitting the
+            // wait-graph check.
+            record.promise = Promise.resolve().then(()=>resolveRecordBody(ctx, id, record));
+        }
+        return await record.promise;
+    } finally{
+        if (demander) {
+            demander.waitingOn.delete(id);
+        }
+    }
+}
+// Walk a record's body under a fresh context built from record.env — no
+// reconstruction from in-tree markers. Operators and identifier tables come
+// from the demanding context (they are build-wide singletons); the resolution
+// environment (file, roots, module entry) comes from the record.
+async function resolveRecordBody(ctx, id, record) {
+    const context = ctx.buildContext;
+    const env = record.env ?? {};
+    const moduleEntry = env.entryId ? context.modules[env.entryId] ?? null : null;
+    const recordCtx = new WalkContext({
+        buildContext: context,
+        refId: env.refId ?? null,
+        sourceRefId: null,
+        vars: {},
+        moduleDependencies: moduleEntry?.moduleDependencies,
+        moduleEntry,
+        moduleRoot: env.moduleRoot ?? null,
+        packageRoot: env.packageRoot ?? null,
+        path: '',
+        currentFile: env.file ?? null,
+        refChain: new Set(env.file ? [
+            env.file
+        ] : []),
+        operators: ctx.operators,
+        env: ctx.env,
+        lowdefyApp: ctx.lowdefyApp,
+        dynamicIdentifiers: ctx.dynamicIdentifiers,
+        activeRecord: id
+    });
+    let value;
+    if (record.kind === 'entryRef') {
+        // The body is a prepared refDef — replay it through loadAndWalkRef with
+        // the original provenance (env.file is where the ref was written).
+        value = await loadAndWalkRef(record.body, recordCtx, {
+            configKey: env.configKey ?? undefined,
+            referencedFrom: env.file ?? undefined
+        });
+    } else {
+        // varDefault and connRemap bodies are raw config subtrees. Clone before
+        // walking — the raw body must stay pristine in the registry
+        // (deferredRecords.json serializes it, and demand order must not change it).
+        value = await resolve(cloneWithMarkers(record.body), recordCtx);
+    }
+    record.value = value;
+    record.done = true;
+    return value;
+}
+// Placeholder lifetime differs by record kind: component and menuLinks
+// placeholders persist by design (per-consumer resolution; JIT consumes them
+// from modules.json), and varDefault placeholders persist in varDefs
+// (demand-only). Everywhere else a placeholder after the final sweep is a
+// build bug. The allowed positions, per module entry:
+const MANIFEST_PLACEHOLDER_PATHS = [
+    /^components\.\d+\.component$/,
+    /^menus\.\d+\.links$/,
+    // varDefs is extracted from manifest.vars by reference, so demand-only
+    // default placeholders legitimately show through the manifest too.
+    /^vars(\.[^.]+\.properties)*\.[^.]+\.default$/
+];
+const VARDEFS_PLACEHOLDER_PATHS = [
+    /^[^.]+(\.properties\.[^.]+)*\.default$/
+];
+function findPlaceholderLeaks(context) {
+    const leaks = [];
+    const scan = (value, path, allowed, location)=>{
+        const id = getPlaceholderId(value);
+        if (id !== undefined) {
+            if (!allowed.some((pattern)=>pattern.test(path))) {
+                leaks.push({
+                    id,
+                    location: `${location}.${path}`
+                });
+            }
+            return;
+        }
+        if (type.isArray(value)) {
+            value.forEach((item, i)=>scan(item, path ? `${path}.${i}` : String(i), allowed, location));
+        } else if (type.isObject(value)) {
+            for (const key of Object.keys(value)){
+                scan(value[key], path ? `${path}.${key}` : key, allowed, location);
+            }
+        }
+    };
+    for (const [entryId, entry] of Object.entries(context.modules ?? {})){
+        scan(entry.manifest ?? {}, '', MANIFEST_PLACEHOLDER_PATHS, `${entryId}.manifest`);
+        scan(entry.consumerVars ?? {}, '', [], `${entryId}.consumerVars`);
+        scan(entry.connections ?? {}, '', [], `${entryId}.connections`);
+        scan(entry.varDefs ?? {}, '', VARDEFS_PLACEHOLDER_PATHS, `${entryId}.varDefs`);
+    }
+    return leaks;
+}
+// Post-sweep leak check: every entryRef/connRemap placeholder must be gone from
+// entry configs, and manifests may hold placeholders only at per-consumer
+// slots. The runtime var cache is not scanned — the deep-forcing read path
+// guarantees it placeholder-free (pinned by its own tests).
+function assertNoPlaceholderLeaks(context) {
+    const leaks = findPlaceholderLeaks(context);
+    if (leaks.length > 0) {
+        const detail = leaks.map((leak)=>`"${leak.id}" at ${leak.location}`).join('; ');
+        throw new LowdefyInternalError(`Deferred placeholder leaked past the final sweep: ${detail}.`);
+    }
+}
+// Serialize the registry's data for the deferredRecords.json build artifact.
+// Runtime state (promise, waitingOn, done, value) is stripped — JIT re-derives
+// it empty. Must go through the marker-preserving serializer: record bodies
+// carry non-enumerable ~r/~l/~k markers that plain JSON.stringify would drop,
+// breaking error line-number pairing in JIT.
+function serializeRegistry(context) {
+    const data = {};
+    for (const [id, record] of Object.entries(context.deferred ?? {})){
+        data[id] = {
+            kind: record.kind,
+            body: record.body,
+            env: record.env,
+            slot: record.slot
+        };
+    }
+    return serializer.serializeToString(data);
+}
+// Hydrate the registry from deserialized deferredRecords.json data (the caller
+// deserializes with the marker-restoring reviver, e.g. serializer.deserialize).
+function hydrateDeferredRecords(context, data) {
+    context.deferred = {};
+    for (const [id, record] of Object.entries(data ?? {})){
+        context.deferred[id] = {
+            kind: record.kind,
+            body: record.body,
+            env: record.env,
+            slot: record.slot ?? null,
+            promise: null,
+            waitingOn: new Set(),
+            done: false,
+            value: undefined
+        };
+    }
+}
+export { DEFERRED_KEY, makeRecordId, createRecord, getRecord, makePlaceholder, getPlaceholderId, resolveDeferred, assertNoPlaceholderLeaks, serializeRegistry, hydrateDeferredRecords };

package/dist/build/buildRefs/getKey.js

@@ -12,12 +12,23 @@
   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 } from '@lowdefy/helpers';
-function getKey({ input, refDef }) {
+*/ import { get, ReservedKeyError } from '@lowdefy/helpers';
+import { ConfigError } from '@lowdefy/errors';
+function getKey({ input, refDef, filePath }) {
     if (refDef.key) {
-        return get(input, refDef.key, {
-            default: null
-        });
+        try {
+            return get(input, refDef.key, {
+                default: null
+            });
+        } catch (error) {
+            if (!(error instanceof ReservedKeyError)) throw error;
+            // The ref key is author-written YAML, so a reserved name is a config mistake. Without
+            // this the bare ReservedKeyError reaches the build with no file and no line.
+            throw new ConfigError(`_ref key "${refDef.key}" is a reserved name.`, {
+                cause: error,
+                filePath
+            });
+        }
     }
     return input;
 }

package/dist/build/buildRefs/getModuleRefContent.js

@@ -13,6 +13,7 @@
   See the License for the specific language governing permissions and
   limitations under the License.
 */ import { ConfigError } from '@lowdefy/errors';
+import { getPlaceholderId } from './deferredRegistry.js';
 function describeRef(refDef) {
     const parts = [];
     if (refDef.module) parts.push(`module: "${refDef.module}"`);
@@ -62,17 +63,31 @@ async function getModuleRefContent({ context, refDef, referencedFrom, walkCtx, c
         component: manifest.components,
         menu: manifest.menus
     }[exportType] ?? [];
-    let content;
-    if (exportType === 'component') {
-        content = manifestArray.find((item)=>item.id === exportName)?.component;
-    } else if (exportType === 'menu') {
-        content = manifestArray.find((item)=>item.id === exportName)?.links;
+    const entry = manifestArray.find((item)=>item.id === exportName);
+    if (!entry) {
+        const availableIds = manifestArray.map((item)=>item.id);
+        const available = availableIds.length > 0 ? ` Available ${exportType}s: ${availableIds.join(', ')}.` : ` The module defines no ${exportType}s.`;
+        throw new ConfigError(`Module "${entryId}" has no ${exportType} "${exportName}".${available}`, {
+            configKey
+        });
     }
+    const content = exportType === 'component' ? entry.component : entry.links;
     if (!content) {
-        throw new ConfigError(`Module "${entryId}" does not export ${exportType} "${exportName}".`, {
+        throw new ConfigError(`The ${exportType} "${exportName}" in module "${entryId}" is empty.`, {
             configKey
         });
     }
+    // Component bodies live in the deferred-record registry — the manifest holds
+    // a placeholder. Return the record id; consumption dereferences it and walks
+    // a clone under the record's env. (Menus still return live links until they
+    // become records; scalar legacy bodies fall through as live content.)
+    const recordId = getPlaceholderId(content);
+    if (recordId !== undefined) {
+        return {
+            recordId,
+            entryId
+        };
+    }
     return {
         content,
         entryId

package/dist/build/buildRefs/getUserJavascriptFunction.js

@@ -25,7 +25,7 @@ async function getUserJavascriptFunction({ context, filePath }) {
         // 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;
+        return (await import(/* webpackIgnore: true */ /* @vite-ignore */ fileUrl.href)).default;
     } catch (error) {
         throw new ConfigError(`Error importing ${filePath}.`, {
             cause: error,

package/dist/build/buildRefs/parseRefContent.js

@@ -19,6 +19,29 @@ import JSON5 from 'json5';
 import YAML from 'yaml';
 import addLineNumbers from './addLineNumbers.js';
 import parseNunjucks from './parseNunjucks.js';
+import { DEFERRED_KEY } from './deferredRegistry.js';
+// '~deferred' is the build's deferred-record placeholder key. Unlike the other
+// build markers it is enumerable (that durability is the point), so user config
+// could collide with it — a literal '~deferred' key would be dispatched as a
+// placeholder far from its source. Reject it where file content first enters
+// the walker, with file provenance.
+function assertNoReservedKeys(value, filePath) {
+    if (type.isArray(value)) {
+        for (const item of value){
+            assertNoReservedKeys(item, filePath);
+        }
+        return;
+    }
+    if (!type.isObject(value)) return;
+    for (const key of Object.keys(value)){
+        if (key === DEFERRED_KEY) {
+            throw new ConfigError(`The key "${DEFERRED_KEY}" is reserved by the Lowdefy build and cannot be used in config.`, {
+                filePath
+            });
+        }
+        assertNoReservedKeys(value[key], filePath);
+    }
+}
 function parseYamlWithLineNumbers(content) {
     const doc = YAML.parseDocument(content);
     if (doc.errors && doc.errors.length > 0) {
@@ -71,6 +94,7 @@ async function parseRefContent({ content, refDef }) {
             }
         }
     }
+    assertNoReservedKeys(content, type.isString(path) ? path : null);
     return content;
 }
 export default parseRefContent;

package/dist/build/buildRefs/{evaluateStaticOperators.js → precomputeRuntimeOperators.js}

@@ -24,7 +24,7 @@ validateOperatorsDynamic({
 const dynamicIdentifiers = collectDynamicIdentifiers({
     operators
 });
-function evaluateStaticOperators({ context, input, refDef }) {
+function precomputeRuntimeOperators({ context, input, refDef }) {
     const typeNames = collectTypeNames({
         typesMap: context.typesMap
     });
@@ -33,20 +33,21 @@ function evaluateStaticOperators({ context, input, refDef }) {
         operators,
         operatorPrefix: '_',
         env: process.env,
+        lowdefyApp: context.appMeta,
         dynamicIdentifiers,
         typeNames
     });
     if (errors.length > 0) {
         errors.forEach((error)=>{
             // Resolve source file path for error location.
-            // Only called from buildRefs top-level where refDef is root lowdefy.yaml,
-            // but ~r on each operator object identifies the real source file via refMap.
-            // Falls back to refDef.path if ~r is missing (shouldn't happen at this stage
-            // since all objects have ~r after recursiveBuild completes).
+            // Called from index.js Phase 3.5 (refDef = lowdefy.yaml) and buildPageJit
+            // (refDef = page); ~r on each operator object identifies the real source
+            // file via refMap. Falls back to refDef.path if ~r is missing (shouldn't
+            // happen at this stage since all objects have ~r after recursiveBuild completes).
             error.filePath = error.refId ? context.refMap[error.refId]?.path : refDef.path;
             collectExceptions(context, error);
         });
     }
     return output;
 }
-export default evaluateStaticOperators;
+export default precomputeRuntimeOperators;