@lowdefy/build 4.6.0 → 4.7.1

package/dist/build/buildImports/buildIconImports.js

@@ -12,36 +12,7 @@
   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.
-*/ const iconPackages = {
-    'react-icons/ai': /"(Ai[A-Z0-9]\w*)"/gm,
-    'react-icons/bi': /"(Bi[A-Z0-9]\w*)"/gm,
-    'react-icons/bs': /"(Bs[A-Z0-9]\w*)"/gm,
-    'react-icons/cg': /"(Cg[A-Z0-9]\w*)"/gm,
-    'react-icons/ci': /"(Ci[A-Z0-9]\w*)"/gm,
-    'react-icons/di': /"(Di[A-Z0-9]\w*)"/gm,
-    'react-icons/fa': /"(Fa[A-Z0-9]\w*)"/gm,
-    'react-icons/fc': /"(Fc[A-Z0-9]\w*)"/gm,
-    'react-icons/fi': /"(Fi[A-Z0-9]\w*)"/gm,
-    'react-icons/gi': /"(Gi[A-Z0-9]\w*)"/gm,
-    'react-icons/go': /"(Go[A-Z0-9]\w*)"/gm,
-    'react-icons/gr': /"(Gr[A-Z0-9]\w*)"/gm,
-    'react-icons/hi': /"(Hi[A-Z0-9]\w*)"/gm,
-    'react-icons/im': /"(Im[A-Z0-9]\w*)"/gm,
-    'react-icons/io': /"(IoIos[A-Z0-9]\w*)"/gm,
-    'react-icons/io5': /"(Io[A-Z0-9]\w*)"/gm,
-    'react-icons/lu': /"(Lu[A-Z0-9]\w*)"/gm,
-    'react-icons/md': /"(Md[A-Z0-9]\w*)"/gm,
-    'react-icons/pi': /"(Pi[A-Z0-9]\w*)"/gm,
-    'react-icons/ri': /"(Ri[A-Z0-9]\w*)"/gm,
-    'react-icons/rx': /"(Rx[A-Z0-9]\w*)"/gm,
-    'react-icons/si': /"(Si[A-Z0-9]\w*)"/gm,
-    'react-icons/sl': /"(Sl[A-Z0-9]\w*)"/gm,
-    'react-icons/tb': /"(Tb[A-Z0-9]\w*)"/gm,
-    'react-icons/tfi': /"(Tfi[A-Z0-9]\w*)"/gm,
-    'react-icons/ti': /"(Ti[A-Z0-9]\w*)"/gm,
-    'react-icons/vsc': /"(Vsc[A-Z0-9]\w*)"/gm,
-    'react-icons/wi': /"(Wi[A-Z0-9]\w*)"/gm
-};
+*/ import iconPackages from './iconPackages.js';
 function getConfigIcons({ components, icons, regex }) {
     [
         ...JSON.stringify(components.global || {}).matchAll(regex)
@@ -65,7 +36,6 @@ function getBlockDefaultIcons({ blocks, context, icons, regex }) {
 function buildIconImports({ blocks, components, context, defaults = {} }) {
     const iconImports = [];
     Object.entries(iconPackages).forEach(([iconPackage, regex])=>{
-        defaults;
         const icons = new Set(defaults[iconPackage]);
         getConfigIcons({
             components,

package/dist/build/buildImports/iconPackages.js

@@ -0,0 +1,49 @@
+/*
+  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.
+*/ // Icon name regex patterns keyed by react-icons package.
+// Note: 'react-icons/io' and 'react-icons/io5' overlap — IoIos* icons match
+// both packages. This is intentional and matches the existing buildIconImports
+// behavior where both packages receive the IoIos* icons.
+const iconPackages = {
+    'react-icons/ai': /"(Ai[A-Z0-9]\w*)"/gm,
+    'react-icons/bi': /"(Bi[A-Z0-9]\w*)"/gm,
+    'react-icons/bs': /"(Bs[A-Z0-9]\w*)"/gm,
+    'react-icons/cg': /"(Cg[A-Z0-9]\w*)"/gm,
+    'react-icons/ci': /"(Ci[A-Z0-9]\w*)"/gm,
+    'react-icons/di': /"(Di[A-Z0-9]\w*)"/gm,
+    'react-icons/fa': /"(Fa[A-Z0-9]\w*)"/gm,
+    'react-icons/fc': /"(Fc[A-Z0-9]\w*)"/gm,
+    'react-icons/fi': /"(Fi[A-Z0-9]\w*)"/gm,
+    'react-icons/gi': /"(Gi[A-Z0-9]\w*)"/gm,
+    'react-icons/go': /"(Go[A-Z0-9]\w*)"/gm,
+    'react-icons/gr': /"(Gr[A-Z0-9]\w*)"/gm,
+    'react-icons/hi': /"(Hi[A-Z0-9]\w*)"/gm,
+    'react-icons/im': /"(Im[A-Z0-9]\w*)"/gm,
+    'react-icons/io': /"(IoIos[A-Z0-9]\w*)"/gm,
+    'react-icons/io5': /"(Io[A-Z0-9]\w*)"/gm,
+    'react-icons/lu': /"(Lu[A-Z0-9]\w*)"/gm,
+    'react-icons/md': /"(Md[A-Z0-9]\w*)"/gm,
+    'react-icons/pi': /"(Pi[A-Z0-9]\w*)"/gm,
+    'react-icons/ri': /"(Ri[A-Z0-9]\w*)"/gm,
+    'react-icons/rx': /"(Rx[A-Z0-9]\w*)"/gm,
+    'react-icons/si': /"(Si[A-Z0-9]\w*)"/gm,
+    'react-icons/sl': /"(Sl[A-Z0-9]\w*)"/gm,
+    'react-icons/tb': /"(Tb[A-Z0-9]\w*)"/gm,
+    'react-icons/tfi': /"(Tfi[A-Z0-9]\w*)"/gm,
+    'react-icons/ti': /"(Ti[A-Z0-9]\w*)"/gm,
+    'react-icons/vsc': /"(Vsc[A-Z0-9]\w*)"/gm,
+    'react-icons/wi': /"(Wi[A-Z0-9]\w*)"/gm
+};
+export default iconPackages;

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/makeRefDefinition.js

@@ -15,8 +15,10 @@
 */ import { get } from '@lowdefy/helpers';
 import getRefPath from './getRefPath.js';
 import makeId from '../../utils/makeId.js';
-function makeRefDefinition(refDefinition, parent, refMap, lineNumber) {
-    const id = makeId.next();
+function makeRefDefinition(refDefinition, parent, refMap, lineNumber, walkerPath) {
+    // Use walker tree path when available for deterministic IDs under parallel
+    // resolution. Falls back to counter for root ref and JIT-created refs.
+    const id = walkerPath != null ? walkerPath : makeId.next();
     const refDef = {
         parent,
         lineNumber

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,348 @@
+/*
+  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, ctx.path);
+    // 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);
+    }
+    await Promise.all(varKeys.map(async (varKey)=>{
+        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)) {
+        try {
+            const varResult = resolveVar(node, ctx);
+            return await resolve(varResult, ctx);
+        } catch (error) {
+            if (error instanceof ConfigError) {
+                ctx.collectError(error);
+                return null;
+            }
+            throw error;
+        }
+    }
+    // 5. Array — walk children in parallel
+    if (type.isArray(node)) {
+        await Promise.all(node.map(async (item, i)=>{
+            node[i] = await resolve(item, ctx.child(String(i)));
+        }));
+        return node;
+    }
+    // 6. Object — walk children in parallel
+    const keys = Object.keys(node);
+    await Promise.all(keys.map(async (key)=>{
+        if (ctx.shouldStop) {
+            const childPath = ctx.path ? `${ctx.path}.${key}` : key;
+            if (ctx.shouldStop(childPath, ctx.refId)) {
+                delete node[key];
+                return;
+            }
+        }
+        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 };