@lowdefy/build 4.6.0 → 4.7.0

package/dist/build/buildRefs/buildRefs.js

@@ -12,33 +12,49 @@
   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 recursiveBuild from './recursiveBuild.js';
+*/ import operators from '@lowdefy/operators-js/operators/build';
+import { resolve, WalkContext } from './walker.js';
+import getRefContent from './getRefContent.js';
 import makeRefDefinition from './makeRefDefinition.js';
-import evaluateBuildOperators from './evaluateBuildOperators.js';
 import evaluateStaticOperators from './evaluateStaticOperators.js';
-import collectTypeNames from '../collectTypeNames.js';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+import isPageContentPath from '../jit/isPageContentPath.js';
+// Validate and collect dynamic identifiers once at module load
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
 async function buildRefs({ context, shallowOptions }) {
+    context.unresolvedRefVars = context.unresolvedRefVars ?? {};
     const refDef = makeRefDefinition('lowdefy.yaml', null, context.refMap);
-    let components = await recursiveBuild({
-        context,
-        refDef,
-        count: 0,
-        shallowOptions
+    const ctx = new WalkContext({
+        buildContext: context,
+        refId: refDef.id,
+        sourceRefId: null,
+        vars: {},
+        path: '',
+        currentFile: refDef.path,
+        refChain: new Set(refDef.path ? [
+            refDef.path
+        ] : []),
+        operators,
+        env: process.env,
+        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
     });
-    // First: evaluate _build.* operators (e.g., _build.env)
-    // Pass typeNames so page objects act as type boundaries, preventing ~dyn markers
-    // from ~shallow content (blocks, events) from bubbling up and blocking evaluation
-    // of _build.array at the pages level.
-    const typeNames = collectTypeNames({
-        typesMap: context.typesMap
-    });
-    components = await evaluateBuildOperators({
+    const content = await getRefContent({
         context,
-        input: components,
         refDef,
-        typeNames
+        referencedFrom: null
     });
-    // Second: evaluate static operators (_sum, _if, etc.) that don't depend on runtime data
+    let components = await resolve(content, ctx);
+    // Evaluate static operators (_sum, _if, etc.) that don't depend on runtime data
     components = evaluateStaticOperators({
         context,
         input: components,

package/dist/build/buildRefs/evaluateStaticOperators.js

@@ -12,13 +12,12 @@
   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 { BuildParser } from '@lowdefy/operators';
+*/ import { evaluateOperators } from '@lowdefy/operators';
 import operators from '@lowdefy/operators-js/operators/build';
 import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
 import collectTypeNames from '../collectTypeNames.js';
 import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
 import collectExceptions from '../../utils/collectExceptions.js';
-// Validate and collect dynamic identifiers once at module load
 validateOperatorsDynamic({
     operators
 });
@@ -26,20 +25,17 @@ const dynamicIdentifiers = collectDynamicIdentifiers({
     operators
 });
 function evaluateStaticOperators({ context, input, refDef }) {
-    // Collect type names from context.typesMap for type boundary detection
     const typeNames = collectTypeNames({
         typesMap: context.typesMap
     });
-    const operatorsParser = new BuildParser({
-        env: process.env,
+    const { output, errors } = evaluateOperators({
+        input,
         operators,
+        operatorPrefix: '_',
+        env: process.env,
         dynamicIdentifiers,
         typeNames
     });
-    const { output, errors } = operatorsParser.parse({
-        input,
-        operatorPrefix: '_'
-    });
     if (errors.length > 0) {
         errors.forEach((error)=>{
             // Resolve source file path for error location.

package/dist/build/buildRefs/parseRefContent.js

@@ -92,7 +92,8 @@ function parseRefContent({ content, refDef }) {
     const { path, vars } = refDef;
     if (type.isString(path)) {
         let ext = getFileExtension(path);
-        if (ext === 'njk') {
+        const isNjk = ext === 'njk';
+        if (isNjk) {
             try {
                 content = parseNunjucks(content, vars);
             } catch (error) {
@@ -107,6 +108,12 @@ function parseRefContent({ content, refDef }) {
             try {
                 content = parseYamlWithLineNumbers(content);
             } catch (error) {
+                if (isNjk) {
+                    throw new ConfigError(`Nunjucks template "${path}" produced invalid YAML.`, {
+                        cause: error,
+                        filePath: path
+                    });
+                }
                 const lineMatch = error.message.match(/at line (\d+)/);
                 throw new ConfigError(`YAML parse error in "${path}".`, {
                     cause: error,

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/jit/buildPageJit.js

@@ -16,24 +16,33 @@
 import path from 'path';
 import { serializer, type } from '@lowdefy/helpers';
 import { ConfigError, LowdefyInternalError } from '@lowdefy/errors';
+import operators from '@lowdefy/operators-js/operators/build';
 import addKeys from '../addKeys.js';
 import buildPage from '../buildPages/buildPage.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';
+import collectDynamicIdentifiers from '../collectDynamicIdentifiers.js';
 import createCheckDuplicateId from '../../utils/createCheckDuplicateId.js';
 import createContext from '../../createContext.js';
-import createRefReviver from '../buildRefs/createRefReviver.js';
-import evaluateBuildOperators from '../buildRefs/evaluateBuildOperators.js';
 import evaluateStaticOperators from '../buildRefs/evaluateStaticOperators.js';
+import getRefContent from '../buildRefs/getRefContent.js';
 import jsMapParser from '../buildJs/jsMapParser.js';
 import makeRefDefinition from '../buildRefs/makeRefDefinition.js';
-import recursiveBuild from '../buildRefs/recursiveBuild.js';
+import { resolve, WalkContext, cloneForResolve, tagRefDeep } from '../buildRefs/walker.js';
+import validateOperatorsDynamic from '../validateOperatorsDynamic.js';
+import writeMaps from '../writeMaps.js';
 import detectMissingPluginPackages from './detectMissingPluginPackages.js';
 import updateServerPackageJsonJit from './updateServerPackageJsonJit.js';
 import validatePageTypes from './validatePageTypes.js';
 import writePageJit from './writePageJit.js';
+validateOperatorsDynamic({
+    operators
+});
+const dynamicIdentifiers = collectDynamicIdentifiers({
+    operators
+});
 async function buildPageJit({ pageId, pageRegistry, context, directories, logger }) {
     // Use provided context or create a minimal one for JIT builds
     const buildContext = context ?? createContext({
@@ -76,18 +85,20 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
         let resolvedVars = null;
         if (unresolvedVars) {
             const varRefDef = makeRefDefinition({}, null, buildContext.refMap);
-            resolvedVars = await recursiveBuild({
-                context: buildContext,
-                refDef: varRefDef,
-                count: 0,
-                content: unresolvedVars,
-                referencedFrom: pageEntry.refPath ?? pageEntry.resolverOriginal?.resolver
-            });
-            resolvedVars = await evaluateBuildOperators({
-                context: buildContext,
-                input: resolvedVars,
-                refDef: varRefDef
+            const varCtx = new WalkContext({
+                buildContext,
+                refId: varRefDef.id,
+                sourceRefId: null,
+                vars: {},
+                path: '',
+                currentFile: pageEntry.refPath ?? pageEntry.resolverOriginal?.resolver ?? '',
+                refChain: new Set(),
+                operators,
+                env: process.env,
+                dynamicIdentifiers,
+                shouldStop: null
             });
+            resolvedVars = await resolve(cloneForResolve(unresolvedVars), varCtx);
         }
         let refDef;
         if (pageEntry.resolverOriginal) {
@@ -105,17 +116,25 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             refDef = makeRefDefinition(refDefinition, null, buildContext.refMap);
             buildContext.refMap[refDef.id].path = refDef.path;
         }
-        let processed = await recursiveBuild({
+        const pageContent = await getRefContent({
             context: buildContext,
             refDef,
-            count: 0
+            referencedFrom: null
         });
-        // Top-level operator evaluation (same as buildRefs does after recursiveBuild)
-        processed = await evaluateBuildOperators({
-            context: buildContext,
-            input: processed,
-            refDef
+        const pageCtx = new WalkContext({
+            buildContext,
+            refId: refDef.id,
+            sourceRefId: null,
+            vars: refDef.vars ?? {},
+            path: '',
+            currentFile: refDef.path ?? '',
+            refChain: new Set(),
+            operators,
+            env: process.env,
+            dynamicIdentifiers,
+            shouldStop: null
         });
+        let processed = await resolve(pageContent, pageCtx);
         processed = evaluateStaticOperators({
             context: buildContext,
             input: processed,
@@ -129,14 +148,9 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
                 throw new ConfigError(`Page "${pageId}" not found in resolved page source file.`);
             }
         }
-        // Stamp root-level content with ~r for correct error file tracing.
-        // recursiveBuild stamps child _ref content via createRefReviver, but the
-        // root file's own objects have no parent to do this. Without ~r, addKeys
-        // can't link objects to their source file and errors fall back to lowdefy.yaml.
-        const reviver = createRefReviver(refDef.id);
-        processed = serializer.copy(processed, {
-            reviver
-        });
+        // Tag all objects with ~r for ref provenance (normally done inside _ref
+        // resolution by the walker; JIT resolves the page file directly).
+        tagRefDeep(processed, refDef.id);
         // Apply skeleton-computed auth (buildAuth ran during skeleton build)
         processed.auth = pageEntry.auth;
         // Add keys to the resolved page
@@ -144,6 +158,11 @@ async function buildPageJit({ pageId, pageRegistry, context, directories, logger
             components: processed,
             context: buildContext
         });
+        // Write keyMap/refMap so the error handler reads JIT entries from disk.
+        // JIT addKeys assigns fresh ~k values that aren't in the skeleton keyMap.
+        await writeMaps({
+            context: buildContext
+        });
         // Initialize linkActionRefs for buildPage (normally done by buildPages)
         if (!buildContext.linkActionRefs) {
             buildContext.linkActionRefs = [];

package/dist/build/jit/createPageRegistry.js

@@ -66,10 +66,15 @@ function createPageRegistry({ components, context }) {
         const keyMapEntry = context.keyMap[page['~k']];
         const refId = keyMapEntry?.['~r'] ?? null;
         const sourceRef = !type.isNone(refId) ? findPageSourceRef(refId, context.refMap, unresolvedRefVars) : null;
+        // Inline pages (defined directly in lowdefy.yaml) have a refId pointing to
+        // the root ref but findPageSourceRef returns null because there is no
+        // separate source file. Set refId to null so buildPageJit serves them from
+        // the pre-built artifact written by buildShallowPages.
+        const isInline = !type.isNone(refId) && sourceRef === null && !type.isNone(context.refMap[refId]) && type.isNone(context.refMap[refId].parent);
         registry.set(page.id, {
             pageId: page.id,
             auth: page.auth,
-            refId,
+            refId: isInline ? null : refId,
             refPath: sourceRef?.path ?? null,
             unresolvedVars: sourceRef?.unresolvedVars ?? null,
             resolverOriginal: sourceRef?.original ?? null

package/dist/build/jit/shallowBuild.js

@@ -48,7 +48,6 @@ import writePluginImports from '../writePluginImports/writePluginImports.js';
 import addInstalledTypes from './addInstalledTypes.js';
 import buildJsShallow from './buildJsShallow.js';
 import buildShallowPages from './buildShallowPages.js';
-import stripPageContent from './stripPageContent.js';
 import writeSourcelessPages from './writeSourcelessPages.js';
 async function shallowBuild(options) {
     makeId.reset();
@@ -73,9 +72,6 @@ async function shallowBuild(options) {
             components,
             context
         });
-        stripPageContent({
-            components
-        });
         tryBuildStep(testSchema, 'testSchema', {
             components,
             context
@@ -201,6 +197,7 @@ async function shallowBuild(options) {
             context
         });
         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 ?? {}));
         // Persist snapshot of installed packages for JIT missing-package detection.
         // Written as a build artifact so JIT builds compare against the skeleton