configorama 0.9.5 → 0.9.11

package/src/main.js

@@ -42,6 +42,7 @@ const { splitCsv } = require('./utils/strings/splitCsv')
 const { replaceAll } = require('./utils/strings/replaceAll')
 const { getTextAfterOccurrence, findNestedVariable } = require('./utils/strings/textUtils')
 const { ensureQuote, isSurroundedByQuotes, startsWithQuotedPipe } = require('./utils/strings/quoteUtils')
+const { splitOnPipe } = require('./utils/strings/splitOnPipe')
 /* Utils - ui */
 const chalk = require('./utils/ui/chalk')
 const deepLog = require('./utils/ui/deep-log')
@@ -63,6 +64,8 @@ const getValueFromOptions = require('./resolvers/valueFromOptions')
 const getValueFromParam = require('./resolvers/valueFromParam')
 const getValueFromCron = require('./resolvers/valueFromCron')
 const getValueFromEval = require('./resolvers/valueFromEval')
+const { encodeValue: encodeValueForEval } = require('./resolvers/valueFromEval')
+const getValueFromIf = require('./resolvers/valueFromIf')
 const createGitResolver = require('./resolvers/valueFromGit')
 const { getValueFromFile: getValueFromFileResolver } = require('./resolvers/valueFromFile')
 /* Parsers */
@@ -151,6 +154,8 @@ class Configorama {
     this.settings.allowUnresolvedVariables = unresolvedSetting
 
     this.filterCache = {}
+    // Cache for originalValue lookups (perf: avoid repeated dotProp.get)
+    this._originalValueCache = new Map()
 
     this.foundVariables = []
     this.fileRefsFound = []
@@ -158,17 +163,25 @@ class Configorama {
     // Track variable resolutions for metadata (keyed by path)
     this.resolutionTracking = {}
 
-    const defaultSyntax = buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
+    // Detect file type early to determine default syntax
+    let detectedFileType = null
+    if (typeof fileOrObject === 'string') {
+      detectedFileType = path.extname(fileOrObject).toLowerCase()
+    }
+
+    // Use $[...] syntax for HCL/Terraform files to avoid conflicts with Terraform's ${} syntax
+    const isHclFile = detectedFileType === '.tf' || detectedFileType === '.hcl'
+    const defaultSyntax = isHclFile
+      ? buildVariableSyntax('$[', ']', ['AWS', 'stageVariables'])
+      : buildVariableSyntax('${', '}', ['AWS', 'stageVariables'])
 
     const varSyntax = options.syntax || defaultSyntax
     let varRegex
     if (typeof varSyntax === 'string') {
       varRegex = new RegExp(varSyntax, 'g')
-      // this.variableSyntax = /\${((?!AWS)([ ~:a-zA-Z0-9=+!@#%*<>?._'",|\-\/\(\)\\]+?|(\w+)\s*\(((?:[^()]+)*)?\s*\)\s*))}/
     } else if (varSyntax instanceof RegExp) {
       varRegex = varSyntax
     }
-    // console.log('varRegex', varRegex)
     const variableSyntax = varRegex
     this.variableSyntax = variableSyntax
 
@@ -183,10 +196,15 @@ class Configorama {
 
     // Set initial config object to populate
     if (typeof fileOrObject === 'object') {
+      // Store truly raw config before any preprocessing
+      this.rawOriginalConfig = cloneDeep(fileOrObject)
+      // Preprocess: convert bare refs in if(), escape help() args
+      // Skip fallback fixing for object configs (they handle bare refs differently)
+      const processed = preProcess(fileOrObject, this.variableSyntax, this.variableTypes, { skipFallbackFix: true })
       // set config objects
-      this.config = fileOrObject
+      this.config = processed
       // Keep a copy
-      this.originalConfig = cloneDeep(fileOrObject)
+      this.originalConfig = cloneDeep(processed)
       // Set configPath for file references
       this.configPath = options.configDir || process.cwd()
     } else if (typeof fileOrObject === 'string') {
@@ -251,6 +269,13 @@ class Configorama {
        */
       getValueFromEval,
 
+      /**
+       * If expressions (alias for eval)
+       * Usage:
+       * ${if(${self:value} > 10 ? "big" : "small")}
+       */
+      getValueFromIf,
+
       /**
        * Self references
        * Usage:
@@ -395,6 +420,15 @@ class Configorama {
     )
     this.variablesKnownTypes = variablesKnownTypes
 
+    // Build prefix lookup map for O(1) type detection (perf optimization)
+    this._resolverByPrefix = new Map()
+    for (const r of this.variableTypes) {
+      const prefix = r.prefix || r.type
+      if (prefix && r.match instanceof RegExp && !r.internal) {
+        this._resolverByPrefix.set(prefix + ':', r)
+      }
+    }
+
     // this.allPatterns = combineRegexes(...this.variableTypes.map((v) => v.match))
     // console.log('this.allPatterns', this.allPatterns)
     // console.log('this.variablesKnownTypes', this.variablesKnownTypes)
@@ -584,19 +618,26 @@ class Configorama {
    */
   isUnknownTypeAllowed(varString) {
     const setting = this.settings.allowUnknownVariableTypes
-    if (setting === true) return true
     if (setting === false || setting === undefined) return false
+
+    // Extract type prefix from variable string
+    // Handle both 'ssm:path' and '${ssm:path}' formats
+    let cleanVar = varString
+    if (cleanVar.startsWith(this.varPrefix)) {
+      cleanVar = cleanVar.slice(this.varPrefix.length)
+    }
+    if (cleanVar.endsWith(this.varSuffix)) {
+      cleanVar = cleanVar.slice(0, -this.varSuffix.length)
+    }
+    const typePrefix = this.extractTypePrefix(cleanVar)
+
+    // Check if this is a known type (has a resolver) - known types should not be treated as "unknown allowed"
+    const isKnownType = typePrefix && this._resolverByPrefix && this._resolverByPrefix.has(typePrefix + ':')
+    if (isKnownType) return false
+
+    if (setting === true) return true
+
     if (Array.isArray(setting)) {
-      // Extract type prefix from variable string
-      // Handle both 'ssm:path' and '${ssm:path}' formats
-      let cleanVar = varString
-      if (cleanVar.startsWith(this.varPrefix)) {
-        cleanVar = cleanVar.slice(this.varPrefix.length)
-      }
-      if (cleanVar.endsWith(this.varSuffix)) {
-        cleanVar = cleanVar.slice(0, -this.varSuffix.length)
-      }
-      const typePrefix = this.extractTypePrefix(cleanVar)
       if (typePrefix && setting.includes(typePrefix)) return true
     }
     return false
@@ -1234,6 +1275,7 @@ class Configorama {
             const transform = this.runFunction.bind(this)
             const varSyntax = this.variableSyntax
             const leaves = this.leaves
+            const filters = this.filters
             // console.log('leaves two', leaves)
             // Traverse resolved object and run functions
             // console.log('this.config', this.config)
@@ -1268,17 +1310,59 @@ class Configorama {
                   // console.log('funcString', funcString)
                   const func = cleanVariable(funcString, varSyntax, true, `init ${this.callCount}`)
                   const funcVal = transform(func)
-                  const hasObjectRef = rawValue.match(/\.\S*$/)
-                  if (hasObjectRef && typeof funcVal === 'object') {
-                    const objectPath = hasObjectRef[0].replace(/^\./, '')
-                    // console.log('objectPath', objectPath)
-                    /* get value from object and update  */
-                    const valueFromObject = dotProp.get(funcVal, objectPath)
-                    // console.log('valueFromObject', valueFromObject)
-                    this.update(valueFromObject)
+
+                  // Strip filters like " | toUpperCase" before checking for property/index access
+                  const rawValueNoFilters = rawValue.replace(/\s*\|.*$/, '')
+
+                  // Helper to get property from value (works on objects, arrays, and primitives)
+                  const getProp = (val, path) => {
+                    if (val == null) return undefined
+                    // For primitives (string, number), access property directly
+                    if (typeof val !== 'object') {
+                      // Handle single property like 'length'
+                      if (!path.includes('.')) return val[path]
+                      // Handle path like 'foo.bar' - not applicable for primitives
+                      return undefined
+                    }
+                    return dotProp.get(val, path)
+                  }
+
+                  // Extract filters from rawValue if present (may end with } from ${...})
+                  // Handles multiple filters like "| trim | toUpperCase"
+                  const pipeIdx = rawValue.indexOf('|')
+                  const filterNames = pipeIdx > -1
+                    ? splitOnPipe(rawValue.slice(pipeIdx).replace(/\}$/, ''))
+                        .map(f => f.trim().split('(')[0])
+                        .filter(Boolean)
+                    : []
+
+                  let finalValue = funcVal
+
+                  // Check for array index access: [N] optionally followed by .property
+                  const indexMatch = rawValueNoFilters.match(/[)\}]\s*\[(\d+)\](?:\.([\w.]+))?$/)
+                  if (indexMatch && Array.isArray(funcVal)) {
+                    const index = parseInt(indexMatch[1], 10)
+                    const propPath = indexMatch[2]
+                    finalValue = funcVal[index]
+                    if (propPath && finalValue != null) {
+                      finalValue = getProp(finalValue, propPath)
+                    }
                   } else {
-                    this.update(funcVal)
+                    // Check for property access: .foo.bar after function close
+                    const propMatch = rawValueNoFilters.match(/[)\}]\s*\.([\w.]+)$/)
+                    if (propMatch && typeof funcVal === 'object') {
+                      finalValue = dotProp.get(funcVal, propMatch[1])
+                    }
+                  }
+
+                  // Apply filters in sequence
+                  for (const filterName of filterNames) {
+                    if (filters[filterName]) {
+                      finalValue = filters[filterName](finalValue)
+                    }
                   }
+
+                  this.update(finalValue)
                 }
 
                 /* fix for file(JS-ref.js, raw) to keep parens and inline code */
@@ -1375,8 +1459,7 @@ class Configorama {
         if (hasFilters) {
           // Extract filter names from the match (e.g., "| String}" -> ["String"])
           const filterPart = hasFilters[0].replace(/}?$/, '') // Remove trailing }
-          foundFilters = filterPart
-            .split('|')
+          foundFilters = splitOnPipe(filterPart)
             .map((filter) => filter.trim())
             .filter(Boolean)
 
@@ -1844,21 +1927,35 @@ class Configorama {
       const thePath = leaf.path.length > 1 ? leaf.path.join('.') : leaf.path[0]
       // console.log('thePath', thePath)
       // console.log('this.originalConfig', this.originalConfig)
-      let originalValue = dotProp.get(this.originalConfig, thePath)
-      // TODO @DWELLS make recursive
-      if (!originalValue) {
-        // Recurse up the tree until we find a value
-        let currentPathArray = leaf.path.slice(0, -1)
-        while (currentPathArray.length > 0 && !originalValue) {
-          const currentPath = currentPathArray.length > 1 ? currentPathArray.join('.') : currentPathArray[0]
-          // console.log('checking parent path:', currentPath)
-          originalValue = dotProp.get(this.originalConfig, currentPath)
-          if (typeof originalValue !== 'undefined') {
-            leaf.originalValuePath = currentPath
-            leaf.currentConfig = this.config
+
+      // Check cache first (perf: avoid repeated dotProp.get calls)
+      let originalValue
+      let originalValuePath
+      if (this._originalValueCache.has(thePath)) {
+        const cached = this._originalValueCache.get(thePath)
+        originalValue = cached.value
+        originalValuePath = cached.originalValuePath
+      } else {
+        originalValue = dotProp.get(this.originalConfig, thePath)
+        // TODO @DWELLS make recursive
+        if (!originalValue) {
+          // Recurse up the tree until we find a value
+          // Use index instead of slice() to avoid array allocations
+          for (let pathLen = leaf.path.length - 1; pathLen > 0 && !originalValue; pathLen--) {
+            const currentPath = leaf.path.slice(0, pathLen).join('.')
+            // console.log('checking parent path:', currentPath)
+            originalValue = dotProp.get(this.originalConfig, currentPath)
+            if (typeof originalValue !== 'undefined') {
+              originalValuePath = currentPath
+            }
           }
-          currentPathArray = currentPathArray.slice(0, -1)
         }
+        // Cache the result
+        this._originalValueCache.set(thePath, { value: originalValue, originalValuePath })
+      }
+      if (originalValuePath) {
+        leaf.originalValuePath = originalValuePath
+        leaf.currentConfig = this.config
       }
       leaf.originalSource = originalValue
 
@@ -1995,6 +2092,7 @@ class Configorama {
     // Initialize resolution history if needed
     if (!valueObject.resolutionHistory) {
       valueObject.resolutionHistory = []
+      valueObject._historyKeys = new Set()
     }
 
     let result = valueObject.value
@@ -2113,12 +2211,13 @@ class Configorama {
       }
 
       // Only add to history if not a duplicate (same match + variable)
-      const isDuplicate = valueObject.resolutionHistory.some(entry =>
-        entry.match === historyEntry.match &&
-        entry.variable === historyEntry.variable
-      )
-
-      if (!isDuplicate) {
+      // Use Set for O(1) lookup instead of O(n) array scan
+      const historyKey = `${historyEntry.match}|${historyEntry.variable}`
+      if (!valueObject._historyKeys) {
+        valueObject._historyKeys = new Set()
+      }
+      if (!valueObject._historyKeys.has(historyKey)) {
+        valueObject._historyKeys.add(historyKey)
         valueObject.resolutionHistory.push(historyEntry)
       }
 
@@ -2277,9 +2376,8 @@ class Configorama {
     const hasFilters = originalSrc.match(this.filterMatch)
     let foundFilters = []
     if (hasFilters) {
-      foundFilters = hasFilters[0]
-        .replace(this.varSuffixPattern, '')
-        .split('|')
+      const filterPart = hasFilters[0].replace(this.varSuffixPattern, '')
+      foundFilters = splitOnPipe(filterPart)
         .map((filter) => filter.trim())
         .filter(Boolean)
     }
@@ -2325,7 +2423,9 @@ class Configorama {
         let deepIndex = Number(v.match(deepIndexPattern)[1])
         let item = this.deep[deepIndex]
 
-        if (item.match(deepRefSyntax)) {
+        // Only follow chain if item IS a deep ref (not just contains one)
+        // e.g. item = "${deep:0}" should follow, but item = "https://...${deep:0}..." should not
+        if (/^\$\{deep:\d+\}$/.test(item)) {
           deepIndex = Number(item.match(deepIndexPattern)[1])
           item = this.deep[deepIndex]
         }
@@ -2372,6 +2472,18 @@ class Configorama {
         valueToPopulate = valueToPopulate.replace(this.varSuffixPattern, '')
       }
 
+      // For eval/if expressions, string values need quotes unless already quoted
+      // BUT don't quote strings that contain variable refs (they need further resolution)
+      if (/\b(eval|if)\s*\(/.test(property) && !valueToPopulate.match(this.variableSyntax)) {
+        const matchIdx = property.indexOf(currentMatchedString)
+        const charBefore = matchIdx > 0 ? property[matchIdx - 1] : ''
+        // Always escape quotes in values for eval/if context
+        valueToPopulate = valueToPopulate.replace(/"/g, '\\"')
+        if (charBefore !== '"' && charBefore !== "'") {
+          // Not already quoted, wrap in quotes for eval
+          valueToPopulate = `"${valueToPopulate}"`
+        }
+      }
       property = replaceAll(currentMatchedString, valueToPopulate, property)
       // console.log('property replaceAll', property)
 
@@ -2387,37 +2499,55 @@ class Configorama {
       // } else if (isArray(valueToPopulate) && valueToPopulate.length === 1) {
       //  property = replaceAll(matchedString, String(valueToPopulate[0]), property)
     } else if (isObject(valueToPopulate)) {
-      if (DEBUG_TYPE) console.log('DEBUG_TYPEisObject')
-
-      const objStr = JSON.stringify(valueToPopulate)
-      /* Check if variable inside another variable. E.g. ${env:${self:someObject}} that resolves to ${env:{...}} */
-      const isNestedInVariable = (
-        property.trim() !== matchedString.trim() &&
-        property.indexOf(matchedString) !== -1 &&
-        matchedString.match(this.variableSyntax) &&
-        property.match(this.variableSyntax)
-      )
-      // Only encode for file() or text() references where JSON braces break regex matching
-      const isFileOrTextRef = /\bfile\s*\(|\btext\s*\(/.test(property)
-      if (isNestedInVariable && isFileOrTextRef) {
-        // Encode object as base64 to avoid breaking variable syntax with nested braces
-        const encodedObj = encodeJsonForVariable(valueToPopulate)
-        property = replaceAll(matchedString, encodedObj, property)
-      } else if (isNestedInVariable) {
-        const isVar = /^\${[a-zA-Z0-9_]+:/.test(property)
-        if (isVar) {
-          throw new Error(
-            `Invalid variable syntax "${property}" resolves to "${replaceAll(matchedString, objStr, property)}"`,
-          )
-        }
-        property = replaceAll(matchedString, objStr, property)
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE isObject')
+
+      // For eval/if expressions, encode objects to avoid {} breaking variable syntax
+      const isEvalOrIf = /\b(eval|if)\s*\(/.test(property)
+      if (isEvalOrIf) {
+        const encoded = encodeValueForEval(valueToPopulate)
+        property = replaceAll(matchedString, encoded, property)
       } else {
-        // console.log('OBJECT MATCH', `"${objStr}"`)
-        property = replaceAll(matchedString, objStr, property)
+        const objStr = JSON.stringify(valueToPopulate)
+        /* Check if variable inside another variable. E.g. ${env:${self:someObject}} that resolves to ${env:{...}} */
+        const isNestedInVariable = (
+          property.trim() !== matchedString.trim() &&
+          property.indexOf(matchedString) !== -1 &&
+          matchedString.match(this.variableSyntax) &&
+          property.match(this.variableSyntax)
+        )
+        // Only encode for file() or text() references where JSON braces break regex matching
+        const isFileOrTextRef = /\bfile\s*\(|\btext\s*\(/.test(property)
+        if (isNestedInVariable && isFileOrTextRef) {
+          // Encode object as base64 to avoid breaking variable syntax with nested braces
+          const encodedObj = encodeJsonForVariable(valueToPopulate)
+          property = replaceAll(matchedString, encodedObj, property)
+        } else if (isNestedInVariable) {
+          const isVar = /^\${[a-zA-Z0-9_]+:/.test(property)
+          if (isVar) {
+            throw new Error(
+              `Invalid variable syntax "${property}" resolves to "${replaceAll(matchedString, objStr, property)}"`,
+            )
+          }
+          property = replaceAll(matchedString, objStr, property)
+        } else {
+          // console.log('OBJECT MATCH', `"${objStr}"`)
+          property = replaceAll(matchedString, objStr, property)
+        }
       }
       // console.log('property', property)
       // TODO run functions here
       // console.log('other new prop', property)
+
+    // partial replacement, boolean inside eval/if expressions
+    } else if (typeof valueToPopulate === 'boolean' && /\b(eval|if)\s*\(/.test(property)) {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE isBoolean in eval/if')
+      property = replaceAll(matchedString, String(valueToPopulate), property)
+
+    // partial replacement, null inside eval/if expressions
+    } else if (valueToPopulate === null && /\b(eval|if)\s*\(/.test(property)) {
+      if (DEBUG_TYPE) console.log('DEBUG_TYPE isNull in eval/if')
+      property = replaceAll(matchedString, '__NULL__', property)
+
     } else {
       if (DEBUG_TYPE) console.log('DEBUG_TYPE else')
       let missingValue = matchedString
@@ -2434,7 +2564,7 @@ class Configorama {
         true,
         `populateVariable fallback ${this.callCount}`
       )
-      const cleanVarNoFilters = cleanVar.split('|')[0]
+      const cleanVarNoFilters = splitOnPipe(cleanVar)[0]
       const splitVars = splitByComma(cleanVarNoFilters)
       const nestedVar = findNestedVariable(splitVars, valueObject.originalSource)
 
@@ -2559,8 +2689,9 @@ Missing Value ${missingValue} - ${matchedString}
         /* Not file or text refs */
         !prop.match(fileRefSyntax)
         && !prop.match(textRefSyntax)
-        /* Not eval refs */
-        && !prop.match(getValueFromEval.match) 
+        /* Not eval/if refs */
+        && !prop.match(getValueFromEval.match)
+        && !prop.match(getValueFromIf.match)
         // AND is not multiline value
         && (func && prop.split('\n').length < 3)) {
         // console.log('IS FUNCTION')
@@ -2821,12 +2952,11 @@ Missing Value ${missingValue} - ${matchedString}
       promiseKey = deeperValue.match(/\s\|/) ? deeperValue : undefined
 
       // TODO clean this up
-      const t = variableString.split('|')
+      const t = splitOnPipe(variableString)
       // console.log('variableString', variableString)
       // console.log('valueObject', valueObject)
       // console.log('t', t)
-      const _filter = string
-        .split('|')
+      const _filter = splitOnPipe(string)
         .filter((value, index, arr) => {
           return index > 0
         })
@@ -2849,24 +2979,40 @@ Missing Value ${missingValue} - ${matchedString}
     /** @type {Function|undefined} */
     let resolverFunction
     let resolverType
-    /* Loop over variables and set getterFunction when match found. */
-    const found = this.variableTypes.some((r, i) => {
-      if (r.match instanceof RegExp && variableString.match(r.match)) {
-        // set resolver function
-        resolverFunction = r.resolver
-        resolverType = r.type || 'unknown'
-        return true
-      } else if (typeof r.match === 'function') {
-        // TODO finalize match API
-        if (r.match(variableString, this.config, valueObject)) {
+    let found = false
+
+    // Fast path: try prefix lookup first for O(1) detection of common types
+    const colonIdx = variableString.indexOf(':')
+    if (colonIdx !== -1) {
+      const prefix = variableString.slice(0, colonIdx + 1)
+      const resolver = this._resolverByPrefix.get(prefix)
+      if (resolver && resolver.match instanceof RegExp && variableString.match(resolver.match)) {
+        resolverFunction = resolver.resolver
+        resolverType = resolver.type || 'unknown'
+        found = true
+      }
+    }
+
+    // Fallback: loop over all variable types
+    if (!found) {
+      found = this.variableTypes.some((r, i) => {
+        if (r.match instanceof RegExp && variableString.match(r.match)) {
           // set resolver function
           resolverFunction = r.resolver
           resolverType = r.type || 'unknown'
           return true
+        } else if (typeof r.match === 'function') {
+          // TODO finalize match API
+          if (r.match(variableString, this.config, valueObject)) {
+            // set resolver function
+            resolverFunction = r.resolver
+            resolverType = r.type || 'unknown'
+            return true
+          }
         }
-      }
-      return false
-    })
+        return false
+      })
+    }
     /*
     // console.log('found variable resolver', found)
     // console.log('resolverFunction', resolverFunction)
@@ -2907,8 +3053,10 @@ Missing Value ${missingValue} - ${matchedString}
         }
 
         // console.log('VALUE', val)
+        // For eval/if resolvers, null is a valid intentional result (e.g., ternary false branch)
+        const isEvalOrIfResolver = resolverType === 'eval' || resolverType === 'if'
         if (
-          val === null ||
+          (val === null && !isEvalOrIfResolver) ||
           typeof val === 'undefined' ||
           /* match deep refs as empty {}, they need resolving via functions */
           (typeof val === 'object' && isEmpty(val) && variableString.match(/deep\:/))
@@ -2966,7 +3114,8 @@ Missing Value ${missingValue} - ${matchedString}
                 return Promise.resolve(undefined)
               }
             }
-            return Promise.resolve(encodeUnknown(propertyString))
+            // Encode only the unknown variable, not the entire string
+            return Promise.resolve(encodeUnknown(this.varPrefix + variableString + this.varSuffix))
           }
 
           if (valueCount.length === 1 && noNestedVars) {
@@ -3040,9 +3189,8 @@ Missing Value ${missingValue} - ${matchedString}
 
         if (typeof val === 'string' && val.match(/deep:/)) {
           // TODO refactor the deep filter logic here. match | filter | filter..
-          const allFilters = propertyString
-            .replace(this.varSuffixPattern, '')
-            .split('|')
+          const propWithoutSuffix = propertyString.replace(this.varSuffixPattern, '')
+          const allFilters = splitOnPipe(propWithoutSuffix)
             .reduce((acc, currentFilter, i) => {
               if (i === 0) {
                 return acc
@@ -3108,7 +3256,7 @@ Missing Value ${missingValue} - ${matchedString}
       // TODO @DWELLS cleanVariable makes fallback values with spaces have no spaces
       // console.log('AFTER cleanVariable', clean)
       // console.log(typeof clean)
-      const cleanClean = clean.split('|')[0]
+      const cleanClean = splitOnPipe(clean)[0]
       // console.log('cleanCleanVariable', cleanClean)
       if (funcRegex.exec(cleanClean)) {
         const valuePromise = Promise.resolve(cleanClean)
@@ -3238,10 +3386,13 @@ Missing Value ${missingValue} - ${matchedString}
       // console.log('allowUnknownVars propertyString', propertyString)
       const varMatches = propertyString.match(this.variableSyntax)
       let allowUnknownVars = propertyString
-      /* If variables found, encode them for passthrough */
+      /* Only encode variables that are actually unknown, not all of them */
       if (varMatches && varMatches.length) {
         varMatches.forEach((m) => {
-          allowUnknownVars = allowUnknownVars.replace(m, encodeUnknown(m))
+          // Only encode this variable if IT is unknown (not just because the string contains unknowns)
+          if (this.isUnknownTypeAllowed(m)) {
+            allowUnknownVars = allowUnknownVars.replace(m, encodeUnknown(m))
+          }
         })
       }
       // console.log('allowUnknownVars propertyString:', propertyString)
@@ -3298,7 +3449,9 @@ Missing Value ${missingValue} - ${matchedString}
       config: this.config,
       getDeeperValue: this.getDeeperValue.bind(this),
       fileRefSyntax: fileRefSyntax,
-      textRefSyntax: textRefSyntax
+      textRefSyntax: textRefSyntax,
+      varPrefix: this.varPrefix,
+      varSuffix: this.varSuffix
     }
     return getValueFromFileResolver(ctx, variableString, options)
   }
@@ -3460,7 +3613,17 @@ Missing Value ${missingValue} - ${matchedString}
     var hasFunc = funcRegex.exec(variableString)
     // TODO finish Function handling. Need to move this down below resolver to resolve inner refs first
     // console.log('hasFunc', hasFunc)
-    if (!hasFunc || hasFunc && (hasFunc[1] === 'cron' || hasFunc[1] === 'eval')) {
+    // Skip special expressions (cron, eval, if) - these aren't user functions
+    if (!hasFunc || hasFunc && (hasFunc[1] === 'cron' || hasFunc[1] === 'eval' || hasFunc[1] === 'if')) {
+      return variableString
+    }
+    // Skip file/text when they match resolver regex OR contain encoded passthrough values
+    // Malformed patterns (with %, \, etc) should still error
+    const hasPassthrough = variableString.includes('>passthrough')
+    if (hasFunc[1] === 'file' && (variableString.match(fileRefSyntax) || hasPassthrough)) {
+      return variableString
+    }
+    if (hasFunc[1] === 'text' && (variableString.match(textRefSyntax) || hasPassthrough)) {
       return variableString
     }
     // test for object

package/src/parsers/esm.js

@@ -19,13 +19,6 @@ async function executeESMFile(filePath, opts = {}) {
     const resolvedPath = path.resolve(filePath)
     let esmModule = jiti(resolvedPath)
 
-    // Handle different export patterns - jiti returns { default: Function } for ESM default exports
-    if (esmModule && typeof esmModule === 'object' && esmModule.default) {
-      esmModule = esmModule.default
-    }
-
-    // For ESM files, we just return the module (object or function)
-    // The calling code will determine whether to execute it or not
     return esmModule
   } catch (err) {
     throw new Error(`Failed to load ESM file ${filePath}: ${err.message}`)
@@ -50,13 +43,6 @@ function executeESMFileSync(filePath, opts = {}) {
     const resolvedPath = path.resolve(filePath)
     let esmModule = jiti(resolvedPath)
 
-    // Handle different export patterns - jiti returns { default: Function } for ESM default exports
-    if (esmModule && typeof esmModule === 'object' && esmModule.default) {
-      esmModule = esmModule.default
-    }
-
-    // For ESM files, we just return the module (object or function)
-    // The calling code will determine whether to execute it or not
     return esmModule
   } catch (err) {
     throw new Error(`Failed to load ESM file ${filePath}: ${err.message}`)