configorama 0.9.15 → 0.9.17

package/src/main.js

@@ -10,7 +10,6 @@ console.log = () => {}
 const findUp = require('find-up')
 const traverse = require('traverse')
 const dotProp = require('dot-prop')
-const { makeBox, makeStackedBoxes } = require('@davidwells/box-logger')
 /* Utils - root */
 const {
   isArray, isString, isNumber, isObject, isDate, isRegExp, isFunction,
@@ -30,8 +29,7 @@ const { parseFileContents } = require('./utils/parsing/parse')
 const { mergeByKeys } = require('./utils/parsing/mergeByKeys')
 const { arrayToJsonPath } = require('./utils/parsing/arrayToJsonPath')
 /* Utils - paths */
-const { normalizePath, extractFilePath, resolveInnerVariables } = require('./utils/paths/filePathUtils')
-const { findLineForKey } = require('./utils/paths/findLineForKey')
+const { findLineByPath } = require('./utils/paths/findLineForKey')
 /* Utils - regex */
 const { combineRegexes, funcRegex, fileRefSyntax, textRefSyntax } = require('./utils/regex')
 /* Utils - strings */
@@ -46,8 +44,11 @@ const { splitOnPipe } = require('./utils/strings/splitOnPipe')
 const chalk = require('./utils/ui/chalk')
 const deepLog = require('./utils/ui/deep-log')
 const { logHeader } = require('./utils/ui/logs')
-const { createEditorLink } = require('./utils/ui/createEditorLink')
-const { runConfigWizard, isSensitiveVariable } = require('./utils/ui/configWizard')
+const { runConfigWizard } = require('./utils/ui/configWizard')
+/* Display */
+const { displayNoVariablesFound, displayVariableDetails, displayUniqueVariables, displayConfigurableVariables } = require('./display')
+/* Metadata */
+const { collectVariableMetadata: collectMetadata } = require('./metadata')
 /* Utils - validation */
 const { warnIfNotFound, isValidValue } = require('./utils/validation/warnIfNotFound')
 /* Utils - variables */
@@ -127,6 +128,10 @@ class Configorama {
       returnMetadata: false,
       // Return preResolvedVariableDetails
       returnPreResolvedVariableDetails: false,
+      // Suppress env-stage-loader's normal dotenv loading logs by default.
+      // CLI users can still see them with --verbose or dotEnvSilent: false.
+      dotEnvSilent: !VERBOSE,
+      dotEnvDebug: false,
     }, options)
 
     // Backward compat: allowUnknownVars -> allowUnknownVariableTypes
@@ -159,6 +164,8 @@ class Configorama {
 
     // Track variable resolutions for metadata (keyed by path)
     this.resolutionTracking = {}
+    // Only track per-call metadata when returnMetadata is requested
+    this._trackCalls = !!(this.settings.returnMetadata)
 
     // Detect file type early to determine default syntax
     let detectedFileType = null
@@ -739,457 +746,25 @@ class Configorama {
       }
 
       if (!varKeys.length) {
-        logHeader('No Variables Found in Config')
-        if (this.configFilePath) {
-          console.log(`File: ${this.configFilePath}`)
-        }
-        
-        console.log(`\nVariable syntax: `, variableSyntax)
-
-        const varTypes = Object.keys(this.variableTypes)
-        if (varTypes.length) {
-          const exclude = ['dot.prop', 'deep']
-          console.log('\nAllowed variable types:')
-          varTypes.forEach((v) => {
-            const vData = this.variableTypes[v]
-            if (exclude.includes(vData.type)) {
-              return
-            }
-            console.log(`  - ${vData.type}: `, vData.match)
-          })
-        }
-        console.log()
+        displayNoVariablesFound(this.configFilePath, variableSyntax, this.variableTypes)
       }
 
       const lines = this.configFileContents ? this.configFileContents.split('\n') : []
       const fileType = this.configFileType
       const configFilePath = this.configFilePath
 
-      if (varKeys.length > 0) {
-        const fileName = this.configFilePath ? ` in ${this.configFilePath}` : ''
-
-        // Extract base variable name from varMatch key (e.g., '${env:FOO, default}' -> 'env:FOO')
-        const getBaseVarName = (key) => key.replace(this.varPrefixPattern, '').replace(this.varSuffixPattern, '').split(',')[0].trim()
-
-        logHeader(`Found ${varKeys.length} Variables${fileName}`)
-
-        // deepLog('variableData', variableData)
-
-        if (varKeys.length) {
-          console.log()
-          const longestKey = varKeys.reduce((acc, k) => {
-            return Math.max(acc, k.length)
-          }, 0)
-
-          // Use uniqueVariables for simpler reference counting
-          const referenceData = varKeys.map((k) => {
-            const varName = getBaseVarName(k)
-            const uniqueVar = uniqueVariables[varName]
-            const refCount = uniqueVar ? uniqueVar.occurrences.length : variableData[k].length
-            const placesWord = refCount > 1 ? 'places' : 'place'
-            return `- ${k.padEnd(longestKey).padEnd(longestKey + 10)} referenced ${refCount} ${placesWord}`
-          }).join('\n')
-
-          console.log(`${referenceData}\n`)
-        }
-
-        logHeader('Variable Details')
-
-        const indent = ''
-        const boxes = varKeys.map((key, i) => {
-          const variableInstances = variableData[key]
-          // console.log('variableInstances', variableInstances)
-          const firstInstance = variableInstances[0]
-
-          // Get uniqueVariable data for description and other metadata
-          const varName = getBaseVarName(key)
-          const uniqueVar = uniqueVariables[varName]
-
-          // Build display message from enriched metadata
-          const spacing = '           '
-          const titleText = `Variable:${spacing}`
-          const VALUE_HEX = '#899499'
-          const keyChalk = chalk.whiteBright
-          const valueChalk = chalk.hex(VALUE_HEX)
-
-          let varMsg = ''
-          let requiredMessage = ''
-
-          // Show required status from metadata
-          if (firstInstance.isRequired) {
-            requiredMessage = `${chalk.red.bold('[Required]')}`
-          }
-
-          // Show type filter if present (Boolean, String, Number, etc.)
-          if (uniqueVar && uniqueVar.types && uniqueVar.types.length > 0) {
-            const typeLabel = `${indent}${keyChalk('Type:'.padEnd(titleText.length, ' '))}`
-            varMsg += `${typeLabel} ${valueChalk(uniqueVar.types.join(', '))}\n`
-          }
-
-          // Show description from uniqueVariables if available
-          if (uniqueVar && uniqueVar.descriptions && uniqueVar.descriptions.length > 0) {
-            const descText = `${indent}${keyChalk('Description:'.padEnd(titleText.length, ' '))}`
-            const combinedDesc = uniqueVar.descriptions.join('. ')
-            varMsg += `${descText} ${valueChalk(combinedDesc)}\n`
-          }
-
-          // Show resolve order from metadata
-          if (firstInstance.resolveOrder.length > 1) {
-            varMsg += `${indent}${keyChalk('Resolve Order:'.padEnd(titleText.length, ' '))}`
-            const resolveOrder = firstInstance.resolveOrder.join(', ')
-            varMsg += ` ${valueChalk(resolveOrder)}\n`
-          }
-
-          // Show default value from metadata
-          if (typeof firstInstance.defaultValue !== 'undefined') {
-            const defaultValueRender = firstInstance.defaultValue === '' ? '""' : firstInstance.defaultValue
-            const defaultValueText = `${indent}${keyChalk('Default value:'.padEnd(titleText.length, ' '))}`
-            varMsg += `${defaultValueText} ${valueChalk(defaultValueRender)}\n`
-          }
-
-          // Show default value source path from metadata
-          if (firstInstance.defaultValueSrc) {
-            varMsg += `${indent}${keyChalk('Default path:'.padEnd(titleText.length, ' '))} `
-            const defaultPathLine = findLineForKey(firstInstance.defaultValueSrc, lines, fileType)
-            if (defaultPathLine) {
-              varMsg += `${createEditorLink(configFilePath, defaultPathLine, 1, firstInstance.defaultValueSrc, 'gray')}\n`
-            } else {
-              varMsg += `${valueChalk(firstInstance.defaultValueSrc)}\n`
-            }
-          }
-
-          // Show path(s) from metadata
-          const configPathLine = findLineForKey(variableInstances[0].path, lines, fileType)
-          let locationRender = configPathLine
-            ? createEditorLink(configFilePath, configPathLine, 1, variableInstances[0].path, 'gray')
-            : valueChalk(variableInstances[0].path)
-          let locationLabel = `${indent}${keyChalk('Config Path:'.padEnd(titleText.length, ' '))}`
-          let typeText = ''
-          if (variableInstances.length > 1) {
-            const pathIndent = ' '.repeat(titleText.length + 1)
-            const pathItems = variableInstances.map((v, idx) => {
-              const pathLine = findLineForKey(v.path, lines, fileType)
-              const pathLink = pathLine
-                ? createEditorLink(configFilePath, pathLine, 1, `- ${v.path}`, 'gray')
-                : valueChalk(`- ${v.path}`)
-              // Show type filter per path if different
-              if (uniqueVar && uniqueVar.occurrences.length > 1) {
-                const occurrence = uniqueVar.occurrences.find(occ => occ.path === v.path)
-                const pathType = occurrence && occurrence.type
-                typeText = pathType ? ` ${chalk.dim(`Type: ${pathType}`)}` : ''
-                const prefix = idx === 0 ? '' : `${indent}${pathIndent}`
-                return `${prefix}${pathLink}${typeText}`
-              }
-              const prefix = idx === 0 ? '' : `${indent}${pathIndent}`
-              return `${prefix}${pathLink}${typeText}`
-            })
-            locationRender = pathItems.join('\n')
-            locationLabel = `${indent}${keyChalk('Config Paths:'.padEnd(titleText.length, ' '))}`
-          } else {
-            const pathType = firstInstance.type
-            typeText = pathType ? ` ${chalk.dim(`Type: ${pathType}`)}` : ''
-          }
-          varMsg += `${locationLabel} ${locationRender}`
-
-          const lineNumber = findLineForKey(firstInstance.key, lines, fileType)
-
-          return {
-            content: {
-              left: varMsg,
-              backgroundColor: 'red',
-              width: '100%',
-            },
-            title: {
-              left: `▷ ${lineNumber ? createEditorLink(this.configFilePath, lineNumber, 1, key) : key}`,
-              right: lineNumber ? createEditorLink(this.configFilePath, lineNumber, 1, `${requiredMessage} ${lineNumber ? `Line: ${lineNumber.toString().padEnd(2, ' ')}` : ''}`, 'gray') : '',
-              center: typeText,
-              paddingBottom: 1,
-              paddingTop: (i === 0) ? 1 : 0,
-              truncate: true,
-            },
-            width: '100%',
-          }
-        })
-
-        console.log(makeStackedBoxes(boxes, {
-          borderText: 'Variable Details. Click on titles to open in editor.',
-          borderColor: 'gray',
-          minWidth: '96%',
-          borderStyle: 'bold',
-          disableTitleSeparator: true,
-        }))
-        // process.exit(1)
-      }
-
-      // New unique variable makeStackedBoxes display
-      const uniqueBoxes = uniqueVarKeys.map((varName, i) => {
-        const uniqueVar = uniqueVariables[varName]
-        const occurrences = uniqueVar.occurrences || []
-        const firstOcc = occurrences[0] || {}
-
-        const spacing = '           '
-        const titleText = `Variable:${spacing}`
-        const VALUE_HEX = '#899499'
-        const keyChalk = chalk.whiteBright
-        const valueChalk = chalk.hex(VALUE_HEX)
-
-        let varMsg = ''
-        let requiredMessage = ''
-
-        // Show required status from computed isRequired (accounts for resolved self-refs)
-        const isRequired = occurrences.some(occ => occ.isRequired)
-        if (isRequired) {
-          requiredMessage = `${chalk.red.bold('[Required]')}`
-        }
-
-        // Show type filter if present
-        if (uniqueVar.types && uniqueVar.types.length > 0) {
-          const typeLabel = `${keyChalk('Type:'.padEnd(titleText.length, ' '))}`
-          varMsg += `${typeLabel} ${valueChalk(uniqueVar.types.join(', '))}\n`
-        }
-
-        // Show description
-        if (uniqueVar.descriptions && uniqueVar.descriptions.length > 0) {
-          const descText = `${keyChalk('Description:'.padEnd(titleText.length, ' '))}`
-          const combinedDesc = uniqueVar.descriptions.join('. ')
-          varMsg += `${descText} ${valueChalk(combinedDesc)}\n`
-        }
-
-        // Show default value only if it's a true fallback, not a pre-resolved value
-        // Redact sensitive values like API keys, secrets, tokens
-        const isSensitive = isSensitiveVariable(varName)
-        const hasActualDefault = firstOcc.hasFallback && typeof firstOcc.defaultValue !== 'undefined'
-        if (hasActualDefault) {
-          const defaultValueRender = isSensitive ? '********' : (firstOcc.defaultValue === '' ? '""' : firstOcc.defaultValue)
-          const defaultValueText = `${keyChalk('Default value:'.padEnd(titleText.length, ' '))}`
-          varMsg += `${defaultValueText} ${valueChalk(defaultValueRender)}\n`
-        } else if (uniqueVar.resolvedValue !== undefined) {
-          // Show pre-resolved current value (e.g., from env, git)
-          const resolvedRender = isSensitive ? '********' : (uniqueVar.resolvedValue === '' ? '""' : uniqueVar.resolvedValue)
-          const resolvedText = `${keyChalk('Current value:'.padEnd(titleText.length, ' '))}`
-          const envIndicator = uniqueVar.variableType === 'env' ? ` ${chalk.red('(currently set env var)')}` : ''
-          varMsg += `${resolvedText} ${valueChalk(resolvedRender)}${envIndicator}\n`
-        }
-
-        // Show default value source path
-        if (firstOcc.defaultValueSrc) {
-          varMsg += `${keyChalk('Default path:'.padEnd(titleText.length, ' '))} `
-          const defaultPathLine = findLineForKey(firstOcc.defaultValueSrc, lines, fileType)
-          if (defaultPathLine) {
-            varMsg += `${createEditorLink(configFilePath, defaultPathLine, 1, firstOcc.defaultValueSrc, 'gray')}\n`
-          } else {
-            varMsg += `${valueChalk(firstOcc.defaultValueSrc)}\n`
-          }
-        }
-
-        // Show config path(s) from occurrences
-        let locationRender
-        let locationLabel
-        if (occurrences.length > 1) {
-          const pathIndent = ' '.repeat(titleText.length + 1)
-          const pathItems = occurrences.map((occ, idx) => {
-            const pathLine = findLineForKey(occ.path, lines, fileType)
-            const pathLink = pathLine
-              ? createEditorLink(configFilePath, pathLine, 1, `- ${occ.path}`, 'gray')
-              : valueChalk(`- ${occ.path}`)
-            const typeText = occ.type ? ` ${chalk.dim(`Type: ${occ.type}`)}` : ''
-            const prefix = idx === 0 ? '' : `${pathIndent}`
-            return `${prefix}${pathLink}${typeText}`
-          })
-          locationRender = pathItems.join('\n')
-          locationLabel = `${keyChalk('Config Paths:'.padEnd(titleText.length, ' '))}`
-        } else {
-          const pathLine = findLineForKey(firstOcc.path, lines, fileType)
-          locationRender = pathLine
-            ? createEditorLink(configFilePath, pathLine, 1, firstOcc.path, 'gray')
-            : valueChalk(firstOcc.path)
-          locationLabel = `${keyChalk('Config Path:'.padEnd(titleText.length, ' '))}`
-        }
-        varMsg += `${locationLabel} ${locationRender}`
+      const displayParams = { lines, fileType, configFilePath, uniqueVariables, uniqueVarKeys }
 
-        // Find first line number for title
-        const lineNumber = findLineForKey(firstOcc.path, lines, fileType)
-
-        return {
-          content: {
-            left: varMsg,
-            backgroundColor: 'red',
-            width: '100%',
-          },
-          title: {
-            left: `▷ ${firstOcc.varMatch}`,
-            right: `${requiredMessage} ${lineNumber ? `Line: ${lineNumber.toString().padEnd(2, ' ')}` : ''}`,
-            paddingBottom: 1,
-            paddingTop: (i === 0) ? 1 : 0,
-            truncate: true,
-          },
-          width: '100%',
-        }
+      displayVariableDetails({
+        varKeys, variableData, uniqueVariables,
+        varPrefixPattern: this.varPrefixPattern,
+        varSuffixPattern: this.varSuffixPattern,
+        lines, fileType, configFilePath,
       })
 
-      console.log(makeStackedBoxes(uniqueBoxes, {
-        borderText: 'Unique Variables',
-        borderColor: 'gray',
-        minWidth: '96%',
-        borderStyle: 'bold',
-        disableTitleSeparator: true,
-      }))
-      console.log()
-
-
-      // Unique variables that require setup (excludes readonly source types)
-      const CONFIGURABLE_SOURCES = ['user', 'config', 'remote']
-      const configurableVariables = {}
-      const configurableVarKeys = []
-
-      for (const varName of uniqueVarKeys) {
-        const uniqueVar = uniqueVariables[varName]
-        // Include if source type is user, config, or remote (not readonly)
-        if (CONFIGURABLE_SOURCES.includes(uniqueVar.variableSourceType)) {
-          configurableVariables[varName] = uniqueVar
-          configurableVarKeys.push(varName)
-        }
-      }
-
-      // Display configurable variables by source type
-      if (configurableVarKeys.length > 0) {
-        const spacing = '           '
-        const titleText = `Variable:${spacing}`
-        const VALUE_HEX = '#899499'
-        const keyChalk = chalk.whiteBright
-        const valueChalk = chalk.hex(VALUE_HEX)
-
-        // Group by source type
-        const bySource = {
-          user: [],
-          config: [],
-          remote: [],
-        }
-
-        for (const varName of configurableVarKeys) {
-          const v = configurableVariables[varName]
-          const sourceType = v.variableSourceType || 'user'
-          if (bySource[sourceType]) {
-            bySource[sourceType].push({ varName, ...v })
-          }
-        }
-
-        const sourceLabels = {
-          user: 'User Input Required',
-          config: 'Config References',
-          remote: 'Remote Services',
-        }
-
-        const sourceColors = {
-          user: 'yellow',
-          config: 'cyan',
-          remote: 'magenta',
-        }
-
-        const configurableBoxes = []
-
-        for (const [sourceType, vars] of Object.entries(bySource)) {
-          if (vars.length === 0) continue
+      displayUniqueVariables(displayParams)
 
-          for (let i = 0; i < vars.length; i++) {
-            const v = vars[i]
-            const occurrences = v.occurrences || []
-            const firstOcc = occurrences[0] || {}
-
-            let varMsg = ''
-            let requiredMessage = ''
-
-            // Show required status from computed isRequired (accounts for resolved self-refs)
-            const isRequired = occurrences.some(occ => occ.isRequired)
-            if (isRequired) {
-              requiredMessage = `${chalk.red.bold('[Required]')}`
-            }
-
-            // Show description if present (directly under title, not as key/value)
-            if (v.descriptions && v.descriptions.length > 0) {
-              varMsg += `${chalk.dim(v.descriptions.join('. '))}\n\n`
-            }
-
-            // Show type filter if defined (String, Number, etc.)
-            const varType = (v.types && v.types[0]) || firstOcc.type
-            if (varType) {
-              varMsg += `${keyChalk('Type:'.padEnd(titleText.length, ' '))} ${valueChalk(varType)}\n`
-            }
-
-            // Show current/default value (redact sensitive values)
-            const isSensitive = isSensitiveVariable(v.varName)
-            if (v.resolvedValue !== undefined) {
-              const resolvedRender = isSensitive ? '********' : (v.resolvedValue === '' ? '""' : v.resolvedValue)
-              varMsg += `${keyChalk('Current value:'.padEnd(titleText.length, ' '))} ${valueChalk(resolvedRender)}\n`
-            } else if (firstOcc.hasFallback && firstOcc.defaultValue !== undefined) {
-              const defaultRender = isSensitive ? '********' : (firstOcc.defaultValue === '' ? '""' : firstOcc.defaultValue)
-              varMsg += `${keyChalk('Default value:'.padEnd(titleText.length, ' '))} ${valueChalk(defaultRender)}\n`
-            }
-
-            // Show config path(s)
-            let locationRender
-            let locationLabel
-            if (occurrences.length > 1) {
-              const pathIndent = ' '.repeat(titleText.length + 1)
-              const pathItems = occurrences.map((occ, idx) => {
-                const pathLine = findLineForKey(occ.path, lines, fileType)
-                const pathLink = pathLine
-                  ? createEditorLink(configFilePath, pathLine, 1, `- ${occ.path}`, VALUE_HEX)
-                  : valueChalk(`- ${occ.path}`)
-                const prefix = idx === 0 ? '' : `${pathIndent}`
-                return `${prefix}${pathLink}`
-              })
-              locationRender = pathItems.join('\n')
-              locationLabel = 'Config Paths:'
-            } else {
-              const pathLine = findLineForKey(firstOcc.path, lines, fileType)
-              locationRender = pathLine
-                ? createEditorLink(configFilePath, pathLine, 1, firstOcc.path, VALUE_HEX)
-                : valueChalk(firstOcc.path)
-              locationLabel = 'Config Path:'
-            }
-            varMsg += `${keyChalk(locationLabel.padEnd(titleText.length, ' '))} ${locationRender}`
-
-            // Get type for center heading (reuse varType from above)
-            const typeText = varType ? chalk.dim(`Type: ${varType}`) : ''
-
-            // Get line number for first occurrence
-            const firstOccLine = findLineForKey(firstOcc.path, lines, fileType)
-            const varTitle = firstOcc.varMatch || v.varName
-            const requiredSuffix = requiredMessage ? ` - ${requiredMessage}` : ''
-            const titleLink = firstOccLine
-              ? createEditorLink(configFilePath, firstOccLine, 1, `▷ ${varTitle}`) + requiredSuffix
-              : `▷ ${varTitle}${requiredSuffix}`
-
-            configurableBoxes.push({
-              content: {
-                left: varMsg,
-                width: '100%',
-              },
-              title: {
-                left: titleLink,
-                // center: typeText,
-                right: chalk.dim(`${v.variableType}`),
-                paddingBottom: 1,
-                paddingTop: (configurableBoxes.length === 0) ? 1 : 0,
-                truncate: true,
-              },
-              width: '100%',
-            })
-          }
-        }
-
-        if (configurableBoxes.length > 0) {
-          console.log(makeStackedBoxes(configurableBoxes, {
-            borderText: `Configurable Variables (${configurableVarKeys.length})`,
-            borderColor: 'yellow',
-            minWidth: '96%',
-            borderStyle: 'bold',
-            disableTitleSeparator: true,
-          }))
-          console.log()
-        }
-      }
+      displayConfigurableVariables(displayParams)
 
 
       // WALK through CLI prompt if --setup flag is set
@@ -1261,8 +836,8 @@ class Configorama {
       const stage = cliOpts.stage || providerStage || process.env.NODE_ENV || 'dev'
       /* Load env variables into process.env */
       require('env-stage-loader')({
-        // silent: true,
-        // debug: true,
+        silent: this.settings.dotEnvSilent,
+        debug: this.settings.dotEnvDebug,
         env: stage,
         // defaultEnv: 'prod',
         // ignoreFiles: ['.env']
@@ -1423,426 +998,19 @@ class Configorama {
       return this._cachedMetadata
     }
 
-    const variableSyntax = this.variableSyntax
-    const variablesKnownTypes = this.variablesKnownTypes
-    const variableTypes = this.variableTypes
-    const filterMatch = this.filterMatch
-    const configFilePath = this.configFilePath
-    // Use rawOriginalConfig for metadata display (truly original, no escaping)
-    const originalConfig = this.rawOriginalConfig || this.originalConfig
-    const foundVariables = []
-    const variableData = {}
-    const fileRefs = []
-    const fileGlobPatterns = []
-    const preResolvedPaths = new Set()
-    const byConfigPath = []
-    const referencesMap = new Map()
-    let matchCount = 1
-
-    traverse(originalConfig).forEach(function (rawValue) {
-      if (typeof rawValue === 'string' && rawValue.match(variableSyntax)) {
-        const configValuePath = this.path.join('.')
-        /* Skip Fn::Sub variables */
-        if (configValuePath.endsWith('Fn::Sub')) {
-          return
-        }
-
-        const nested = findNestedVariables(
-          rawValue, 
-          variableSyntax, 
-          variablesKnownTypes, 
-          configValuePath, 
-          variableTypes
-        )
-
-        const lastItem = nested[nested.length - 1]
-        const lastKeyPath = this.path[this.path.length - 1]
-        const itemKey = (lastKeyPath.match(/[\d+]$/)) ? `${this.path[this.path.length - 2]}[${lastKeyPath}]` : lastKeyPath
-
-        // Extract filters from varMatch
-        const originalSrc = lastItem.varMatch || ''
-        const hasFilters = filterMatch && originalSrc.match(filterMatch)
-        let foundFilters = []
-        let keyWithoutFilters = originalSrc
-
-        if (hasFilters) {
-          // Extract filter names from the match (e.g., "| String}" -> ["String"])
-          const filterPart = hasFilters[0].replace(/}?$/, '') // Remove trailing }
-          foundFilters = splitOnPipe(filterPart)
-            .map((filter) => filter.trim())
-            .filter(Boolean)
-
-          // Remove filters from the key (replace "| String}" with suffix)
-          // Also clean up any trailing whitespace before the closing brace
-          keyWithoutFilters = originalSrc.replace(filterMatch, this.varSuffix).replace(this.varSuffixWithSpacePattern, this.varSuffix)
-        }
-
-        const key = keyWithoutFilters
-
-        // Helper to pre-resolve a variable from config
-        const preResolveFromConfig = (varString, varType) => {
-          if (!varString) return undefined
-          // Handle self: prefix
-          const varPath = varString.startsWith('self:') ? varString.slice(5) : varString
-          // Only pre-resolve dot.prop and self references
-          if (varType === 'dot.prop' || varType === 'self') {
-            const value = dotProp.get(originalConfig, varPath)
-            if (value !== undefined && typeof value !== 'object') {
-              return { resolved: value, path: varPath }
-            }
-          }
-          return undefined
-        }
-
-        // Strip filters from resolveDetails
-        const cleanedResolveDetails = nested.map(detail => {
-          const cleaned = { ...detail }
-          if (cleaned.varMatch && filterMatch) {
-            const match = cleaned.varMatch.match(filterMatch)
-            if (match) {
-              cleaned.varMatch = cleaned.varMatch.replace(filterMatch, '').replace(/\s+$/, '') + this.varSuffix
-            }
-          }
-          if (cleaned.variable && filterMatch) {
-            const match = cleaned.variable.match(filterMatch)
-            if (match) {
-              cleaned.variable = cleaned.variable.replace(filterMatch, '').replace(/\s+$/, '')
-            }
-          }
-          if (cleaned.varString && filterMatch) {
-            const match = cleaned.varString.match(filterMatch)
-            if (match) {
-              cleaned.varString = cleaned.varString.replace(filterMatch, '').trim()
-            }
-          }
-
-          // Pre-resolve dot.prop and self references
-          const preResolved = preResolveFromConfig(cleaned.varString || cleaned.variable, cleaned.variableType)
-          if (preResolved) {
-            cleaned.varResolved = preResolved.resolved
-            cleaned.varResolvedPath = preResolved.path
-          }
-
-          // Also clean fallbackValues if present
-          if (cleaned.fallbackValues && Array.isArray(cleaned.fallbackValues)) {
-            cleaned.fallbackValues = cleaned.fallbackValues.map(fb => {
-              const cleanedFb = { ...fb }
-              if (cleanedFb.varMatch && filterMatch) {
-                const match = cleanedFb.varMatch.match(filterMatch)
-                if (match) {
-                  cleanedFb.varMatch = cleanedFb.varMatch.replace(filterMatch, '').trim()
-                }
-              }
-              if (cleanedFb.variable && filterMatch) {
-                const match = cleanedFb.variable.match(filterMatch)
-                if (match) {
-                  cleanedFb.variable = cleanedFb.variable.replace(filterMatch, '').trim()
-                }
-              }
-              if (cleanedFb.stringValue && filterMatch) {
-                const match = cleanedFb.stringValue.match(filterMatch)
-                if (match) {
-                  cleanedFb.stringValue = cleanedFb.stringValue.replace(filterMatch, '').trim()
-                }
-              }
-
-              // Pre-resolve fallback variable references
-              if (cleanedFb.stringValue && cleanedFb.stringValue.match(/^\$\{[^}]+\}$/)) {
-                const innerVar = cleanedFb.stringValue.slice(2, -1)
-                const fbPreResolved = preResolveFromConfig(innerVar, 'dot.prop')
-                if (fbPreResolved) {
-                  cleanedFb.varResolved = fbPreResolved.resolved
-                  cleanedFb.varResolvedPath = fbPreResolved.path
-                }
-              }
-
-              return cleanedFb
-            })
-          }
-          return cleaned
-        })
-
-        const varData = {
-          filters: foundFilters.length > 0 ? foundFilters : undefined,
-          path: configValuePath,
-          key: itemKey,
-          originalStringValue: rawValue,
-          variable: keyWithoutFilters,
-          variableWithFilters: originalSrc,
-          isRequired: false,
-          defaultValue: undefined,
-          defaultValueIsVar: undefined,
-          defaultValueSrc: undefined,
-          hasFallback: false,
-          matchIndex: matchCount++,
-          resolveOrder: [],
-          resolveDetails: cleanedResolveDetails,
-        }
-        let defaultValueIsVar = false
-
-        function calculateResolveOrder(item) {
-          // Helper to strip filters from variable strings
-          const stripFilters = (str) => {
-            if (!str || !filterMatch) return str
-            const match = str.match(filterMatch)
-            if (match) {
-              return str.replace(filterMatch, '').trim()
-            }
-            return str
-          }
-
-          if (item && item.fallbackValues) {
-            let hasResolvedFallback
-            let defaultValueSrc
-            const isSingleFallback = item.fallbackValues.length === 1
-            const order = ([stripFilters(item.valueBeforeFallback)]).concat(item.fallbackValues.map((f, i) => {
-              if (f.fallbackValues) {
-                const [nestedOrder, nestedResolvedFallback, nestedDefaultSrc] = calculateResolveOrder(f)
-                if (!hasResolvedFallback && nestedResolvedFallback) {
-                  hasResolvedFallback = nestedResolvedFallback
-                  defaultValueSrc = nestedDefaultSrc
-                }
-                return nestedOrder
-              }
-
-              const valueStr = stripFilters(f.stringValue || f.variable)
-
-              // Only set default from first resolvable fallback
-              if (!hasResolvedFallback && f.isResolvedFallback) {
-                if (f.varResolved !== undefined) {
-                  hasResolvedFallback = f.varResolved
-                  defaultValueSrc = f.varResolvedPath
-                } else if (!valueStr.match(/^\$\{[^}]+\}$/)) {
-                  // Literal value - use as default
-                  hasResolvedFallback = valueStr
-                }
-                // If variable can't resolve, don't set - let next fallback try
-              }
-
-              if (!hasResolvedFallback && f.isVariable) {
-                defaultValueIsVar = f
-              }
-
-              if (f.isResolvedFallback) {
-                if (isSingleFallback) {
-                  // Single fallback: show "value (default)"
-                  return `${valueStr} (default)`
-                } else {
-                  // Multiple fallbacks: show resolved value if available
-                  if (f.varResolved !== undefined) {
-                    return `${valueStr} = ${f.varResolved}`
-                  }
-                  // If can't resolve, just show the value without annotation
-                  return valueStr
-                }
-              }
-              return valueStr
-            })).flat()
-
-            return [order, hasResolvedFallback, defaultValueSrc]
-          }
-          return [[stripFilters(item.variable)], undefined, undefined]
-        }
-
-        const lastCleanedItem = cleanedResolveDetails[cleanedResolveDetails.length - 1]
-        const [resolveOrder, hasResolvedFallback, defaultValueSrc] = calculateResolveOrder(lastCleanedItem)
-        varData.resolveOrder = resolveOrder
-
-        if (defaultValueIsVar) {
-          varData.defaultValueIsVar = defaultValueIsVar
-        }
-
-        if (typeof hasResolvedFallback !== 'undefined') {
-          varData.defaultValue = hasResolvedFallback
-        }
-
-        if (defaultValueSrc) {
-          varData.defaultValueSrc = defaultValueSrc
-        }
-
-        if (typeof varData.defaultValue === 'undefined') {
-          varData.isRequired = true
-        }
-
-        if (varData.resolveOrder.length > 1) {
-          varData.hasFallback = true
-        }
-
-        // Extract file references
-        nested.forEach((detail) => {
-          // console.log('detail', detail)
-          if (detail.variableType && (detail.variableType === 'file' || detail.variableType === 'text')) {
-            const extracted = extractFilePath(detail.variable)
-            if (extracted) {
-              const normalizedPath = normalizePath(extracted.filePath)
-              if (!normalizedPath) return
-
-              // Handle variables in file paths - just record the pattern
-              if (!fileRefs.includes(normalizedPath)) {
-                fileRefs.push(normalizedPath)
-              }
-
-              // Check if path contains variables and create glob pattern
-              const containsVariables = !!normalizedPath.match(variableSyntax)
-              let globPattern
-              if (containsVariables) {
-                // Replace variable syntax ${...} with * for glob pattern
-                globPattern = normalizedPath.replace(variableSyntax, '*')
-                if (!fileGlobPatterns.includes(globPattern)) {
-                  fileGlobPatterns.push(globPattern)
-                }
-              }
-
-              // Try to pre-resolve inner variables from originalConfig
-              let resolvedPath = normalizedPath
-              let resolvedVarString = rawValue
-              if (containsVariables) {
-                const pathResult = resolveInnerVariables(normalizedPath, variableSyntax, originalConfig, dotProp.get)
-                const varStringResult = resolveInnerVariables(rawValue, variableSyntax, originalConfig, dotProp.get)
-
-                if (pathResult.didResolve) {
-                  resolvedPath = normalizePath(pathResult.resolved) || pathResult.resolved
-                  resolvedVarString = varStringResult.resolved
-                  preResolvedPaths.add(resolvedPath)
-                }
-              }
-
-              // Build byConfigPath entry
-              const absolutePath = configFilePath
-                ? path.resolve(path.dirname(configFilePath), resolvedPath)
-                : resolvedPath
-              const fileExists = configFilePath ? fs.existsSync(absolutePath) : false
-
-              const configPathEntry = {
-                location: configValuePath,
-                filePath: absolutePath,
-                relativePath: resolvedPath,
-                originalVariableString: rawValue,
-                resolvedVariableString: resolvedVarString,
-                containsVariables,
-                exists: fileExists,
-              }
-              if (globPattern) {
-                configPathEntry.pattern = globPattern
-              }
-              byConfigPath.push(configPathEntry)
-
-              // Build references entry (use resolvedPath as key when available)
-              const refKey = resolvedPath
-              if (!referencesMap.has(refKey)) {
-                referencesMap.set(refKey, {
-                  resolvedPath: refKey,
-                  refs: [],
-                })
-              }
-              const refEntry = referencesMap.get(refKey)
-              refEntry.refs.push({
-                location: configValuePath,
-                value: normalizedPath,
-                originalVariableString: rawValue,
-              })
-            }
-          }
-        })
-
-        variableData[key] = (variableData[key] || []).concat(varData)
-        foundVariables.push(rawValue)
-      }
-    })
-
-    // Make foundVariables array unique
-    const finalFoundVariables = [...new Set(foundVariables)]
-    const varKeys = Object.keys(variableData)
-
-    // Calculate summary using same logic as CLI display
-    let requiredCount = 0
-    let withDefaultsCount = 0
-    varKeys.forEach((key) => {
-      const instances = variableData[key]
-      const firstInstance = instances[0]
-
-      // Extract variable name from key (e.g. "${self:service}" -> "self:service")
-      const keyVarName = key.slice(2, -1).split(',')[0].trim()
-
-      // Find the resolveDetail that matches THIS variable (not any self-ref in the string)
-      let matchingDetail = null
-      for (const instance of instances) {
-        if (instance.resolveDetails && instance.resolveDetails.length > 0) {
-          const found = instance.resolveDetails.find((detail) => {
-            const detailVar = detail.valueBeforeFallback || detail.variable
-            return detailVar === keyVarName
-          })
-          if (found && (found.variableType === 'dot.prop' || found.variableType === 'self')) {
-            matchingDetail = found
-            break
-          }
-        }
-      }
-
-      // Also check defaultValueIsVar
-      if (!matchingDetail && firstInstance.defaultValueIsVar && (
-        firstInstance.defaultValueIsVar.variableType === 'self:' ||
-        firstInstance.defaultValueIsVar.variableType === 'dot.prop'
-      )) {
-        matchingDetail = firstInstance.defaultValueIsVar
-      }
-
-      // Check if truly required
-      let isTrulyRequired = false
-      if (matchingDetail) {
-        // Check if the self-reference resolves to a value
-        // Use valueBeforeFallback if present (strips inline fallback like ", false")
-        const varPath = matchingDetail.valueBeforeFallback || matchingDetail.variable
-        const cleanPath = varPath.replace('self:', '')
-        const dotPropValue = dotProp.get(this.originalConfig, cleanPath)
-        if (typeof dotPropValue === 'undefined') {
-          isTrulyRequired = true
-        } else {
-          // Enrich ALL instances with resolved self-reference value (overrides inline fallbacks)
-          instances.forEach((instance) => {
-            instance.defaultValueSrc = cleanPath
-            instance.defaultValue = dotPropValue
-            instance.isRequired = false
-          })
-        }
-      } else if (typeof firstInstance.defaultValue === 'undefined') {
-        isTrulyRequired = true
-      }
-
-      // Update isRequired based on computed isTrulyRequired
-      instances.forEach((instance) => {
-        instance.isRequired = isTrulyRequired
-      })
-
-      if (isTrulyRequired) {
-        requiredCount++
-      } else {
-        withDefaultsCount++
-      }
+    this._cachedMetadata = collectMetadata({
+      variableSyntax: this.variableSyntax,
+      variablesKnownTypes: this.variablesKnownTypes,
+      variableTypes: this.variableTypes,
+      filterMatch: this.filterMatch,
+      configFilePath: this.configFilePath,
+      // Use rawOriginalConfig for metadata display (truly original, no escaping)
+      displayConfig: this.rawOriginalConfig || this.originalConfig,
+      originalConfig: this.originalConfig,
+      varSuffix: this.varSuffix,
+      varSuffixWithSpacePattern: this.varSuffixWithSpacePattern,
     })
 
-    this._cachedMetadata = {
-      variables: variableData,
-      uniqueVariables: {},
-      fileDependencies: {
-        globPatterns: fileGlobPatterns,
-        // all: fileRefs,
-        dynamicPaths: fileRefs.filter(ref => ref.indexOf('*') !== -1 || ref.match(variableSyntax)),
-        // Resolved paths: static paths + pre-resolved dynamic paths
-        resolvedPaths: [
-          ...fileRefs.filter(ref => ref.indexOf('*') === -1 && !ref.match(variableSyntax)),
-          ...preResolvedPaths
-        ],
-        byConfigPath,
-        references: Array.from(referencesMap.values()),
-      },
-      summary: {
-        totalVariables: varKeys.length,
-        requiredVariables: requiredCount,
-        variablesWithDefaults: withDefaultsCount
-      },
-    }
-
     return this._cachedMetadata
   }
   /**
@@ -1917,7 +1085,7 @@ class Configorama {
     if (!context) context = []
     let results = _results
     if (!results) results = []
-  
+
     const addContext = (value, key) => {
       return this.getProperties(root, false, value, context.concat(key), results)
     }
@@ -2877,10 +2045,12 @@ Missing Value ${missingValue} - ${matchedString}
     // console.log('getValueFromSrc caller', caller)
     const propertyString = valueObject.value
     const pathValue = valueObject.path
+    // Cache joined path to avoid repeated array.join('.') calls
+    const pathJoined = pathValue && pathValue.length ? pathValue.join('.') : null
 
     // Track every call to getValueFromSource for metadata
-    if (pathValue && pathValue.length) {
-      const pathKey = pathValue.join('.')
+    if (this._trackCalls && pathJoined) {
+      const pathKey = pathJoined
       if (!this.resolutionTracking[pathKey]) {
         this.resolutionTracking[pathKey] = {
           path: pathKey,
@@ -2892,7 +2062,7 @@ Missing Value ${missingValue} - ${matchedString}
 
       // this.resolutionTracking[pathKey].resolutionHistory = this.resolutionTracking[pathKey].resolutionHistory || []
 
-      // const isDuplicate = this.resolutionTracking[pathKey].resolutionHistory.some(entry => 
+      // const isDuplicate = this.resolutionTracking[pathKey].resolutionHistory.some(entry =>
       //   entry.variableString === variableString
       // )
 
@@ -2917,7 +2087,7 @@ Missing Value ${missingValue} - ${matchedString}
     // console.log(`tracker contains ${variableString}`, this.tracker.contains(variableString))
 
     // Cycle detection: track dependencies and check for cycles
-    const fromPath = valueObject.path ? valueObject.path.join('.') : null
+    const fromPath = pathJoined
     // Extract target path from variableString (e.g., 'self:b' → 'b', 'b.c' → 'b.c')
     let toPath = variableString
     if (variableString.startsWith('self:')) {
@@ -3049,8 +2219,8 @@ Missing Value ${missingValue} - ${matchedString}
         valueObject,
       ).then((val) => {
         // Update the last call with the resolved value
-        if (pathValue && pathValue.length) {
-          const pathKey = pathValue.join('.')
+        if (this._trackCalls && pathJoined) {
+          const pathKey = pathJoined
           if (this.resolutionTracking[pathKey] && this.resolutionTracking[pathKey].calls.length) {
             // Find the most recent call for this variableString
             for (let i = this.resolutionTracking[pathKey].calls.length - 1; i >= 0; i--) {
@@ -3131,11 +2301,18 @@ Missing Value ${missingValue} - ${matchedString}
           }
 
           if (valueCount.length === 1 && noNestedVars) {
-            const configFilePathMsg = (this.configFilePath) ? `\nIn file ${this.configFilePath} ` : ''
+            let lineInfo = ''
+            if (this.originalString && this.configFilePath && valueObject.path) {
+              const ext = path.extname(this.configFilePath)
+              if (ext === '.yml' || ext === '.yaml' || ext === '.json') {
+                const rawLines = this.originalString.split('\n')
+                const lineNum = findLineByPath(arrayToJsonPath(valueObject.path), rawLines, ext)
+                if (lineNum) lineInfo = ` at line ${lineNum},`
+              }
+            }
+            const configFilePathMsg = (this.configFilePath) ? `\nIn file ${this.configFilePath}${lineInfo} ` : ''
             const fromLine = (propertyString !== valueObject.originalSource) ? `\n  From   "${valueObject.originalSource}"\n` : ''
 
-
-
             throw new Error(`Unable to resolve config variable "${propertyString}".\n${configFilePathMsg}at location ${valueObject.path ? `"${arrayToJsonPath(valueObject.path)}"` : 'n/a'}${fromLine}
 \nFix this reference, your inputs and/or provide a valid fallback value.
 \nExample of setting a fallback value: \${${variableString}, "fallbackValue"\}\n`)
@@ -3351,7 +2528,7 @@ Missing Value ${missingValue} - ${matchedString}
     }
 
     // Variable NOT FOUND. Warn user
-    const key = valueObject.path ? valueObject.path.join('.') : 'na'
+    const key = pathJoined || 'na'
     const errorMessage = [
       `Invalid variable reference syntax`,
       `Key: "${key}"`,
@@ -3395,21 +2572,11 @@ Missing Value ${missingValue} - ${matchedString}
 
     /* Pass through unknown variable types */
     if (allowSpecialCase || this.isUnknownTypeAllowed(propertyString)) {
-      // console.log('allowUnknownVars propertyString', propertyString)
-      const varMatches = propertyString.match(this.variableSyntax)
-      let allowUnknownVars = propertyString
-      /* Only encode variables that are actually unknown, not all of them */
-      if (varMatches && varMatches.length) {
-        varMatches.forEach((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)
-      // console.log('allowUnknownVars:', allowUnknownVars)
-      return Promise.resolve(allowUnknownVars)
+      // Return only the encoded current variable, not the whole propertyString.
+      // The caller substitutes this value at the matched position; returning the
+      // full property would re-insert the surrounding context (including this
+      // variable) and cause exponential string growth on subsequent passes.
+      return Promise.resolve(encodeUnknown(this.varPrefix + variableString + this.varSuffix))
     }
 
     const message = errorMessage.join('\n')